使用emit代替表达式树构造委托。

内置了websocket server与相应的导航功能，可在实例工程中找到相应的实现。

Library/Utils/EmitHelper.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Serein.Library.Utils
+{
+    public class EmitHelper
+    {
+        public enum EmitMethodType
+        {
+            Func,
+            Task,
+            HasResultTask,
+        }
+        public static bool IsGenericTask(Type returnType, out Type taskResult)
+        {
+            // 判断是否为 Task 类型或泛型 Task<T>
+            if (returnType == typeof(Task))
+            {
+                taskResult = null;
+                return true;
+            }
+            else if (returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task<>))
+            {
+                // 获取泛型参数类型
+                Type genericArgument = returnType.GetGenericArguments()[0];
+                taskResult = genericArgument;
+                return true;
+            }
+            else
+            {
+                taskResult = null;
+                return false;
+
+            }
+        }
+        //public static Delegate CreateDynamicMethod<T>(MethodInfo methodInfo)
+        //{
+        //    return CreateDynamicMethod(methodInfo);
+        //}
+
+        public static EmitMethodType CreateDynamicMethod( MethodInfo methodInfo,out Delegate @delegate)
+        {
+            bool IsTask = IsGenericTask(methodInfo.ReturnType, out var taskGenericsType);
+            bool IsTaskGenerics = taskGenericsType != null;
+            DynamicMethod dynamicMethod;
+            if (IsTask)
+            {
+                if (IsTaskGenerics)
+                {
+
+                    dynamicMethod = new DynamicMethod(
+                           name: methodInfo.Name + "_DynamicMethod",
+                           returnType: typeof(Task<object>),
+                           parameterTypes: new[] { typeof(object), typeof(object[]) },
+                           restrictedSkipVisibility: true // 跳过私有方法访问限制
+                     );
+                }
+                else
+                {
+                    dynamicMethod = new DynamicMethod(
+                       name: methodInfo.Name + "_DynamicMethod",
+                       returnType: typeof(Task),
+                       parameterTypes: new[] { typeof(object), typeof(object[]) },
+                       restrictedSkipVisibility: true // 跳过私有方法访问限制
+                    );
+                }
+            }
+            else
+            {
+                dynamicMethod = new DynamicMethod(
+                       name: methodInfo.Name + "_DynamicMethod",
+                       returnType: typeof(object),
+                       parameterTypes: new[] { typeof(object), typeof(object[]) },
+                       restrictedSkipVisibility: true // 跳过私有方法访问限制
+                 );
+            }
+
+
+
+
+            var il = dynamicMethod.GetILGenerator();
+
+            // 加载实例 (this)
+            il.Emit(OpCodes.Ldarg_0);
+            il.Emit(OpCodes.Castclass, methodInfo.DeclaringType); // 将 ISocketControlBase 转换为目标类类型
+
+            // 加载方法参数
+            var methodParams = methodInfo.GetParameters();
+            for (int i = 0; i < methodParams.Length; i++)
+            {
+                il.Emit(OpCodes.Ldarg_1); // 加载参数数组
+                il.Emit(OpCodes.Ldc_I4, i); // 加载当前参数索引
+                il.Emit(OpCodes.Ldelem_Ref); // 取出数组元素
+
+                var paramType = methodParams[i].ParameterType;
+                if (paramType.IsValueType) // 如果参数是值类型，拆箱
+                {
+                    il.Emit(OpCodes.Unbox_Any, paramType);
+                }
+                else // 如果是引用类型，直接转换
+                {
+                    il.Emit(OpCodes.Castclass, paramType);
+                }
+            }
+
+            // 调用方法
+            il.Emit(OpCodes.Callvirt, methodInfo);
+
+            //// 处理返回值，如果没有返回值，则返回null
+            if (methodInfo.ReturnType == typeof(void))
+            {
+                il.Emit(OpCodes.Ldnull);
+            }
+            else if (methodInfo.ReturnType.IsValueType)
+            {
+                il.Emit(OpCodes.Box, methodInfo.ReturnType); // 如果是值类型，将其装箱
+            }
+            // 处理返回值，如果没有返回值，则返回null
+            il.Emit(OpCodes.Ret); // 返回
+            EmitMethodType emitMethodType;
+            if (IsTask)
+            {
+                if (IsTaskGenerics)
+                {
+                    emitMethodType = EmitMethodType.HasResultTask;
+                    @delegate = dynamicMethod.CreateDelegate(typeof(Func<object, object[], Task<object>>));
+                }
+                else
+                {
+                    emitMethodType = EmitMethodType.Task;
+                    @delegate = dynamicMethod.CreateDelegate(typeof(Func<object, object[], Task>));
+                }
+            }
+            else
+            {
+                emitMethodType = EmitMethodType.Func;
+                @delegate = dynamicMethod.CreateDelegate(typeof(Func<object, object[], object>));
+
+            }
+            return emitMethodType;
+        }
+
+        
+    }
+
+}

