DMContainer.cs

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

using System;
using System.Reflection;
using Dreamine.MVVM.Core.DependencyInjection;
using Dreamine.MVVM.Interfaces.DependencyInjection;
 
namespace Dreamine.MVVM.Core
{
    public static partial class DMContainer
    {
        private static readonly object SyncRoot = new();
        private static IServiceContainer Container = CreateDefaultContainer();
 
        // Self-registers IServiceResolver so that ViewManager(IServiceResolver) and other
        // constructor-injected types can be resolved by DreamineContainer without an
        // explicit registration call from application startup code.
        private static DreamineContainer CreateDefaultContainer()
        {
            var c = new DreamineContainer();
            c.RegisterSingleton<IServiceResolver>(c);
            return c;
        }

        internal static IServiceRegistry GetRegistry()
        {
            lock (SyncRoot) { return Container; }
        }

        public static IServiceResolver GetResolver()
        {
            lock (SyncRoot) { return Container; }
        }
 

        public static void SetContainer(IServiceContainer container)
        {
            ArgumentNullException.ThrowIfNull(container);
 
            lock (SyncRoot)
            {
                Container = container;
            }
        }

        public static void Reset()
        {
            IServiceContainer previous;
 
            lock (SyncRoot)
            {
                previous = Container;
                Container = CreateDefaultContainer();
            }
 
            (previous as IDisposable)?.Dispose();
        }

        public static void Register<TImplementation>()
            where TImplementation : class
        {
            lock (SyncRoot)
            {
                Container.Register<TImplementation>();
            }
        }

        public static void Register<TService, TImplementation>()
            where TService : class
            where TImplementation : class, TService
        {
            lock (SyncRoot)
            {
                Container.Register<TService, TImplementation>();
            }
        }

        public static void Register<TService>(Func<TService> factory)
            where TService : class
        {
            lock (SyncRoot)
            {
                Container.Register(factory);
            }
        }

        public static void RegisterSingleton<TService>(TService instance)
            where TService : class
        {
            lock (SyncRoot)
            {
                Container.RegisterSingleton(instance);
            }
        }

        public static void RegisterSingleton<TImplementation>()
            where TImplementation : class
        {
            lock (SyncRoot)
            {
                Container.RegisterSingleton<TImplementation>();
            }
        }

        public static void RegisterSingleton<TService, TImplementation>()
            where TService : class
            where TImplementation : class, TService
        {
            lock (SyncRoot)
            {
                Container.RegisterSingleton<TService, TImplementation>();
            }
        }

        public static TService Resolve<TService>()
            where TService : class
        {
            lock (SyncRoot)
            {
                return Container.Resolve<TService>();
            }
        }

        public static object Resolve(Type type)
        {
            ArgumentNullException.ThrowIfNull(type);
 
            lock (SyncRoot)
            {
                return Container.Resolve(type);
            }
        }

        public static bool TryResolve<TService>(out TService? result)
            where TService : class
        {
            try
            {
                lock (SyncRoot)
                {
                    result = Container.Resolve<TService>();
                    return true;
                }
            }
            catch (InvalidOperationException)
            {
                result = null;
                return false;
            }
        }

        [System.Obsolete("Use DreamineAutoRegistrar.RegisterAll(rootAssembly, DMContainer) instead.")]
        public static void AutoRegisterAll(Assembly rootAssembly)
        {
            DreamineAutoRegistrar.RegisterAll(rootAssembly, Container);
        }

        public static bool IsRegistered<TService>()
        {
            lock (SyncRoot)
            {
                return Container.IsRegistered(typeof(TService));
            }
        }

        public static bool IsRegistered(Type serviceType)
        {
            ArgumentNullException.ThrowIfNull(serviceType);
 
            lock (SyncRoot)
            {
                return Container.IsRegistered(serviceType);
            }
        }
    }
}