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 1;
    }
    private async Task<Tout> FuncWithResult<T, Tout>(T para)
    {
        await Task.Delay(2);
        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();
    }