Library/Utils/ExpressionHelper.cs

@@ -0,0 +1,446 @@
+using Serein.Library.Api;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Serein.Library.Utils
+{
+    /// <summary>
+    /// 基于类型创建表达式树反射委托
+    /// </summary>
+    public static class ExpressionHelper
+    {
+        /// <summary>
+        /// 缓存表达式树反射方法
+        /// </summary>
+        private static ConcurrentDictionary<string, Delegate> Cache { get; } = new ConcurrentDictionary<string, Delegate>();
+
+
+        #region 基于类型的表达式反射构建委托
+
+        #region 属性、字段的委托创建（表达式反射）
+
+        /// <summary>
+        /// 动态获取属性值
+        /// </summary>
+        public static Delegate PropertyGetter(Type type, string propertyName)
+        {
+            string cacheKey = $"{type.FullName}.{propertyName}.Getter";
+            return Cache.GetOrAdd(cacheKey, _ => CreateGetterDelegate(type, propertyName));
+        }
+        /// <summary>
+        /// 动态获取属性值
+        /// </summary>
+        private static Delegate CreateGetterDelegate(Type type, string propertyName)
+        {
+            var parameter = Expression.Parameter(typeof(object), "instance");
+            var property = Expression.Property(Expression.Convert(parameter, type), propertyName);
+            var lambda = Expression.Lambda(Expression.Convert(property, typeof(object)), parameter);
+            return lambda.Compile();
+        }
+
+        /// <summary>
+        /// 动态设置属性值
+        /// </summary>
+        public static Delegate PropertySetter(Type type, string propertyName)
+        {
+            string cacheKey = $"{type.FullName}.{propertyName}.Setter";
+            return Cache.GetOrAdd(cacheKey, _ => CreateSetterDelegate(type, propertyName));
+        }
+
+        /// <summary>
+        /// 动态设置属性值
+        /// </summary>
+        private static Delegate CreateSetterDelegate(Type type, string propertyName)
+        {
+            var parameter = Expression.Parameter(typeof(object), "instance");
+            var value = Expression.Parameter(typeof(object), "value");
+            var property = Expression.Property(Expression.Convert(parameter, type), propertyName);
+            var assign = Expression.Assign(property, Expression.Convert(value, property.Type));
+            var lambda = Expression.Lambda(assign, parameter, value);
+            return lambda.Compile();
+        }
+
+        /// <summary>
+        /// 动态获取字段值
+        /// </summary>
+        public static Delegate FieldGetter(Type type, string fieldName)
+        {
+            string cacheKey = $"{type.FullName}.{fieldName}.FieldGetter";
+            return Cache.GetOrAdd(cacheKey, _ => CreateFieldGetterDelegate(type, fieldName));
+        }
+        /// <summary>
+        /// 动态获取字段值
+        /// </summary>
+        private static Delegate CreateFieldGetterDelegate(Type type, string fieldName)
+        {
+            var parameter = Expression.Parameter(typeof(object), "instance");
+            var field = Expression.Field(Expression.Convert(parameter, type), fieldName);
+            var lambda = Expression.Lambda(Expression.Convert(field, typeof(object)), parameter);
+            return lambda.Compile();
+        }
+
+        /// <summary>
+        /// 动态设置字段值
+        /// </summary>
+        public static Delegate FieldSetter(Type type, string fieldName)
+        {
+            string cacheKey = $"{type.FullName}.{fieldName}.FieldSetter";
+            return Cache.GetOrAdd(cacheKey, _ => CreateFieldSetterDelegate(type, fieldName));
+        }
+        /// <summary>
+        /// 动态设置字段值
+        /// </summary>
+        private static Delegate CreateFieldSetterDelegate(Type type, string fieldName)
+        {
+            var parameter = Expression.Parameter(typeof(object), "instance");
+            var value = Expression.Parameter(typeof(object), "value");
+            var field = Expression.Field(Expression.Convert(parameter, type), fieldName);
+            var assign = Expression.Assign(field, Expression.Convert(value, field.Type));
+            var lambda = Expression.Lambda(assign, parameter, value);
+            return lambda.Compile();
+        }
+
+        #endregion
+
+
+
+        /// <summary>
+        /// 表达式树构建无参数，无返回值方法
+        /// </summary>
+        public static Delegate MethodCaller(Type type, MethodInfo methodInfo)
+        {
+            string cacheKey = $"{type.FullName}.{methodInfo.Name}.MethodCaller";
+            return Cache.GetOrAdd(cacheKey, _ => CreateMethodCallerDelegate(type, methodInfo));
+        }
+
+        /// <summary>
+        /// 表达式树构建无参数，无返回值方法
+        /// </summary>
+        private static Delegate CreateMethodCallerDelegate(Type type, MethodInfo methodInfo)
+        {
+            var parameter = Expression.Parameter(typeof(object), "instance");
+            var methodCall = Expression.Call(Expression.Convert(parameter, type), methodInfo);
+            var lambda = Expression.Lambda(methodCall, parameter);
+            // Action<object>
+            return lambda.Compile();
+        }
+
+        /// <summary>
+        /// 表达式树构建无参数，有返回值方法
+        /// </summary>
+        public static Delegate MethodCallerHaveResult(Type type, MethodInfo methodInfo)
+        {
+            string cacheKey = $"{type.FullName}.{methodInfo.Name}.MethodCallerHaveResult";
+            return Cache.GetOrAdd(cacheKey, _ => CreateMethodCallerDelegateHaveResult(type, methodInfo));
+        }
+        /// <summary>
+        /// 表达式树构建无参数，有返回值方法
+        /// </summary>
+        private static Delegate CreateMethodCallerDelegateHaveResult(Type type, MethodInfo methodInfo)
+        {
+            var parameter = Expression.Parameter(typeof(object), "instance");
+            var methodCall = Expression.Call(Expression.Convert(parameter, type), methodInfo);
+
+            if (IsGenericTask(methodInfo.ReturnType, out var taskResult))
+            {
+                if (taskResult is null)
+                {
+                    var lambda = Expression.Lambda<Func<object, Task>>(Expression.Convert(methodCall, typeof(Task)), parameter);
+                    return lambda.Compile();
+                }
+                else
+                {
+                    var lambda = Expression.Lambda<Func<object, Task<object>>>(Expression.Convert(methodCall, typeof(Task<object>)), parameter);
+                    return lambda.Compile();
+                }
+            }
+            else
+            {
+                var lambda = Expression.Lambda<Func<object, object>>(Expression.Convert(methodCall, typeof(object)), parameter);
+                return lambda.Compile();
+            }
+
+        }
+
+
+        /// <summary>
+        /// 表达式树构建多个参数,无返回值的方法
+        /// </summary>
+        public static Delegate MethodCaller(Type type, MethodInfo methodInfo, params Type[] parameterTypes)
+        {
+            string cacheKey = $"{type.FullName}.{methodInfo.Name}.MethodCaller";
+            return Cache.GetOrAdd(cacheKey, _ => CreateMethodCallerDelegate(type, methodInfo, parameterTypes));
+        }
+
+        /// <summary>
+        /// 表达式树构建多个参数,无返回值的方法
+        /// </summary>
+        private static Delegate CreateMethodCallerDelegate(Type type, MethodInfo methodInfo, Type[] parameterTypes)
+        {
+            /* var parameter = Expression.Parameter(typeof(object), "instance");
+
+             var arguments = parameterTypes.Select((t, i) => Expression.Parameter(typeof(object), $"arg{i}")).ToArray();
+
+             var convertedArguments = arguments.Select((arg, i) => Expression.Convert(arg, parameterTypes[i])).ToArray();
+             var methodCall = Expression.Call(Expression.Convert(parameter, type),
+                                              methodInfo,
+                                              convertedArguments);
+             var lambda = Expression.Lambda(methodCall, new[] { parameter }.Concat(arguments));
+             var tmpAction = lambda.Compile();
+
+             // Action<object, object[]>
+             return lambda.Compile();*/
+
+            var instanceParam = Expression.Parameter(typeof(object), "instance");
+            var argsParam = Expression.Parameter(typeof(object[]), "args");
+
+            // 创建参数表达式
+            var convertedArgs = parameterTypes.Select((paramType, index) =>
+                Expression.Convert(Expression.ArrayIndex(argsParam, Expression.Constant(index)), paramType)
+            ).ToArray();
+
+
+            // 创建方法调用表达式
+            var methodCall = Expression.Call(
+                Expression.Convert(instanceParam, type),
+                methodInfo,
+                convertedArgs
+            );
+
+            // 创建 lambda 表达式
+            var lambda = Expression.Lambda(
+                methodCall,
+                instanceParam,
+                argsParam
+            );
+
+            // Func<object, object[], object>
+            return lambda.Compile();
+        }
+
+        /// <summary>
+        /// 表达式树构建多个参数,有返回值的方法
+        /// </summary>
+        public static Delegate MethodCallerHaveResult(Type type, MethodInfo methodInfo, Type[] parameterTypes)
+        {
+            string cacheKey = $"{type.FullName}.{methodInfo.Name}.MethodCallerHaveResult";
+            return Cache.GetOrAdd(cacheKey, _ => CreateMethodCallerDelegateHaveResult(type, methodInfo, parameterTypes));
+        }
+        /// <summary>
+        /// 表达式树构建多个参数,有返回值的方法
+        /// </summary>
+        private static Delegate CreateMethodCallerDelegateHaveResult(Type type, MethodInfo methodInfo, Type[] parameterTypes)
+        {
+            /*var instanceParam = Expression.Parameter(typeof(object), "instance");
+            var argsParam = Expression.Parameter(typeof(object[]), "args");
+
+            // 创建参数表达式
+            var convertedArgs = parameterTypes.Select((paramType, index) =>
+                Expression.Convert(Expression.ArrayIndex(argsParam, Expression.Constant(index)), paramType)
+            ).ToArray();
+
+
+            // 创建方法调用表达式
+            var methodCall = Expression.Call(
+                Expression.Convert(instanceParam, type),
+                methodInfo,
+                convertedArgs
+            );
+
+            // 创建 lambda 表达式
+            var lambda = Expression.Lambda(
+                Expression.Convert(methodCall, typeof(object)),
+                instanceParam,
+                argsParam
+            );
+
+            // Func<object, object[], object>
+            return lambda.Compile();*/
+
+            var instanceParam = Expression.Parameter(typeof(object), "instance");
+            var argsParam = Expression.Parameter(typeof(object[]), "args");
+
+            // 创建参数表达式
+            var convertedArgs = parameterTypes.Select((paramType, index) =>
+                Expression.Convert(Expression.ArrayIndex(argsParam, Expression.Constant(index)), paramType)
+            ).ToArray();
+
+
+            // 创建方法调用表达式
+            var methodCall = Expression.Call(
+                Expression.Convert(instanceParam, type),
+                methodInfo,
+                convertedArgs
+            );
+
+            if (IsGenericTask(methodInfo.ReturnType, out var taskResult))
+            {
+                if (taskResult is null)
+                {
+                    var lambda = Expression.Lambda<Func<object, object[], Task>>
+                        (Expression.Convert(methodCall, typeof(Task)), instanceParam, argsParam);
+                    return lambda.Compile();
+                }
+                else
+                {
+                    var lambda = Expression.Lambda<Func<object, object[], Task<object>>>
+                        (Expression.Convert(methodCall, typeof(Task<object>)), instanceParam, argsParam);
+                    return lambda.Compile();
+                }
+            }
+            else
+            {
+                var lambda = Expression.Lambda<Func<object, object[], object>>
+                        (Expression.Convert(methodCall, typeof(object)), instanceParam, argsParam);
+                return lambda.Compile();
+            }
+
+
+        }
+
+
+        /// <summary>
+        /// 表达式树构建无参数，有返回值(Task<object>)的方法（触发器）
+        /// </summary>
+        public static Delegate MethodCallerAsync(Type type, MethodInfo methodInfo)
+        {
+            string cacheKey = $"{type.FullName}.{methodInfo.Name}.MethodCallerAsync";
+            return Cache.GetOrAdd(cacheKey, _ => CreateMethodCallerDelegateAsync(type, methodInfo));
+        }
+        /// <summary>
+        /// 表达式树构建无参数，有返回值(Task<object>)的方法（触发器）
+        /// </summary>
+        private static Delegate CreateMethodCallerDelegateAsync(Type type, MethodInfo methodInfo)
+        {
+            var parameter = Expression.Parameter(typeof(object), "instance");
+            var methodCall = Expression.Call(Expression.Convert(parameter, type), methodInfo);
+            var lambda = Expression.Lambda<Func<object, Task<object>>>(
+                Expression.Convert(methodCall, typeof(Task<object>)), parameter);
+            // Func<object, Task<object>>
+            return lambda.Compile();
+        }
+
+
+
+        /// <summary>
+        /// 表达式树构建多个参数，有返回值(Task-object)的方法（触发器）
+        /// </summary>
+        public static Delegate MethodCallerAsync(Type type, MethodInfo method, params Type[] parameterTypes)
+        {
+
+            string cacheKey = $"{type.FullName}.{method.Name}.MethodCallerAsync";
+            return Cache.GetOrAdd(cacheKey, _ => CreateMethodCallerDelegateAsync(type, method, parameterTypes));
+        }
+        /// <summary>
+        /// 表达式树构建多个参数，有返回值(Task<object>)的方法（触发器）
+        /// </summary>
+        private static Delegate CreateMethodCallerDelegateAsync(Type type, MethodInfo methodInfo, Type[] parameterTypes)
+        {
+            var instanceParam = Expression.Parameter(typeof(object), "instance");
+            var argsParam = Expression.Parameter(typeof(object[]), "args");
+
+            // 创建参数表达式
+            var convertedArgs = parameterTypes.Select((paramType, index) =>
+                Expression.Convert(Expression.ArrayIndex(argsParam, Expression.Constant(index)), paramType)
+            ).ToArray();
+
+
+            // 创建方法调用表达式
+            var methodCall = Expression.Call(
+                Expression.Convert(instanceParam, type),
+                methodInfo,
+                convertedArgs
+            );
+
+            // 创建 lambda 表达式
+            var lambda = Expression.Lambda<Func<object, object[], Task<IFlipflopContext>>>(
+                Expression.Convert(methodCall, typeof(Task<IFlipflopContext>)),
+                instanceParam,
+                argsParam
+            );
+            //获取返回类型
+            //var returnType = methodInfo.ReturnType;
+            //var lambda = Expression.Lambda(
+            //        typeof(Func<,,>).MakeGenericType(typeof(object), typeof(object[]), returnType),
+            //        Expression.Convert(methodCall, returnType),
+            //        instanceParam,
+            //        argsParam
+            //    );
+
+
+            //var resule = task.DynamicInvoke((object)[Activator.CreateInstance(type), [new DynamicContext(null)]]);
+            return lambda.Compile();
+        }
+
+
+
+
+
+        public static bool IsGenericTask(Type returnType, out Type taskResult)
+        {
+            // 判断是否为 Task 类型或泛型 Task<T>
+            if (returnType == typeof(Task))
+            {
+                taskResult = null;
+                return true;
+            }
+            else if (returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task<>))
+            {
+                // 获取泛型参数类型
+                Type genericArgument = returnType.GetGenericArguments()[0];
+                taskResult = genericArgument;
+                return true;
+            }
+            else
+            {
+                taskResult = null;
+                return false;
+
+            }
+        }
+
+        public static Delegate AutoCreate(Type type, MethodInfo methodInfo)
+        {
+            Type returnType = methodInfo.ReturnType;
+            var parameterTypes = methodInfo.GetParameters().Select(p => p.ParameterType).ToArray();
+            var parameterCount = parameterTypes.Length;
+
+            if (returnType == typeof(void))
+            {
+                if (parameterCount == 0)
+                {
+                    // 无返回值，无参数
+                    return MethodCaller(type, methodInfo);
+                }
+                else
+                {
+                    // 无返回值，有参数
+                    return MethodCaller(type, methodInfo, parameterTypes);
+                }
+            }
+            else
+            {
+                if (parameterCount == 0)
+                {
+                    // 有返回值，无参数
+                    return MethodCallerHaveResult(type, methodInfo);
+                }
+                else
+                {
+                    // 有返回值，有参数
+                    return MethodCallerHaveResult(type, methodInfo, parameterTypes);
+                }
+            }
+
+            #endregion
+
+
+
+        }
+    }
+}

