从 Task.WhenAll() 等待的任务分配时避免检查条件两次

Question

有没有更好的方法来编写这个异步代码（例如，这样我就不需要重复 if (myCondition) 两次）？我想避免在这里使用Task.Run。

var tasks = new List<Task>();
Task<String> t1 = null;
Task<String> t2 = null;

if (myCondition) {
    t1 = getAsync();
    tasks.Add(t1);
}

if (myOtherCondition) {
    t2 = getAsync2();
    tasks.Add(t2);
}

await Task.WhenAll(tasks)

if (myCondition) {
    result.foo = await t1;
}

if (myOtherCondition) {
    result.bar = await t2;
}

Answer 1

在不知道你的条件在检查什么的情况下，我想我通常会将该检查移到与获取 foo 或 bar 实际相关的方法中。这似乎是你的一种方法做的比它应该做的更多的例子。

另一种方法：

var fooTask = GetFoo();
var barTask = GetBar();

await Task.WhenAll(new [] { fooTask, barTask });
result.foo = (await fooTask) ?? result.foo;
result.bar = (await barTask) ?? result.bar;

// ...
async Task<string> GetFoo()
{
    if (!myCondition) {
        return Task.FromResult((string)null);
    }
    return await DoHeavyWorkFoo();
}

async Task<string> GetBar()
{
    if (!myOtherCondition) {
        return Task.FromResult((string)null);
    }
    return await DoHeavyWorkBar();
}

Answer 2

一种方法是创建两个列表，一个任务列表和一个操作列表。这些操作将在所有任务完成后依次调用，并将分配result 对象的属性。示例：

var tasks = new List<Task>();
var actions = new List<Action>();
var result = new MyClass();

if (myCondition)
{
    var task = getAsync();
    tasks.Add(task);
    actions.Add(() => result.Foo = task.Result);
}

if (myOtherCondition)
{
    var task = getAsync2();
    tasks.Add(task);
    actions.Add(() => result.Bar = task.Result);
}

await Task.WhenAll(tasks);

actions.ForEach(action => action());

这样您就不需要将每个 Task 存储在单独的变量中，因为每个 lambda 表达式 captures task 变量都在 if 块的内部范围内。当Action被调用时，task就完成了，所以task.Result不会阻塞。

---

只是为了好玩：如果你想变得花哨，你可以把这个“并行对象初始化”功能封装在一个ObjectInitializer类中，它会同时调用所有的异步方法，然后创建一个新对象并按顺序分配其每个属性的值：

public class ObjectInitializer<TObject> where TObject : new()
{
    private readonly List<Func<object, Task<Action<TObject>>>> _functions = new();

    public void Add<TProperty>(Func<object, Task<TProperty>> valueGetter,
        Action<TObject, TProperty> propertySetter)
    {
        _functions.Add(async arg =>
        {
            TProperty value = await valueGetter(arg);
            return instance => propertySetter(instance, value);
        });
    }

    public async Task<TObject> Run(object arg = null)
    {
        var getterTasks = _functions.Select(f => f(arg));
        Action<TObject>[] setters = await Task.WhenAll(getterTasks);
        TObject instance = new();
        Array.ForEach(setters, f => f(instance));
        return instance;
    }
}

使用示例：

var initializer = new ObjectInitializer<MyClass>();
if (myFooCondition) initializer.Add(_ => GetFooAsync(), (x, v) => x.Foo = v);
if (myBarCondition) initializer.Add(_ => GetBarAsync(), (x, v) => x.Bar = v);
MyClass result = await initializer.Run();