ViewModelLocator.cs

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

using Dreamine.MVVM.Interfaces.Locators;
using System.Reflection;
 
namespace Dreamine.MVVM.Locators
{
    public static class ViewModelLocator
    {
        private static readonly object _syncRoot = new();
        private static readonly Dictionary<Type, Type> _map = new(32);
        private static readonly Dictionary<Type, Type?> _viewModelTypeCache = new(32);
        private static readonly Dictionary<Type, Type?> _viewTypeCache = new(32);
        private static IViewModelResolver? _resolver;
        private static Type[]? _allLoadableTypesCache;

        static ViewModelLocator()
        {
            AppDomain.CurrentDomain.AssemblyLoad += (_, _) => ClearTypeCache();
        }

        public static void Register(Type viewType, Type viewModelType)
        {
            ArgumentNullException.ThrowIfNull(viewType);
            ArgumentNullException.ThrowIfNull(viewModelType);
 
            lock (_syncRoot)
            {
                _map[viewType] = viewModelType;
                _viewModelTypeCache[viewType] = viewModelType;
            }
        }

        public static void RegisterResolver(IViewModelResolver resolver)
        {
            ArgumentNullException.ThrowIfNull(resolver);
 
            lock (_syncRoot)
            {
                _resolver = resolver;
            }
        }

        public static void ClearResolver()
        {
            lock (_syncRoot)
            {
                _resolver = null;
            }
        }

        public static void Clear()
        {
            lock (_syncRoot)
            {
                _map.Clear();
                _viewModelTypeCache.Clear();
                _viewTypeCache.Clear();
                _allLoadableTypesCache = null;
            }
        }

        public static void Reset()
        {
            lock (_syncRoot)
            {
                _map.Clear();
                _viewModelTypeCache.Clear();
                _viewTypeCache.Clear();
                _allLoadableTypesCache = null;
                _resolver = null;
            }
        }

        public static object? Resolve(Type viewType)
        {
            ArgumentNullException.ThrowIfNull(viewType);
 
            Type? mappedType;
            lock (_syncRoot)
            {
                _map.TryGetValue(viewType, out mappedType);
            }
 
            if (mappedType is not null)
            {
                return CreateInstance(mappedType);
            }
 
            Type? resolvedType = FindViewModelType(viewType);
            if (resolvedType is null)
            {
                return null;
            }
 
            Register(viewType, resolvedType);
            return CreateInstance(resolvedType);
        }

        public static object? ResolveView(Type viewModelType)
        {
            ArgumentNullException.ThrowIfNull(viewModelType);
 
            Type? viewType = FindViewType(viewModelType);
            return viewType != null
                ? Activator.CreateInstance(viewType)
                : null;
        }

        public static void RegisterAll(Assembly assembly)
        {
            ArgumentNullException.ThrowIfNull(assembly);
 
            Type[] allTypes = GetLoadableTypes(assembly)
                .Where(t => t is { IsClass: true, IsAbstract: false })
                .ToArray();
 
            IEnumerable<Type> viewCandidates = allTypes.Where(ViewNamingConvention.IsLikelyViewType);
 
            foreach (Type viewType in viewCandidates)
            {
                bool alreadyRegistered;
                lock (_syncRoot)
                {
                    alreadyRegistered = _map.ContainsKey(viewType);
                }
 
                if (alreadyRegistered)
                {
                    continue;
                }
 
                Type? viewModelType = FindViewModelType(viewType, allTypes);
                if (viewModelType != null)
                {
                    Register(viewType, viewModelType);
                }
            }
        }

        private static Type? FindViewModelType(Type viewType, Type[]? cachedTypes = null)
        {
            if (cachedTypes is null)
            {
                lock (_syncRoot)
                {
                    if (_viewModelTypeCache.TryGetValue(viewType, out Type? cachedViewModelType))
                    {
                        return cachedViewModelType;
                    }
                }
            }
 
            Type[] allTypes = cachedTypes ?? GetAllLoadableTypes();
            string[] candidateNames = ViewNamingConvention.GetViewModelTypeNameCandidates(viewType);
 
            foreach (string candidateName in candidateNames)
            {
                Type? match = allTypes.FirstOrDefault(t =>
                    t.FullName == candidateName ||
                    t.Name == candidateName);
 
                if (match != null)
                {
                    if (cachedTypes is null)
                    {
                        lock (_syncRoot)
                        {
                            _viewModelTypeCache[viewType] = match;
                        }
                    }
 
                    return match;
                }
            }
 
            if (cachedTypes is null)
            {
                lock (_syncRoot)
                {
                    _viewModelTypeCache[viewType] = null;
                }
            }
 
            return null;
        }

        private static Type[] GetAllLoadableTypes()
        {
            lock (_syncRoot)
            {
                if (_allLoadableTypesCache is not null)
                {
                    return _allLoadableTypesCache;
                }
            }
 
            Type[] types = AppDomain.CurrentDomain
                    .GetAssemblies()
                    .Where(assembly => !assembly.IsDynamic)
                    .SelectMany(GetLoadableTypes)
                    .Where(type => type is { IsClass: true, IsAbstract: false })
                    .ToArray();
 
            lock (_syncRoot)
            {
                _allLoadableTypesCache ??= types;
                return _allLoadableTypesCache;
            }
        }

        private static IEnumerable<Type> GetLoadableTypes(Assembly assembly)
        {
            try
            {
                return assembly.GetTypes();
            }
            catch (ReflectionTypeLoadException ex)
            {
                return ex.Types.Where(type => type != null)!;
            }
            catch
            {
                return Array.Empty<Type>();
            }
        }

        private static Type? FindViewType(Type viewModelType)
        {
            lock (_syncRoot)
            {
                if (_viewTypeCache.TryGetValue(viewModelType, out Type? cachedViewType))
                {
                    return cachedViewType;
                }
            }
 
            Type[] allTypes = GetAllLoadableTypes();
            string[] candidateNames = ViewNamingConvention.GetViewTypeNameCandidates(viewModelType);
 
            foreach (string candidateName in candidateNames)
            {
                Type? match = allTypes.FirstOrDefault(t =>
                    t.FullName == candidateName ||
                    t.Name == candidateName);
 
                if (match != null)
                {
                    lock (_syncRoot)
                    {
                        _viewTypeCache[viewModelType] = match;
                    }
 
                    return match;
                }
            }
 
            lock (_syncRoot)
            {
                _viewTypeCache[viewModelType] = null;
            }
 
            return null;
        }

        private static object? CreateInstance(Type type)
        {
            System.Diagnostics.Debug.WriteLine($"[ViewModelLocator] CreateInstance: {type.FullName}");
 
            IViewModelResolver? resolver;
            lock (_syncRoot)
            {
                resolver = _resolver;
            }
 
            if (resolver is null)
            {
                throw new InvalidOperationException(
                    $"Cannot resolve ViewModel [{type.FullName}] because no ViewModel resolver is configured. " +
                    "Call ViewModelLocator.RegisterResolver(...) or configure DreamineAppBuilder to use the default DMContainer resolver.");
            }
 
            var resolved = resolver.Resolve(type);
            if (resolved is not null)
            {
                return resolved;
            }
 
            throw new InvalidOperationException(
                $"Cannot resolve ViewModel [{type.FullName}]. " +
                "The type was not resolved by the configured resolver. " +
                "Register the ViewModel in the configured container or replace the ViewModelLocator resolver.");
        }

        private static void ClearTypeCache()
        {
            lock (_syncRoot)
            {
                _viewModelTypeCache.Clear();
                _viewTypeCache.Clear();
                _allLoadableTypesCache = null;
            }
        }
    }
}