如何初始化可选任务和任务<T>使用 C#？

Question

How to optionally create multiple tasks and execute them using await Task.WhenAll(a,b,c);

I have the following class

public class TaskProcessor
{
    private ProcessResult Result;

    public TaskProcessor(ProcessResult result)
    {
        Result = result ?? throw new ArgumentNullException(nameof(result));
    }

    public async Task<ProcessResult> Process(TaskOption option)
    {
        // First optional task
        Task<int?> typeFetcher = Task.FromResult<int?>(null);
        if (option is IProcessType t)
        {
            typeFetcher = t.GetAsync();
        }

        // Second optional task
        Task<int?> subtypeFetcher = Task.FromResult<int?>(null);
        if (option is IProcessSubtype st)
        {
            subtypeFetcher = st.GetAsync();
        }

        // Third optional task
        Task mainContent = Task.CompletedTask;

        if(Result.Content != null) 
        {
            mainContent = SetMainContentAsync(Result.Content);
        }

        await Task.WhenAll(typeFetcher, subtypeFetcher, mainContent);

        Result.TypeId = typeFetcher.Result,
        Result.SubtypeId = subtypeFetcher.Result;

        return result;
    }
}

I want to initialize the task to a default value that does nothing. As you can see in the above code, the typeFetcher task is initialized using Task.FromResult<int?>(null); and when the given TaskOption implements IProcessType interface, the task is overridden using a custom task. The same scenario implies for the subtypeFetcher task.

For the mainContent task, I initialized it using a Task.CompletedTask and when Result.Content is not null, I set the mainContent to SetMainContentAsync(Result.Content) . Finally, I await all tasks using await Task.WhenAll(typeFetcher, subtypeFetcher, mainContent) .

The ASP.NET Core Performance Best Practices states the following

Do not : Block asynchronous execution by calling Task.Wait or Task.Result .

Since I am using Task.FromResult<int?>(null); to initialize the tasks, I feel that I am violating best practices. I would like to learn the correct approach to initialize an optional task.

Question What is the correct approach to initialize an optional task that returns type? Also, is initializing a task that does not return anything to Task.CompletedTask acceptable or is there a more correct approach?

Answer 1

What you are doing is fine. Task.FromResult is not Task.Result , the two are entirely unrelated.

Task.Result is an instance property that blocks the current thread until the task completes, and returns the result of the task.

Task.FromResult is a static method that returns a trivial, already completed task.

Answer 2

First things first: using .Result the way you are is "ok" because you already made sure it's complete by using await Task.WhenAll . Your code won't be sitting at .Result waiting for the result and blocking the thread. But I say "ok" in quotes because of the way exceptions are handled. When you use .Result , exceptions are always put inside of an AggregateException and you have to look inside to find the real exception.

However, you can still use await with completed tasks, and exceptions are thrown as you'd expect:

Result.TypeId = await typeFetcher;

As to the rest of the question: the best way I find to await multiple, optional tasks is to use a List<Task> and just add the tasks that are needed.

var taskList = new List<Task>();

However, this is complicated by the fact that you need to use the return values from the tasks. There are a couple ways to go about it. You can use a list that you await, but also keep a reference to each task itself as you already were. Initialize the Task to null and only set the value if it's not null . For example:

var taskList = new List<Task>();

Task<int?> typeFetcher = null;
if (option is IProcessType t)
{
    typeFetcher = t.GetAsync();
    taskList.Add(typeFetcher);
}

...

await Task.WhenAll(taskList);

if (typeFetcher != null)
{
    Result.TypeId = await typeFetcher;
}

...

But you keeping two references to the same thing is... I don't know. Seems like it could be done better.

Another option is to use local functions that set the value and add that to your task list. That way, you don't have to set the values after awaiting.

public async Task<ProcessResult> Process(TaskOption option)
{
    var taskList = new List<Task>();

    // First optional task
    if (option is IProcessType t)
    {
        // Declare a local function that sets the value
        async Task TypeFetcher()
        {
            Result.TypeId = await t.GetAsync();
        }

        // Call it and add the resulting Task to the list
        taskList.Add(TypeFetcher());
    }

    // Second optional task
    Task<int?> subtypeFetcher = Task.FromResult<int?>(null);
    if (option is IProcessSubtype st)
    {
        async Task SubtypeFetcher()
        {
            Result.SubtypeId = await st.GetAsync();
        }
        taskList.Add(SubtypeFetcher());
    }

    // Third optional task
    if(Result.Content != null) 
    {
        //don't need a local function here since there's no return value
        taskList.Add(SetMainContentAsync(Result.Content));
    }

    await Task.WhenAll(taskList);

    //I assume you actually declared and set result somewhere
    return result;
}

I'm not saying that's any more efficient than keeping two references to each Task . Just do what you find least confusing.