何时使用“await”关键字

Question

I'm writing a web page, and it calls some web services. The calls looked like this:

var Data1 = await WebService1.Call();
var Data2 = await WebService2.Call();
var Data3 = await WebService3.Call();

During code review, somebody said that I should change it to:

var Task1 = WebService1.Call();
var Task2 = WebService2.Call();
var Task3 = WebService3.Call();

var Data1 = await Task1;
var Data2 = await Task2;
var Data3 = await Task3;

Why? What's the difference?

Answer 1

Servy's answer is correct; to expand on that a little. What's the difference between:

Eat(await cook.MakeSaladAsync());
Eat(await cook.MakeSoupAsync());
Eat(await cook.MakeSandwichAsync());

and

Task<Salad> t1 = cook.MakeSaladAsync();
Task<Soup> t2 = cook.MakeSoupAsync();
Task<Sandwich> t3 = cook.MakeSandwichAsync();
Eat(await t1);
Eat(await t2);
Eat(await t3);

?

The first is:

• Cook, please make me a salad
• While waiting for the salad, you have some free time to brush the cat. When you're done that, oh, look, the salad is done. If the cook finished the salad while you were brushing the cat, they did not start on making the soup because you haven't asked for it yet .
• Eat the salad. The cook is now idle while you eat.
• Cook, please make me some soup.
• While waiting for the soup you have some free time to clean the fish tank. When you're done that, oh, look, the soup is done. If the cook finishes the soup while you are cleaning the fish tank, they do not start on the sandwich because you haven't asked for it yet.
• Eat the soup. The cook is now idle while you eat.
• Cook, please make me a sandwich.
• Again, find something else to do while you're waiting.
• Eat the sandwich.

Your second program is equivalent to:

• Cook, please make me a salad
• Cook, please make me some soup.
• Cook, please make me a sandwich.
• Is the salad done? If not, while waiting for the salad, you have some free time to brush the cat. If the cook finished the salad while you were brushing the cat, they started making the soup .
• Eat the salad. The cook can still be working on the soup and sandwich while you are eating.
• Is the soup done? ...

You see the difference? In your original program you don't tell the cook to start the next course until you are done eating the first course. In your second program you request all three courses up front, and eat them -- in order -- as they come available. The second program makes better use of the cook's time because the cook can "get ahead" of you.

Answer 2

In the first code snippet you're not even starting the second service call until the first service call completes (and likewise not starting the third until the second completes). In short, they are executed sequentially.

In the second snippet you start all three service calls, but then don't continue on in the code until all three are done. In short, they are all executed in parallel.

If the second/third calls are unable to be started until they have the result of the previous operation then you would need to do something like the first snippet in order to make it work. If the service calls don't depend on each other at all then you'd want them to be executed in parallel for performance reasons.

If, for some reason, you really dislike having the extra local variables, there are other ways of executing the tasks in parallel using alternate syntaxes. One alternative that would act like your second option is:

var Data = await Task.WhenAll(WebService1.Call(), 
    WebService2.Call(), 
    WebService3.Call());

Answer 3

Servy posted a very good answer, but here is a visual description using Task s to help show what the problem is. This code will not be functionaly the same as yours (it does not do all the synchronization context stuff like giving back control to the message pump) but it illustrates the problem very well.

Your code is doing something like this

var fooTask = Task.Factory.StartNew(Foo);
fooTask.Wait();
var fooResult = fooTask.Result;

var barTask = Task.Factory.StartNew(Bar);
barTask.Wait();
var barResult = barTask.Result;

var bazTask = Task.Factory.StartNew(Baz);
bazTask.Wait();
var bazResult = bazTask.Result;

and the corrected code is doing something like this

var fooTask = Task.Factory.StartNew(Foo);
var barTask = Task.Factory.StartNew(Bar);
var bazTask = Task.Factory.StartNew(Baz);

fooTask.Wait();
var fooResult = fooTask.Result;
barTask.Wait();
var barResult = barTask.Result;
bazTask.Wait();
var bazResult = bazTask.Result;

You can see that all 3 tasks are running while waiting for the first result to get back, where in the first example the 2nd task does not start until the first task is finished.