Library/Utils/SereinIoc.cs

@@ -28,6 +28,7 @@ namespace Serein.Library.Utils
         /// 已完成注入的实例集合
         /// </summary>
         private readonly ConcurrentDictionary<string, object> _dependencies;
+        private readonly ConcurrentDictionary<string, object[]> _registerParameterss;
 
         /// <summary>
         /// 未完成注入的实例集合。
@@ -40,9 +41,10 @@ namespace Serein.Library.Utils
 
         public SereinIOC()
         {
-            // 首先注册自己
             _dependencies = new ConcurrentDictionary<string, object>();
+            _registerParameterss = new ConcurrentDictionary<string, object[]>();
             _typeMappings = new ConcurrentDictionary<string, Type>(); 
+
             _unfinishedDependencies = new ConcurrentDictionary<string, List<(object, PropertyInfo)>>();
         }
 
@@ -57,7 +59,7 @@ namespace Serein.Library.Utils
         /// <param name="parameters">参数</param>
         public bool Register(Type type, params object[] parameters)
         {
-            return RegisterType(type?.FullName, type);
+            return RegisterType(type?.FullName, type, parameters);
         }
         /// <summary>
         /// 注册类型
@@ -67,7 +69,7 @@ namespace Serein.Library.Utils
         public bool Register<T>(params object[] parameters)
         {
             var type = typeof(T);
-            return RegisterType(type.FullName, type);
+            return RegisterType(type.FullName, type, parameters);
         }
 
         /// <summary>
