C# 以函数Action/Func/Task作为方法参数

以Action、Func、Task作为方法参数，mark一下

以Action为参数

     public void TestAction()
     {
         //Action参数
         ExecuteFunction(() =>
         {

         });
         ExecuteFunction(ActionAAA("para"));
         ExecuteFunction(AAA);

         //Action<T>参数,T可以由类的泛型参数输入
         ExecuteFunction<string>((string praa) =>
         {

         });
         //Action<T>参数，T主动输入
         ExecuteFunction<string>((string praa) =>
         {

         }, "aaa");
         ExecuteFunction<string>(AAA, "para");
     }

     private void ExecuteFunction(Action action)
     {
         action?.Invoke();
     }

     private void ExecuteFunction<T>(Action<T> action)
     {
         return;
     }
     private void ExecuteFunction<T>(Action<T> action, T s)
     {
         action?.Invoke(s);
     }

引用的方法

     void AAA()
     {
     }
     void AAA(string para)
     {
     }
     Action ActionAAA(string para)
     {
         return () =>
         {
             Console.WriteLine(para);
         };
     }

以Func为参数

     public async void TestFunc()
     {
         //Func<string>
         ExecuteFunction(() =>
         {
             return string.Empty;
         });
         //Func<Task>
         ExecuteFunction(async () => { });
         ExecuteFunction(FuncTask);
         //Func<T, Tout>
         ExecuteFunction<string, int>(BBB, "para");
         //Func<T, Task>
         ExecuteFunction<string>(FuncTask, "para");
         //Func<T, Task<Tout>>
         var stringResult = await ExecuteFunction<string, string>(FuncWithResult<string, string>, "para");
     }

     private string ExecuteFunction(Func<string> func)
     {
         return func.Invoke();
     }

     private void ExecuteFunction(Func<Task> func)
     {
         func?.Invoke();
     }
     private Tout ExecuteFunction<T, Tout>(Func<T, Tout> func, T para)
     {
         return func.Invoke(para);
     }

     private void ExecuteFunction<T>(Func<T, Task> function, T para)
     {
         function?.Invoke(para);
     }
     private async Task<Tout> ExecuteFunction<T, Tout>(Func<T, Task<Tout>> function, T para)
     {
         return await function?.Invoke(para);
     }

     private int BBB(string obj)
     {
         return ;
     }
     private async Task<Tout> FuncWithResult<T, Tout>(T para)
     {
         await Task.Delay();
         return default(Tout);
     }

     async Task FuncTask<T>(T para)
     {

     }
     async Task FuncTask()
     {

     }

其中，

    ExecuteFunction(async () =>
    {

    });

输入async () =>{}后，Func<Task> func、Action action都是可以匹配的，优先使用的是Func<Task> func

以Task为参数

     private void TestTask()
     {
         ExecuteFunction(Task.Run(() =>
         {

         }));
         ExecuteFunction(Task<string>.Run(async () =>
         {
             return string.Empty;
         }));
     }

     private void ExecuteFunction(Task task)
     {
         task.Start();
     }
     private void ExecuteFunction<Tout>(Task<Tout> task)
     {
         task.Start();
     }