Merge pull request #19 from softlgl/dev

方法调用抽离

Author: softlgl

src/DotNetCoreRpc.Core/TaskUtils.cs

@@ -17,6 +17,7 @@ public class TaskUtils
         private static readonly ConcurrentDictionary<Type, Func<object, object>> _asValueTaskFuncCache = new ConcurrentDictionary<Type, Func<object, object>>();
         private static readonly ConcurrentDictionary<Type, Func<object, object>> _resultFuncCache = new ConcurrentDictionary<Type, Func<object, object>>();
         private static readonly ConcurrentDictionary<TypeInfo, Func<object, Task>> _valueTaskAsTaskFuncCache = new ConcurrentDictionary<TypeInfo, Func<object, Task>>();
+        private static readonly ConcurrentDictionary<MethodInfo, Func<object, object?[]?, object?>> _methodFuncCache = new ConcurrentDictionary<MethodInfo, Func<object, object?[]?, object?>>();
 
         public static Func<object, object> TaskResultFunc(Type returnType)
         {
@@ -74,6 +75,45 @@ public static Task ValueTaskWithResultToTask(object value, TypeInfo valueTypeInf
             return func(value);
         }
 
+        public static Func<object, object?[]?, object?> InvokeMethod(MethodInfo methodInfo)
+        {
+            var methodFunc = _methodFuncCache.GetOrAdd(methodInfo, method => 
+            {
+                var targetParameter = Expression.Parameter(typeof(object), "target");
+                var parametersParameter = Expression.Parameter(typeof(object?[]), "parameters");
+
+                var paramInfos = method.GetParameters();
+                var parameters = new List<Expression>(paramInfos.Length);
+                for (int i = 0; i < paramInfos.Length; i++)
+                {
+                    var valueObj = Expression.ArrayIndex(parametersParameter, Expression.Constant(i));
+                    var valueCast = Expression.Convert(valueObj, paramInfos[i].ParameterType);
+
+                    parameters.Add(valueCast);
+                }
+
+                Type targetType = method.DeclaringType;
+                var instanceCast = Expression.Convert(targetParameter, targetType);
+                var methodCall = Expression.Call(instanceCast, method, parameters);
+
+                if (methodCall.Type == typeof(void))
+                {
+                    var lambdaAction = Expression.Lambda<Action<object, object?[]?>>(methodCall, targetParameter, parametersParameter);
+                    return (target, parameters) =>
+                    {
+                        lambdaAction.Compile().Invoke(target, parameters);
+                        return null;
+                    };
+                }
+
+                var castMethodCall = Expression.Convert(methodCall, typeof(object));
+                var lambdaFunc = Expression.Lambda<Func<object, object?[]?, object?>>(castMethodCall, targetParameter, parametersParameter);
+                return lambdaFunc.Compile();
+            });
+
+            return methodFunc;
+        }
+
         public static bool IsAsyncMethod(MethodInfo method)
         {
             bool isDefAsync = Attribute.IsDefined(method, typeof(AsyncStateMachineAttribute), false);

src/DotNetCoreRpc.Server/DotNetCoreRpcMiddleware.cs

@@ -129,39 +129,9 @@ private static RpcRequestDelegate PiplineEndPoint(object instance, RpcContext as
         {
             return async rpcContext =>
             {
-                var targetParameter = Expression.Parameter(typeof(object), "target");
-                var parametersParameter = Expression.Parameter(typeof(object?[]), "parameters");
-                var paramInfos = aspectContext.Method.GetParameters();
-                var parameters = new List<Expression>(paramInfos.Length);
-                for (int i = 0; i < paramInfos.Length; i++)
-                {
-                    var paramInfo = paramInfos[i];
-                    var valueObj = Expression.ArrayIndex(parametersParameter, Expression.Constant(i));
-                    var valueCast = Expression.Convert(valueObj, paramInfo.ParameterType);
-
-                    // valueCast is "(Ti) parameters[i]"
-                    parameters.Add(valueCast);
-                }
-                var instanceCast = Expression.Convert(targetParameter, aspectContext.TargetType.GetTypeInfo().AsType());
-                var methodCall = Expression.Call(instanceCast, aspectContext.Method, parameters);
-
-                Func<object, object?[]?, object?> func = null;
-                if (methodCall.Type == typeof(void))
-                {
-                    var lambda = Expression.Lambda<Action<object, object?[]?>>(methodCall, targetParameter, parametersParameter);
-                    func = (target, parameters) =>
-                    {
-                        lambda.Compile().Invoke(target, parameters);
-                        return null;
-                    };
-                }
-                else
-                {
-                    var castMethodCall = Expression.Convert(methodCall, typeof(object));
-                    var lambda = Expression.Lambda<Func<object, object?[]?, object?>>(castMethodCall, targetParameter, parametersParameter);
-                    func = lambda.Compile();
-                }
+                var func = TaskUtils.InvokeMethod(aspectContext.Method);
                 var returnValue = func.Invoke(instance, aspectContext.Parameters);
+
                 if (returnValue != null)
                 {
                     var returnValueType = returnValue.GetType().GetTypeInfo();
@@ -189,11 +159,6 @@ private static RpcRequestDelegate PiplineEndPoint(object instance, RpcContext as
                             aspectContext.ReturnValue = TaskUtils.CreateFuncToGetTaskResult(returnValueType).Invoke(returnValue);
                             return;
                         }
-                        //}
-                        //if (returnValue is Task || returnValue is ValueTask)
-                        //{
-                        //    return;
-                        //}
                     }
                     aspectContext.ReturnValue = returnValue;
                 }