@@ -78,7 +80,7 @@ namespace Serein.Library.Utils
         public bool Register<TService, TImplementation>(params object[] parameters)
             where TImplementation : TService
         {
-            return RegisterType(typeof(TService).FullName, typeof(TImplementation));
+            return RegisterType(typeof(TService).FullName, typeof(TImplementation), parameters);
         }
         #endregion
 
@@ -132,6 +134,12 @@ namespace Serein.Library.Utils
         }
         public object Get(Type type)
         {
+            var instance = Get(type.FullName);
+            if(instance is null)
+            {
+                Console.WriteLine("类型没有注册：" + type.FullName);
+            }
+            
             return Get(type.FullName);
         }
 
@@ -170,6 +178,7 @@ namespace Serein.Library.Utils
                     disposable?.Dispose();
                 }
             }
+            _registerParameterss?.Clear();
             _unfinishedDependencies?.Clear();
             _typeMappings?.Clear();
             _dependencies?.Clear();
@@ -185,11 +194,13 @@ namespace Serein.Library.Utils
             public string Name { get; set; }
             public Type Type { get; set; }
         }
-
+        private const string FlowBaseClassName = "<>$FlowBaseClass!@#";
         public Dictionary<string, List<string>> BuildDependencyTree()
         {
             var dependencyMap = new Dictionary<string, List<string>>();
-
+            //var tmpTypeFullName = new HashSet<string>();
+            //var tmpTypeFullName2 = new HashSet<string>();
+            dependencyMap[FlowBaseClassName] = new List<string>();
             foreach (var typeMapping in _typeMappings)
             {
                 var constructor = GetConstructorWithMostParameters(typeMapping.Value); // 获取参数最多的构造函数
@@ -198,18 +209,41 @@ namespace Serein.Library.Utils
                     var parameters = constructor.GetParameters()
                         .Select(p => p.ParameterType)
                         .ToList();
+                    //if(parameters.Count == 0)
+                    //{
+                    //    if (!dependencyMap.ContainsKey(typeMapping.Value.FullName))
+                    //    {
+                    //        dependencyMap[typeMapping.Value.FullName] = new List<string>();
+                    //    }
+                    //    dependencyMap[typeMapping.Value.FullName].Add(typeMapping.Key);
+                    //}
 
-                    foreach (var param in parameters)
+
+                    if(parameters .Count > 0)
                     {
-                        if (!dependencyMap.ContainsKey(param.FullName))
+                        // 从类型的构造函数中提取类型
+                        foreach (var param in parameters)
                         {
-                            dependencyMap[param.FullName] = new List<string>();
+                            if (!dependencyMap.ContainsKey(param.FullName))
+                            {
+                                dependencyMap[param.FullName] = new List<string>();
+                            }
+                            dependencyMap[param.FullName].Add(typeMapping.Key);
+                            //tmpTypeFullName.Add(param.FullName);
+                            //if (tmpTypeFullName2.Contains(param.FullName))
+                            //{
+                            //    tmpTypeFullName2.Remove(param.FullName);
+                            //}
                         }
-                        dependencyMap[param.FullName].Add(typeMapping.Key);
+                    }
+                    else
+                    {
+                        var type = typeMapping.Value;
+                        dependencyMap[FlowBaseClassName].Add(type.FullName);
                     }
                 }
             }
