这些以下异步方法之间有什么区别？

Question

I've actually some problems with understanding the principle from async. Can someone tell me the different between the following code examples? If someone thinks, that this example are completely wrong can this guy give me a correction?

So here's my code:

private async void DoHardStuffAsync()
    {
        var result = DoHardStuff();
        var secondResult = DoHardStuff();
        var thirdResult =  DoHardStuff();

        await Task.WhenAll(result, secondResult, thirdResult);

        MessageBox.Show(result.Result + secondResult.Result + thirdResult.Result);
    }

    private Task<string> DoHardStuff()
    {
        return Task.Run(() =>
        {
            var time = DateTime.Now;
            while (DateTime.Now.Subtract(time).Milliseconds < 900)
            { }

            return "finished";
        });
    }

And this:

private async void DoHardStuffAsync()
    {
        var result = DoHardStuff();
        var secondResult = DoHardStuff();
        var thirdResult =  DoHardStuff();

        MessageBox.Show(await result + await secondResult + await thirdResult);
    }

And why is async != parallel? For what should I use async and for what should I use parallel (for example tasks, threads)?

Answer 1

Parallelism and asynchrony are two different forms of concurrency. Parallelism is using multiple threads (eg, for CPU-bound code). Asynchrony uses multiple operations but not necessarily multiple threads (eg, for I/O-bound code).

Task.Run is a kind of bridge between these two worlds. It starts (presumably CPU-bound) code running on a background thread, and returns a task that allows the calling thread to treat that work asynchronously.

While Task.Run is OK for basic parallelism, if you have real CPU-bound work to do, you'd be better off using Parallel or Parallel LINQ.

Regarding your code examples, they're both pretty similar: three background tasks are started and the calling thread asynchronously waits for them all to complete.

The first one does call Task<T>.Result , which I discourage, because if there was some exception then Result wraps the exception in an AggregateException while await raises the exception directly. The AggregateException complicates error handling.

The second one calls await individually on each task, which is OK but IMO not ideal. I think the await Task.WhenAll(..) approach has a clearer intent (and it's just a tiny bit more efficient, too).

So, I'd recommend combining the approaches:

private async Task DoHardStuffAsync()
{
  var result = DoHardStuff();
  var secondResult = DoHardStuff();
  var thirdResult =  DoHardStuff();

  await Task.WhenAll(result, secondResult, thirdResult);

  MessageBox.Show(await result + await secondResult + await thirdResult);
}

I also changed the return type to Task . As a general rule, you should avoid async void , as I describe in an MSDN article.

The implementation of DoHardStuff is a bit questionable, too. In general, you should use Task.Run to call a method, not as the implementation of a method. I have a blog post that goes into details on this subject.

Answer 2

The methods are for reasons of practicality similar. However your call to Task.Result is in my opinion where they differ. This assumes the operation is complete and gets the result of the task. It is pretty dangerous to do this and since it may blow up, you are better off using await .