DreamineAppBuilder.cs

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

using Dreamine.MVVM.Core;
using Dreamine.MVVM.Core.Locators;
using Dreamine.MVVM.Interfaces.Navigation;
using Dreamine.MVVM.Interfaces.Windows;
using Dreamine.MVVM.Locators;
using Dreamine.MVVM.Locators.Wpf;
using System;
using System.Reflection;
using System.Windows;
using System.Windows.Controls;
 
namespace Dreamine.MVVM.Wpf
{
    public static class DreamineAppBuilder
    {
        private static readonly object SyncRoot = new();
        private static bool _globalAutoWireHandlerRegistered;
        private static bool _autoNavigatorHandlerRegistered;

        public static void Initialize(Assembly rootAssembly)
        {
            Initialize(rootAssembly, DreamineWpfOptions.CreateDefault());
        }

        public static void Initialize(Assembly rootAssembly, DreamineWpfOptions options)
        {
            ArgumentNullException.ThrowIfNull(rootAssembly);
            ArgumentNullException.ThrowIfNull(options);
 
            if (options.RegisterDefaultServices)
            {
                RegisterDefaultServices(options);
            }
 
            RegisterDefaultViewModelResolver();
 
            // ① DI 자동 등록
            DreamineAutoRegistrar.RegisterAll(rootAssembly);
 
            // ② View ↔ ViewModel 자동 매핑
            ViewModelLocator.RegisterAll(rootAssembly);
 
            // ③ 선택적 Loaded 기반 ViewModel 자동 주입
            if (options.EnableGlobalAutoWireOnLoaded)
            {
                RegisterGlobalAutoWireHandlerOnce();
            }
 
            // ④ 선택적 Region 기반 INavigator 자동 등록
            if (options.EnableAutoNavigatorRegistration)
            {
                RegisterAutoNavigatorHandlerOnce(options.DefaultRegionName);
            }
        }

        private static void RegisterDefaultViewModelResolver()
        {
            ViewModelLocator.RegisterResolver(
                new DreamineContainerViewModelResolver());
        }

        public static void RegisterDefaultServices(DreamineWpfOptions? options = null)
        {
            if (!DMContainer.IsRegistered<IWindowStateService>())
            {
                DMContainer.RegisterSingleton<IWindowStateService, WindowStateService>();
            }
 
            if (!DMContainer.IsRegistered<IViewManager>())
            {
                var vm = options is not null
                    ? new ViewManager(DMContainer.GetResolver(),
                        options.FallbackWindowWidth,
                        options.FallbackWindowHeight)
                    : new ViewManager();
                DMContainer.RegisterSingleton<IViewManager>(vm);
            }
 
            if (!DMContainer.IsRegistered<IDialogService>())
            {
                DMContainer.RegisterSingleton<IDialogService, WpfDialogService>();
            }
        }

        public static void RegisterGlobalAutoWireHandlerOnce()
        {
            lock (SyncRoot)
            {
                if (_globalAutoWireHandlerRegistered)
                {
                    return;
                }
 
                EventManager.RegisterClassHandler(
                    typeof(FrameworkElement),
                    FrameworkElement.LoadedEvent,
                    new RoutedEventHandler(AttachViewModelIfExists));
 
                _globalAutoWireHandlerRegistered = true;
            }
        }

        public static void RegisterAutoNavigatorHandlerOnce(string defaultRegionName)
        {
            if (string.IsNullOrWhiteSpace(defaultRegionName))
            {
                throw new ArgumentException("Default region name must not be empty.", nameof(defaultRegionName));
            }
 
            lock (SyncRoot)
            {
                if (_autoNavigatorHandlerRegistered)
                {
                    return;
                }
 
                EventManager.RegisterClassHandler(
                    typeof(Window),
                    FrameworkElement.LoadedEvent,
                    new RoutedEventHandler((sender, _) =>
                    {
                        if (sender is Window window)
                        {
                            RegisterNavigatorFromWindow(window, defaultRegionName);
                        }
                    }));
 
                _autoNavigatorHandlerRegistered = true;
            }
        }

        public static void RegisterNavigatorFromWindow(Window window, string regionName)
        {
            ArgumentNullException.ThrowIfNull(window);
 
            if (string.IsNullOrWhiteSpace(regionName))
            {
                throw new ArgumentException("Region name must not be empty.", nameof(regionName));
            }
 
            ContentControl? region = RegionBinderHelper.FindRegionControl(window, regionName);
            if (region is null)
            {
                return;
            }
 
            DMContainer.RegisterSingleton<INavigator>(
                new ContentControlNavigator(region));
        }

        private static void AttachViewModelIfExists(object sender, RoutedEventArgs e)
        {
            if (sender is not FrameworkElement view)
            {
                return;
            }
 
            if (view.DataContext is not null)
            {
                return;
            }
 
            if (view is not Window && view is not UserControl && view is not Page)
            {
                return;
            }
 
            object? viewModel = ViewModelLocator.Resolve(view.GetType());
            if (viewModel is not null)
            {
                view.DataContext = viewModel;
            }
        }
    }
}