Ejemplo n.º 1
0
        private static Func <T, TRq, IDependencyResolver, Task> CreateExecuteActionFunction <TRq>(MethodInfo method)
        {
            var returnType = method.ReturnType;

            if (returnType == typeof(void) || returnType == typeof(Task))
            {
                return(ApiHelpers.CreateExecuteActionFunctionVoid <TRq>(method));
            }
            else
            {
                if (returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task <>))
                {
                    returnType = returnType.GetGenericArguments()[0];
                }

                //public static Func<T, TRq, IDependencyResolver, Task<TReturn>> CreateExecuteActionFunction<TRq, TReturn>(MethodInfo method)
                var executeFunction = Expression.Constant(
                    typeof(ApiHelpers).GetRuntimeMethodExt("CreateExecuteActionFunction", p => true).MakeGenericMethod(typeof(TRq), returnType).Invoke(null, new[] { method }),
                    typeof(Func <, , ,>).MakeGenericType(typeof(T), typeof(TRq), typeof(IDependencyResolver), typeof(Task <>).MakeGenericType(returnType))
                    );

                //public static Func<TRq, TReturn, IDependencyResolver> CreateWriteResultLambda<TRq, TReturn>()
                var sendResultFunction = Expression.Constant(
                    typeof(ApiHelpers).GetRuntimeMethodExt("CreateWriteResultLambda", p => true).MakeGenericMethod(typeof(TRq), returnType).Invoke(null, new object[] { }),
                    typeof(Func <, , ,>).MakeGenericType(typeof(TRq), returnType, typeof(IDependencyResolver), typeof(Task))
                    );

                //public static async Task ExecuteActionAndSendResult<TRq, TReturn>(T controller, TRq ctx, IDependencyResolver resolver, Func<T, TRq, IDependencyResolver, Task<TReturn>> executeControllerActionFunction, Action<TRq, TReturn, IDependencyResolver> sendResultAction)
                var wrapperMethod = typeof(ApiHelpers).GetRuntimeMethodExt("ExecuteActionAndSendResult", p => true).MakeGenericMethod(typeof(TRq), returnType);

                var controller = Expression.Parameter(typeof(T), "controller");
                var ctx        = Expression.Parameter(typeof(TRq), "ctx");
                var resolver   = Expression.Parameter(typeof(IDependencyResolver), "resolver");

                return(Expression.Lambda <Func <T, TRq, IDependencyResolver, Task> >(Expression.Call(wrapperMethod, controller, ctx, resolver, executeFunction, sendResultFunction), controller, ctx, resolver).Compile());
            }
        }