-
+            
             return dependencyMap;
         }
         // 获取参数最多的构造函数
@@ -288,29 +322,44 @@ namespace Serein.Library.Utils
 
         public object CreateInstance(string typeName)
         {
-            if (_typeMappings.TryGetValue(typeName, out var type))
+            if (!_typeMappings.TryGetValue(typeName, out var type))
             {
+                return null;
+            }
+            if (_dependencies.TryGetValue(typeName, out var instance))
+            {
+                return instance;
+            }
+            if (_registerParameterss.TryGetValue(typeName,out var @params))
+            {
+                instance = Activator.CreateInstance(type, @params);
+            }
+            else
+            {
+                // 没有显示指定构造函数入参，选择参数最多的构造函数
                 var constructor = GetConstructorWithMostParameters(type);
                 var parameters = constructor.GetParameters();
                 var args = new object[parameters.Length];
-
-
                 for (int i = 0; i < parameters.Length; i++)
                 {
+                    var argType = parameters[i].ParameterType;
                     var fullName = parameters[i].ParameterType.FullName;
                     if (!_dependencies.TryGetValue(fullName, out var argObj))
                     {
-                        argObj = CreateInstance(parameters[i].ParameterType.FullName);
+                        if (!_typeMappings.ContainsKey(fullName))
+                        {
+                            _typeMappings.TryAdd(fullName, argType);
+                        }
+                        argObj = CreateInstance(fullName);
                     }
                     args[i] = argObj;
                 }
-                var value = Activator.CreateInstance(type, args);
-                InjectDependencies(value); // 完成创建后注入实例需要的特性依赖项
-
-                return value;
+                instance = Activator.CreateInstance(type, args);
             }
 
-            return null;
+            InjectDependencies(instance); // 完成创建后注入实例需要的特性依赖项
+            _dependencies[typeName] = instance;
+            return instance;
         }
 
 
