如何将异步方法放在列表中并迭代调用它们？

Question

最近我想对服务调用列表实施健康检查。它们都是异步任务（例如Task<IHttpOperationResponse<XXX_Model>> method_name(...)

我想将它们全部放入一个列表中。我按照这篇文章的答案：Storing a list of methods in C# 但是，它们是异步方法。

我是这样说的： 异步方法的集合

List<Action> _functions = new List<Action> {
      () => accountDetailsServiceProvider.GetEmployer(EmployerId),                                  
      () => accountServiceProvider.GetAccountStatus(EmployerId)
}

有人可以指导我正确的方法来实现将异步方法放入列表并迭代调用它们吗？

提前致谢！

Answer 1

首先，您需要使您的方法异步。这意味着他们必须返回一个任务。例如：

public static async Task Foo()
{
    await Task.Delay(1);
    Console.WriteLine("Foo!");
}

public static async Task Bar()
{
    await Task.Delay(1);
    Console.WriteLine("Bar!");
}

然后要将它们放入列表中，您必须将列表定义为包含正确的类型。由于异步方法实际上返回了一些东西，所以它是一个 Func，而不是一个动作。它返回一个任务。

var actions = new List<Func<Task>>
{
    Foo, Bar
};

要调用它们，请在列表中选择（使用 Linq）来调用它们。这将创建一个任务列表来代替功能列表。

var tasks = actions.Select( x => x() );

那就等着他们吧：

await Task.WhenAll(tasks);

完整示例：

public static async Task MainAsync()
{
    var actions = new List<Func<Task>>
    {
        Foo, Bar
    };
    var tasks = actions.Select( x => x() );
    await Task.WhenAll(tasks);
}

输出：

Foo!
Bar!

Example on DotNetFiddle

如果你的方法返回一个布尔值，那么返回类型就变成Task<bool>，其余的也一样：

public static async Task<bool> Foo()
{
    await Task.Delay(1);
    Console.WriteLine("Foo!");
    return true;
}

public static async Task<bool> Bar()
{
    await Task.Delay(1);
    Console.WriteLine("Bar!");
    return true;
}

var actions = new List<Func<Task<bool>>>
{
    Foo, Bar
};

var tasks = actions.Select( x => x() );

await Task.WhenAll(tasks);

等待它们之后，您可以使用另外一条 LINQ 语句将任务转换为它们的结果：

List<bool> results = tasks.Select( task => task.Result ).ToList();

Answer 2

基于 cmets：

但是，我的任务需要每个方法调用的布尔值， 因为我必须向前端报告状态是否 服务是否关闭

为将返回所需布尔值的方法创建一个包装方法

public async Task<Result> Check(string name, Func<Task> execute)
{
    try
    {
        await execute();
        return new Result(name, true, string.Empty);
    }
    catch (Exception ex)
    {
        return new Result(name, false, ex.Message);
    }
}

public class Result
{
    public string Name { get; }
    public bool Success { get; }
    public string Message { get; }
    public Result(string name, bool success, string message) 
        => (Name, Success, Message) = (name, success, message);
}

那么您不需要收集代表，而是收集Task。

var tasks = new[]
{
    Check(nameof(details.GetEmployer), () => details.GetEmployer(Id)),
    Check(nameof(accounts.GetAccountStatus), () => accounts.GetAccountStatus(Id)),
};

var completed = await Task.WhenAll(tasks);

foreach (var task in completed)
{
    Console.WriteLine($"Task: {task.Name}, Success: {task.Success};");
}

Answer 3

我认为您只是在寻找像这样简单的东西？

var myList = new List<Action>()
{
    async() => { await Foo.GetBarAsync(); },
    ...
};

我建议您将类型从 Action 更改为 Func<Task>，就像这样。

var myList = new List<Func<Task>>()
{
  async() => { await Foo.GetBarAsync(); },
};

您可以在此处阅读有关原因的更多信息：https://blogs.msdn.microsoft.com/pfxteam/2012/02/08/potential-pitfalls-to-avoid-when-passing-around-async-lambdas/

调用（简化）

foreach (var action in myList)
{
    await action.Invoke();
}