如何在.NET Core中执行多个任务，并检查哪个成功完成

Question

I am trying to perform the following scenario:

• Create multiple tasks
  • all tasks are in the same structure (same code with different parameters)
  • the structure is: try to do, catch if failed, and throw the exception / an exception
• Run them in parallel and wait for their completion
• After completion, check which tasks threw exception and which were succeeded, without the exception being thrown

public class Controller : ControllerBase
    {
        private readonly List<string> _names = new List<string>()
        {
            "name1",
            "name2"
        };

        [HttpGet]
        public async Task<ActionResult> Get()
        {
            // Leaving this processing because it is the same in the original code, maybe there is something here that is relevant
            var tasks = _names.ToDictionary(name => name, name => ExecuteRequest(name, async (value) =>
            {
                return await ReturnOrThrow(value);
            }));

            // I want to wait until all were finished
            await Task.WhenAll(tasks.Values); // This already throws an exception, i don't want it to
            // I don't want to catch exception here and just ignore it

            var namesThatSucceeded = tasks.Count(t => t.Value.IsCompletedSuccessfully);
            var namesThatThrewException = tasks.Count(t => t.Value.IsFaulted);

            return Ok(new
            {
                Succeeded = namesThatSucceeded,
                Failed = namesThatThrewException
            });
        }

        // The "generic task structure" that runs the request, catches exception if thrown, and re-throws it.
        private async Task<string> ExecuteRequest(string name, Func<string, Task<string>> request)
        {
            try
            {
                return await request(name);
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine(e.Message);
                throw; // I would prefer to just return Faulted Task here so it won't throw exception
            }
        }

        // The actual processing
        private async Task<string> ReturnOrThrow(string name)
        {
            if (name == "name1")
            {
                throw new HttpRequestException();
            }

            return await Task.FromResult(name);
        }
    }

Answer 1

You can wrap action with a high order function which has await and exception handler.

 class Program
{
    static async Task Main(string[] args)
    {
        var itemsToProcess = new[] { "one", "two" };
        var results = itemsToProcess.ToDictionary(x => x, async (item) =>
        {
            try
            {
                var result = await DoAsync();
                return ((Exception)null, result);
            }
            catch (Exception ex)
            {
                return (ex, (object)null);
            }
        });

        await Task.WhenAll(results.Values);

        foreach(var item in results)
        {
            Console.WriteLine(item.Key + (await item.Value).Item1 != null ? " Failed" : "Succeed");
        }
    }

    public static async Task<object> DoAsync()
    {
        await Task.Delay(10);
        throw new InvalidOperationException();
    }
}

Answer 2

您是否在调用 ExecuteRequest 的 ToDictionary 中缺少等待？

async name => await ExecuteRequest

Answer 3

You cannot avoid exception throwing in awaiting for Task.WhenAll(). That's behavior by design. But you can pass Task's status via it's Result value. Just extend the Result from string to (string Result, bool Success) and return false Success from catch without re-throwing Exception.

public class Controller : ControllerBase
{
    private readonly List<string> _names = new List<string>()
    {
        "name1",
        "name2"
    };

    [HttpGet]
    public async Task<ActionResult> Get()
    {
        // Leaving this processing because it is the same in the original code, maybe there is something here that is relevant
        var tasks = _names.ToDictionary(name => name, name => ExecuteRequest(name, async (value) =>
        {
            return await ReturnOrThrow(value);
        }));

        await Task.WhenAll(tasks.Values); // Doesn't throw exception anymore, but you can access Success status from Task's Result tuple

        var namesThatSucceeded = tasks.Count(t => t.Value.Result.Success);
        var namesThatThrewException = tasks.Count(t => !t.Value.Result.Success);

        return Ok(new
        {
            Succeeded = namesThatSucceeded,
            Failed = namesThatThrewException
        });
    }

    // The "generic task structure" that runs the request, catches exception if thrown, and re-throws it.
    private async Task<(string Result, bool Success)> ExecuteRequest(string name, Func<string, Task<string>> request)
    {
        try
        {
            return (await request(name), true);
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine(e.Message);
            return (null, false);
        }
    }

    // The actual processing
    private async Task<string> ReturnOrThrow(string name)
    {
        if (name == "name1")
        {
            throw new HttpRequestException();
        }

        return await Task.FromResult(name);
    }
}

You're welcome.

Answer 4

An easy way to suppress the exception of an awaited task is to pass the task as a single argument to Task.WhenAny :

Creates a task that will complete when any of the supplied tasks have completed.

await Task.WhenAny(Task.WhenAll(tasks.Values)); // Ignores the exception

This works because the task returned from Task.WhenAny never fails. When it completes, it is always completed successfully. There are two small drawbacks though:

1. It doesn't communicate clearly its intention, so adding a comment is advised.
2. This method accepts a params Task[] argument, so calling it results in an object allocation (avoid using it in hot paths).