Avoid checking condition twice when assigning from task awaited with Task.WhenAll()

Question

Is there a better way to write this asynchronous code (e.g. so that I don't need to repeat if (myCondition) twice)? I want to avoid using Task.Run here.

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

One way to do this is to have two lists, one list of tasks and one list of actions. The actions will be invoked sequentially after the completions of all tasks, and will assign the properties of the result object. Example:

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());

This way you don't need to store each Task in a separate variable, because each lambda expression captures the task variable in the inner scope of the if block. When the Action is invoked, the task will be completed, and so the task.Result will not block.

---

Just for fun: If you want to get fancy, you could encapsulate this "parallel object initialization" functionality in an ObjectInitializer class, that would invoke all the asynchronous methods concurrently, and then create a new object and assign the value of each of its properties sequentially:

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

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

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

Usage example:

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();