DreamineContainer.cs

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

using System;
using System.Collections.Generic;
using System.Threading;
using Dreamine.MVVM.Interfaces.DependencyInjection;
 
namespace Dreamine.MVVM.Core.DependencyInjection
{
    public sealed class DreamineContainer : IServiceContainer, IDisposable
    {
        private readonly Dictionary<Type, ServiceDescriptor> _descriptors = new();
        private readonly Dictionary<Type, object> _singletonInstances = new();
        private readonly AsyncLocal<ResolutionContext?> _currentResolutionContext = new();
        private readonly IObjectActivator _objectActivator;
        private readonly object _syncRoot = new();
        private bool _disposed;

        public DreamineContainer()
            : this(new ConstructorActivator(new ConstructorSelector()))
        {
        }

        public DreamineContainer(IObjectActivator objectActivator)
        {
            _objectActivator = objectActivator
                ?? throw new ArgumentNullException(nameof(objectActivator));
        }

        public void Register<TImplementation>()
            where TImplementation : class
        {
            Register<TImplementation, TImplementation>();
        }

        public void Register<TService, TImplementation>()
            where TService : class
            where TImplementation : class, TService
        {
            Type serviceType = typeof(TService);
            Type implementationType = typeof(TImplementation);
 
            lock (_syncRoot)
            {
                _descriptors[serviceType] = new ServiceDescriptor(
                    serviceType,
                    implementationType,
                    factory: null,
                    instance: null,
                    lifetime: ServiceLifetime.Transient);
                _singletonInstances.Remove(serviceType);
            }
        }

        public void Register<TService>(Func<TService> factory)
            where TService : class
        {
            if (factory is null)
            {
                throw new ArgumentNullException(nameof(factory));
            }
 
            Type serviceType = typeof(TService);
 
            lock (_syncRoot)
            {
                _descriptors[serviceType] = new ServiceDescriptor(
                    serviceType,
                    implementationType: null,
                    factory: () => factory(),
                    instance: null,
                    lifetime: ServiceLifetime.Transient);
                _singletonInstances.Remove(serviceType);
            }
        }

        public void RegisterSingleton<TService>(TService instance)
            where TService : class
        {
            if (instance is null)
            {
                throw new ArgumentNullException(nameof(instance));
            }
 
            Type serviceType = typeof(TService);
 
            lock (_syncRoot)
            {
                _descriptors[serviceType] = new ServiceDescriptor(
                    serviceType,
                    instance.GetType(),
                    factory: null,
                    instance,
                    lifetime: ServiceLifetime.Singleton);
 
                _singletonInstances[serviceType] = instance;
            }
        }

        public void RegisterSingleton<TImplementation>()
            where TImplementation : class
        {
            RegisterSingleton<TImplementation, TImplementation>();
        }

        public void RegisterSingleton<TService, TImplementation>()
            where TService : class
            where TImplementation : class, TService
        {
            Type serviceType = typeof(TService);
            Type implementationType = typeof(TImplementation);
 
            lock (_syncRoot)
            {
                _descriptors[serviceType] = new ServiceDescriptor(
                    serviceType,
                    implementationType,
                    factory: null,
                    instance: null,
                    lifetime: ServiceLifetime.Singleton);
                _singletonInstances.Remove(serviceType);
            }
        }

        public bool IsRegistered(Type serviceType)
        {
            if (serviceType is null)
            {
                throw new ArgumentNullException(nameof(serviceType));
            }
 
            lock (_syncRoot)
            {
                return _descriptors.ContainsKey(serviceType);
            }
        }

        public TService Resolve<TService>()
            where TService : class
        {
            return (TService)Resolve(typeof(TService));
        }

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

        public object Resolve(Type serviceType)
        {
            if (serviceType is null)
            {
                throw new ArgumentNullException(nameof(serviceType));
            }
 
            // AsyncLocal context setup is per-async-flow and must live outside the lock
            // so that nested Resolve calls on the same flow see the same context
            // without requiring lock re-entry ordering to be preserved.
            ResolutionContext? previousContext = _currentResolutionContext.Value;
            bool ownsContext = previousContext is null;
            if (ownsContext)
            {
                _currentResolutionContext.Value = new ResolutionContext();
            }
 
            try
            {
                lock (_syncRoot)
                {
                    return ResolveCore(serviceType);
                }
            }
            finally
            {
                if (ownsContext)
                {
                    _currentResolutionContext.Value = null;
                }
            }
        }

        private object ResolveCore(Type serviceType)
        {
            if (_singletonInstances.TryGetValue(serviceType, out object? singleton))
            {
                return singleton;
            }
 
            if (!_descriptors.TryGetValue(serviceType, out ServiceDescriptor? descriptor))
            {
                if (CanCreateUnregisteredConcreteType(serviceType))
                {
                    return CreateConcrete(serviceType);
                }
 
                throw new InvalidOperationException(
                    $"Service [{serviceType.FullName}] is not registered.");
            }
 
            if (descriptor.Factory is not null)
            {
                return descriptor.Factory();
            }
 
            if (descriptor.Instance is not null)
            {
                return descriptor.Instance;
            }
 
            if (descriptor.ImplementationType is null)
            {
                throw new InvalidOperationException(
                    $"Service [{serviceType.FullName}] has no implementation type.");
            }
 
            object instance = CreateConcrete(descriptor.ImplementationType);
 
            if (descriptor.Lifetime == ServiceLifetime.Singleton)
            {
                _singletonInstances[serviceType] = instance;
            }
 
            return instance;
        }

        private object CreateConcrete(Type implementationType)
        {
            ResolutionContext context = _currentResolutionContext.Value ?? new ResolutionContext();
            if (!context.TryEnter(implementationType))
            {
                throw new InvalidOperationException(
                    $"Circular dependency detected while resolving [{implementationType.FullName}].");
            }
 
            try
            {
                return _objectActivator.CreateInstance(implementationType, this);
            }
            finally
            {
                context.Exit(implementationType);
            }
        }

        public void Dispose()
        {
            List<object> toDispose;
 
            lock (_syncRoot)
            {
                if (_disposed)
                {
                    return;
                }
 
                _disposed = true;
                toDispose = new List<object>(_singletonInstances.Values);
                _singletonInstances.Clear();
                _descriptors.Clear();
            }
 
            foreach (object instance in toDispose)
            {
                if (instance is IDisposable disposable)
                {
                    disposable.Dispose();
                }
            }
        }

        private static bool CanCreateUnregisteredConcreteType(Type type)
        {
            return type.IsClass &&
                   !type.IsAbstract &&
                   !type.IsGenericTypeDefinition;
        }
    }
}