serein-flow/Library/ServiceContainer.cs

using Serein.Web;
using Microsoft.Win32;
using NetTaste;
using System.Collections.Concurrent;
using System.Reflection;
using System;
using System.Linq;
using System.Collections.Generic;
using SqlSugar;

namespace Serein
{


    public interface IServiceContainer
    {
        /// <summary>
        /// 获取或创建类型的实例（不注入依赖项）
        /// </summary>
        object GetOrCreateServiceInstance(Type serviceType, params object[] parameters);
        T CreateServiceInstance<T>(params object[] parameters);
        IServiceContainer Reset(); // 清空
        IServiceContainer Register(Type type, params object[] parameters);
        IServiceContainer Register<T>(params object[] parameters);
        IServiceContainer Register<TService, TImplementation>(params object[] parameters) where TImplementation : TService;
        T Get<T>();
        object Get(Type type);

        /// <summary>
        /// 创建目标类型的对象， 并注入依赖项
        /// </summary>
        object? Instantiate(Type type, params object[] parameters);
        IServiceContainer Build();
        IServiceContainer Run<T>(Action<T> action);
        IServiceContainer Run<T1, T2>(Action<T1, T2> action);
        IServiceContainer Run<T1, T2, T3>(Action<T1, T2, T3> action);
        IServiceContainer Run<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action);
        IServiceContainer Run<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action);
        IServiceContainer Run<T1, T2, T3, T4, T5, T6>(Action<T1, T2, T3, T4, T5, T6> action);
        IServiceContainer Run<T1, T2, T3, T4, T5, T6, T7>(Action<T1, T2, T3, T4, T5, T6, T7> action);
        IServiceContainer Run<T1, T2, T3, T4, T5, T6, T7, T8>(Action<T1, T2, T3, T4, T5, T6, T7, T8> action);
    }

    public class ServiceContainer : IServiceContainer
    {

        private readonly ConcurrentDictionary<string, object> _dependencies;
        private readonly ConcurrentDictionary<string, Type> _typeMappings;
        private readonly List<Type> _waitingForInstantiation;

        public ServiceContainer()
        {

            _dependencies = new ConcurrentDictionary<string, object>
            {
                [typeof(IServiceContainer).FullName] = this
            };

            _typeMappings = new ConcurrentDictionary<string, Type>();
            _waitingForInstantiation = [];
        }
        public object GetOrCreateServiceInstance(Type type, params object[] parameters)
        {
            Register(type);
            object instance;

            if (_dependencies.ContainsKey(type.FullName))
            {
                instance = _dependencies[type.FullName];
            }
            else
            {

                instance = Activator.CreateInstance(type);


                _dependencies[type.FullName] = instance;

            }


            return instance;

        }
        public T CreateServiceInstance<T>(params object[] parameters)
        {
            return (T)GetOrCreateServiceInstance(typeof(T), parameters);
        }

        public IServiceContainer Reset()
        {
            foreach(var instancei in _dependencies.Values)
            {
                if (typeof(IDisposable).IsAssignableFrom(instancei.GetType()) && instancei is IDisposable disposable)
                {
                    disposable.Dispose();
                }
            }
            _dependencies.Clear();
            _waitingForInstantiation.Clear();
            //_typeMappings.Clear();
            return this;
        }

        public IServiceContainer Register(Type type, params object[] parameters)
        {

            if (!_typeMappings.ContainsKey(type.FullName))
            {
                _typeMappings[type.FullName] = type;
            }

            return this;
        }
        public IServiceContainer Register<T>(params object[] parameters)
        {
            Register(typeof(T), parameters);
            return this;
        }

        public IServiceContainer Register<TService, TImplementation>(params object[] parameters)
            where TImplementation : TService
        {
            _typeMappings[typeof(TService).FullName!] = typeof(TImplementation);
            return this;
        }

        public object Get(Type type)
        {


            if (!_dependencies.TryGetValue(type.FullName, out object value))
            {
                Register(type);

                value = Instantiate(type);

                InjectDependencies(type);
            }



            return value;

        }


        public T Get<T>()
        {


            if(!_dependencies.TryGetValue(typeof(T).FullName, out object value))
            {
                Register<T>();

                value = Instantiate(typeof(T));

            }




            return (T)value;


            //throw new InvalidOperationException("目标类型未创建实例");
        }
        public IServiceContainer Build()
        {
            foreach (var type in _typeMappings.Values)
            {

                if(!_dependencies.ContainsKey(type.FullName))
                {

                    _dependencies[type.FullName] = Activator.CreateInstance(type);

                }

            }

            foreach (var instance in _dependencies.Values)
            {

                InjectDependencies(instance); // 替换占位符
            }

            //var instance = Instantiate(item.Value);

            TryInstantiateWaitingDependencies();
            return this;
        }

        public object? Instantiate(Type controllerType, params object[] parameters)
        {
            var instance = Activator.CreateInstance(controllerType, parameters);
            if(instance != null)
            {
                InjectDependencies(instance);
            }
            return instance;
        }

        private void InjectDependencies(object instance)
        {
            var properties = instance.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public)
                                              .Where(p => p.CanWrite && p.GetCustomAttribute<AutoInjectionAttribute>() != null);

            foreach (var property in properties)
            {
                var propertyType = property.PropertyType;

                if (_dependencies.TryGetValue(propertyType.FullName, out var dependencyInstance))
                {
                    property.SetValue(instance, dependencyInstance);
                }

            }
        }

        private void TryInstantiateWaitingDependencies()
        {
            foreach (var waitingType in _waitingForInstantiation.ToList())
            {
                if (_typeMappings.TryGetValue(waitingType.FullName!, out var implementationType))
                {
                    var instance = Instantiate(implementationType);
                    if (instance != null)
                    {

                        _dependencies[waitingType.FullName] = instance;

                        _waitingForInstantiation.Remove(waitingType);
                    }
                }
            }
        }

        #region run()
        public IServiceContainer Run<T>(Action<T> action)
        {
            var service = Get<T>();
            if (service != null)
            {
                action(service);
            }
            return this;
        }

        public IServiceContainer Run<T1, T2>(Action<T1, T2> action)
        {
            var service1 = Get<T1>();
            var service2 = Get<T2>();

            action(service1, service2);
            return this;
        }

        public IServiceContainer Run<T1, T2, T3>(Action<T1, T2, T3> action)
        {
            var service1 = Get<T1>();
            var service2 = Get<T2>();
            var service3 = Get<T3>();
            action(service1, service2, service3);
            return this;
        }

        public IServiceContainer Run<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action)
        {
            var service1 = Get<T1>();
            var service2 = Get<T2>();
            var service3 = Get<T3>();
            var service4 = Get<T4>();
            action(service1, service2, service3, service4);
            return this;
        }

        public IServiceContainer Run<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action)
        {
            var service1 = Get<T1>();
            var service2 = Get<T2>();
            var service3 = Get<T3>();
            var service4 = Get<T4>();
            var service5 = Get<T5>();
            action(service1, service2, service3, service4, service5);
            return this;
        }

        public IServiceContainer Run<T1, T2, T3, T4, T5, T6>(Action<T1, T2, T3, T4, T5, T6> action)
        {
            var service1 = Get<T1>();
            var service2 = Get<T2>();
            var service3 = Get<T3>();
            var service4 = Get<T4>();
            var service5 = Get<T5>();
            var service6 = Get<T6>();
            action(service1, service2, service3, service4, service5, service6);
            return this;
        }

        public IServiceContainer Run<T1, T2, T3, T4, T5, T6, T7>(Action<T1, T2, T3, T4, T5, T6, T7> action)
        {
            var service1 = Get<T1>();
            var service2 = Get<T2>();
            var service3 = Get<T3>();
            var service4 = Get<T4>();
            var service5 = Get<T5>();
            var service6 = Get<T6>();
            var service7 = Get<T7>();
            action(service1, service2, service3, service4, service5, service6, service7);
            return this;
        }

        public IServiceContainer Run<T1, T2, T3, T4, T5, T6, T7, T8>(Action<T1, T2, T3, T4, T5, T6, T7, T8> action)
        {
            var service1 = Get<T1>();
            var service2 = Get<T2>();
            var service3 = Get<T3>();
            var service4 = Get<T4>();
            var service5 = Get<T5>();
            var service6 = Get<T6>();
            var service7 = Get<T7>();
            var service8 = Get<T8>();
            action(service1, service2, service3, service4, service5, service6, service7, service8);
            return this;
        }

        #endregion
    }


    /* public interface IServiceContainer
     {
         ServiceContainer Register<T>(params object[] parameters);
         ServiceContainer Register<TService, TImplementation>(params object[] parameters) where TImplementation : TService;
         TService Resolve<TService>();
         void Get<T>(Action<T> action);
         object Instantiate(Type type, params object[] parameters);

     }
     public class ServiceContainer : IServiceContainer
     {
         private readonly Dictionary<Type, object> _dependencies;
         public ServiceContainer()
         {
             _dependencies = new Dictionary<Type, object>
             {
                 [typeof(IServiceContainer)] = this
             };
         }

         public void Get<T>(Action<T> action)
         {
             var service = Resolve<T>();
             action(service);
         }
         public ServiceContainer Register<T>(params object[] parameters)
         {
             var instance = Instantiate(typeof(T), parameters);
             _dependencies[typeof(T)] = instance;
             return this;
         }

         public ServiceContainer Register<TService, TImplementation>(params object[] parameters)
             where TImplementation : TService
         {

             _dependencies[typeof(TService)] = Instantiate(typeof(TImplementation), parameters);
             return this;
         }


         public TService Resolve<TService>()
         {
             return (TService)_dependencies[typeof(TService)];
         }

         public object Instantiate(Type controllerType, params object[] parameters)
         {
             var constructors = controllerType.GetConstructors(); // 获取控制器的所有构造函数

             // 查找具有最多参数的构造函数
             var constructor = constructors.OrderByDescending(c => c.GetParameters().Length).FirstOrDefault();

             if (constructor != null)
             {
                 if (parameters.Length > 0)
                 {
                     return Activator.CreateInstance(controllerType, parameters);
                 }
                 else {
                     var tmpParameters = constructor.GetParameters();
                     var dependencyInstances = new List<object>();

                     foreach (var parameter in tmpParameters)
                     {
                         var parameterType = parameter.ParameterType;
                         _dependencies.TryGetValue(parameterType, out var dependencyInstance);
                         dependencyInstances.Add(dependencyInstance);
                         if (dependencyInstance == null)
                         {
                             return null;
                         }
                     }
                     // 用解析的依赖项实例化目标类型
                     return Activator.CreateInstance(controllerType, dependencyInstances.ToArray());
                 }
             }
             else
             {
                 return Activator.CreateInstance(controllerType);
             }
         }
     }*/



}