@@ -330,6 +379,10 @@ namespace Serein.Library.Utils
                     continue;
                 }
                 var value = CreateInstance(typeName);
+                if(value is null)
+                {
+                    continue;
+                }
                 _dependencies[typeName] = value;
                 OnIOCMembersChanged.Invoke(new IOCMembersChangedEventArgs(typeName, value));
             }
@@ -349,11 +402,15 @@ namespace Serein.Library.Utils
         /// </summary>
         /// <param name="typeFull"></param>
         /// <param name="type"></param>
-        private bool RegisterType(string typeFull, Type type)
+        private bool RegisterType(string typeFull, Type type, params object[] parameters)
         {
             if (!_typeMappings.ContainsKey(typeFull))
             {
                 _typeMappings[typeFull] = type;
+                if(parameters.Length > 0)
+                {
+                    _registerParameterss[typeFull] = parameters;
+                }
                 return true;
             }
             else
@@ -432,15 +489,8 @@ namespace Serein.Library.Utils
         public void Run<T>(Action<T> action)
         {
             var service = Get<T>();
-            if (service == null)
-            {
-                throw new Exception("类型没有注册："+typeof(T).FullName);
-               
-            }
-            else
-            {
-                action(service);
-            }
+            action(service);
+           
         }
 
         public void Run<T1, T2>(Action<T1, T2> action)

Library/Utils/SerinExpressionEvaluator.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace Serein.Library.Utils
-{
-    //public abstract class SerinExpressionEvaluator
-    //{
-    //    public abstract string Evaluate(string expression ,object obj , out bool isChange);
-    //}
-}

Library/Utils/Utils.cs

@@ -1,9 +0,0 @@
-using System;
-using System.Threading;
-
-namespace Serein.Library.Utils
-{
-    public class NodeRunCts : CancellationTokenSource
-    {
-    }
-}