ViewManager.cs

이 파일의 문서화 페이지로 가기

using Dreamine.MVVM.Core;
using Dreamine.MVVM.Interfaces.DependencyInjection;
using Dreamine.MVVM.Interfaces.Navigation;
using Dreamine.MVVM.Interfaces.Windows;
using Dreamine.MVVM.Locators;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Windows;
using System.Windows.Controls;
 
namespace Dreamine.MVVM.Wpf
{
    public sealed class ViewManager : IViewManager
    {
        private readonly IServiceResolver _resolver;
        private readonly List<IViewDisplayStrategy> _customStrategies = new();
        private readonly double _fallbackWindowWidth;
        private readonly double _fallbackWindowHeight;

        public ViewManager(IServiceResolver resolver, double fallbackWindowWidth = 800, double fallbackWindowHeight = 600)
        {
            _resolver = resolver ?? throw new ArgumentNullException(nameof(resolver));
            _fallbackWindowWidth = fallbackWindowWidth > 0 ? fallbackWindowWidth : 800;
            _fallbackWindowHeight = fallbackWindowHeight > 0 ? fallbackWindowHeight : 600;
        }

        public ViewManager() : this(DMContainer.GetResolver())
        {
        }

        public void RegisterDisplayStrategy(IViewDisplayStrategy strategy)
        {
            ArgumentNullException.ThrowIfNull(strategy);
            _customStrategies.Add(strategy);
        }

        public void Show<TViewModel>() where TViewModel : class
        {
            Show(typeof(TViewModel));
        }

        public void Show(Type viewModelType)
        {
            ArgumentNullException.ThrowIfNull(viewModelType);
 
            object viewModel = _resolver.Resolve(viewModelType);
            object? view = ViewModelLocator.ResolveView(viewModelType);
            DisplayResolvedView(view, viewModel, viewModelType, useRegionNavigator: true);
        }

        public void Navigate(object viewModel)
        {
            ArgumentNullException.ThrowIfNull(viewModel);
 
            Type viewModelType = viewModel.GetType();
            object? view = ViewModelLocator.ResolveView(viewModelType);
            DisplayResolvedView(view, viewModel, viewModelType, useRegionNavigator: false);
        }

        private void DisplayResolvedView(
            object? view,
            object viewModel,
            Type viewModelType,
            bool useRegionNavigator)
        {
            if (view is null)
            {
                Debug.WriteLine(
                    $"[ViewManager] No view found for {viewModelType.FullName}. " +
                    "Ensure the view is registered via ViewModelLocator.Register<TView, TViewModel>().");
                return;
            }
 
            // Custom strategies take precedence — checked before built-in WPF types.
            foreach (var strategy in _customStrategies)
            {
                if (strategy.CanHandle(view))
                {
                    strategy.Display(view, viewModel, viewModelType, useRegionNavigator);
                    return;
                }
            }
 
            // Built-in WPF type handling.
            switch (view)
            {
                case Window window:
                    ShowWindow(window, viewModel, viewModelType);
                    break;
 
                case UserControl userControl:
                    ShowUserControl(userControl, viewModel, useRegionNavigator);
                    break;
 
                case Page page:
                    ShowPage(page, viewModel, useRegionNavigator);
                    break;
 
                default:
                    Debug.WriteLine(
                        $"[ViewManager] No display strategy found for view type {view.GetType().FullName}. " +
                        "Register a custom IViewDisplayStrategy via RegisterDisplayStrategy().");
                    break;
            }
        }

        private void ShowWindow(Window window, object viewModel, Type viewModelType)
        {
            string windowKey = GetViewKey(viewModelType);
            IWindowStateService? windowStateService = TryResolve<IWindowStateService>();
 
            if (windowStateService?.IsOpen(windowKey) == true)
            {
                ActivateExistingWindow(windowKey);
                return;
            }
 
            window.DataContext = viewModel;
 
            // 메인 윈도우를 Owner로 지정합니다.
            // WPF는 Owner가 닫힐 때 소유된 모든 창을 자동으로 닫아주므로
            // 메인 창 종료 시 팝업이 남아있는 문제를 방지합니다.
            var mainWindow = Application.Current?.MainWindow;
            if (mainWindow is not null && mainWindow != window && mainWindow.IsLoaded)
            {
                window.Owner = mainWindow;
            }
 
            windowStateService?.MarkOpened(windowKey);
 
            window.Closed += (_, _) =>
            {
                windowStateService?.MarkClosed(windowKey);
            };
 
            window.Show();
        }

        private void ShowUserControl(UserControl userControl, object viewModel, bool useRegionNavigator)
        {
            userControl.DataContext = viewModel;
 
            INavigator? navigator = useRegionNavigator ? TryResolve<INavigator>() : null;
            if (navigator is not null && navigator is not ViewManager)
            {
                navigator.Navigate(viewModel);
                return;
            }
 
            new Window
            {
                Content = userControl,
                Width = _fallbackWindowWidth,
                Height = _fallbackWindowHeight
            }.Show();
        }

        private void ShowPage(Page page, object viewModel, bool useRegionNavigator)
        {
            page.DataContext = viewModel;
 
            INavigator? navigator = useRegionNavigator ? TryResolve<INavigator>() : null;
            if (navigator is not null && navigator is not ViewManager)
            {
                navigator.Navigate(viewModel);
                return;
            }
 
            new Window
            {
                Content = page,
                Width = _fallbackWindowWidth,
                Height = _fallbackWindowHeight
            }.Show();
        }

        private static void ActivateExistingWindow(string windowKey)
        {
            foreach (Window window in Application.Current.Windows)
            {
                if (GetViewKey(window.GetType()) == windowKey)
                {
                    window.Activate();
                    return;
                }
 
                if (window.DataContext is not null &&
                    GetViewKey(window.DataContext.GetType()) == windowKey)
                {
                    window.Activate();
                    return;
                }
            }
        }

        private static string GetViewKey(Type type)
        {
            string name = type.Name;
 
            if (name.EndsWith("ViewModel", StringComparison.Ordinal))
                return name[..^"ViewModel".Length];
 
            if (name.EndsWith("Window", StringComparison.Ordinal))
                return name[..^"Window".Length];
 
            if (name.EndsWith("View", StringComparison.Ordinal))
                return name[..^"View".Length];
 
            if (name.EndsWith("Page", StringComparison.Ordinal))
                return name[..^"Page".Length];
 
            return name;
        }

        private T? TryResolve<T>() where T : class
        {
            _resolver.TryResolve<T>(out var result);
            return result;
        }
    }
}