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

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

Library/Network/WebSocket/Handle/MyHandleConfig.cs

@@ -0,0 +1,141 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using Serein.Library.Utils;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Serein.Library.Network.WebSocketCommunication.Handle
+{
+    public class MyHandleConfig
+    {
+        private readonly Delegate EmitDelegate;
+        private readonly EmitHelper.EmitMethodType EmitMethodType;
+
+        public MyHandleConfig(ISocketControlBase instance, MethodInfo methodInfo)
+        {
+            EmitMethodType = EmitHelper.CreateDynamicMethod(methodInfo,out EmitDelegate);
+
+            Instance = instance;
+            var parameterInfos = methodInfo.GetParameters();
+            ParameterType = parameterInfos.Select(t => t.ParameterType).ToArray();
+            ParameterName = parameterInfos.Select(t => t.Name).ToArray();
+
+        }
+        public ISocketControlBase Instance { get; private set; }
+        private string[] ParameterName;
+        private Type[] ParameterType;
+
+
+        public async void Handle(Func<string, Task> RecoverAsync, JObject jsonObject)
+        {
+            object[] args = new object[ParameterType.Length];
+            for (int i = 0; i < ParameterType.Length; i++)
+            {
+                var type = ParameterType[i];
+                var argName = ParameterName[i];
+                if (type.IsGenericType)
+                {
+                    if (type.IsAssignableFrom(typeof(Func<object, Task>)))
+                    {
+                        args[i] = new Func<object, Task>(async data =>
+                        {
+                            var jsonText = JsonConvert.SerializeObject(data);
+                            await RecoverAsync.Invoke(jsonText);
+                        });
+                    }
+                    else if (type.IsAssignableFrom(typeof(Func<string, Task>)))
+                    {
+                        args[i] = new Func<string, Task>(async data =>
+                        {
+                            await RecoverAsync.Invoke(data);
+                        });
+                    }
+                    else if (type.IsAssignableFrom(typeof(Action<object>)))
+                    {
+                        args[i] = new Action<object>(async data =>
+                        {
+                            var jsonText = JsonConvert.SerializeObject(data);
+                            await RecoverAsync.Invoke(jsonText);
+                        });
+                    }
+                    else if (type.IsAssignableFrom(typeof(Action<string>)))
+                    {
+                        args[i] = new Action<string>(async data =>
+                        {
+                            var jsonText = JsonConvert.SerializeObject(data);
+                            await RecoverAsync.Invoke(jsonText);
+                        });
+                    }
+                }
+                else if (type.IsValueType || type.IsClass)
+                {
+                    var jsonValue = jsonObject.GetValue(argName);
+                    if (jsonValue is null)
+                    {
+                        // 值类型返回默认值，引用类型返回null
+                        args[i] = type.IsValueType ? Activator.CreateInstance(type) : null;
+                    }
+                    else
+                    {
+                        args[i] = jsonValue.ToObject(type);
+                    }
+                }
+
+
+            }
+            Stopwatch sw = new Stopwatch();
+            sw.Start();
+            object result;
+            if (EmitMethodType == EmitHelper.EmitMethodType.HasResultTask && EmitDelegate is Func<object, object[], Task<object>> hasResultTask)
+            {
+                result = await hasResultTask(Instance, args);
+            }
+            else if (EmitMethodType == EmitHelper.EmitMethodType.Task && EmitDelegate is Func<object, object[], Task> task)
+            {
+                await task.Invoke(Instance, args);
+                result = null;
+            }
+            else if (EmitMethodType == EmitHelper.EmitMethodType.Func &&  EmitDelegate is Func<object, object[], object> func)
+            {
+                result = func.Invoke(Instance, args);
+            }
+            else
+            {
+                throw new NotImplementedException("构造委托无法正确调用");
+            }
+           sw.Stop();
+           Console.WriteLine($"Emit Invoke：{sw.ElapsedTicks * 1000000F / Stopwatch.Frequency:n3}μs");
+
+            if(result != null && result.GetType().IsClass)
+            {
+                var reusltJsonText = JsonConvert.SerializeObject(result);
+                _ = RecoverAsync.Invoke($"{reusltJsonText}");
+            }
+            
+
+        }
+        public void Clear()
+        {
+            Instance = null;
+            ParameterName = null;
+            ParameterType = null;
+            //expressionDelegate = null;
+        }
+
+    }
+
+
+  
+
+
+
+}