Return to Answer

An alternative implementation that has more or less the same performance characteristics could be:

 public async Task<string> Foobar() { using (var carTask = BuyCarAsync()) using (var catTask = FeedCatAsync()) using (var houseTask = SellHouseAsync()) { cat = catTask.Status == TaskStatus.RanToCompletion ? catTask.Result : (await catTask); car = carTask.Status == TaskStatus.RanToCompletion ? carTask.Result : (await carTask); house = houseTask.Status == TaskStatus.RanToCompletion ? houseTask.Result : (await houseTask); return DoSomething(cat, car, house); } } 

Forward Warning

Just a quick headsup to those visiting this and other similar threads looking for a way to parallelize EntityFramework using async+await+task tool-set: The pattern shown here is sound, however, when it comes to the special snowflake of EF you will not achieve parallel execution unless and until you use a separate (new) db-context-instance inside each and every *Async() call involved.

This sort of thing is necessary due to inherent design limitations of ef-db-contexts which forbid running multiple queries in parallel in the same ef-db-context instance.

Capitalizing on the answers already given, this is the way to make sure that you collect all values even in the case that one or more of the tasks results in an exception:

 public async Task<string> Foobar() { async Task<string> Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) { return DoSomething(await a, await b, await c); } using (var carTask = BuyCarAsync()) using (var catTask = FeedCatAsync()) using (var houseTask = SellHouseAsync()) { if (carTask.Status == TaskStatus.RanToCompletion //triple && catTask.Status == TaskStatus.RanToCompletion //cache && houseTask.Status == TaskStatus.RanToCompletion) { //hits return Task.FromResult(DoSomething(catTask.Result, carTask.Result, houseTask.Result)); //fast-track } cat = await catTask; car = await carTask; house = await houseTask; //or Task.AwaitAll(carTask, catTask, houseTask); //or await Task.WhenAll(carTask, catTask, houseTask); //it depends on how you like exception handling better return Awaited(catTask, carTask, houseTask); } } 

The aggregate exception which contains one or more sub-exceptions will still be thrown at the end. It's up to the calling environment to handle that properly.

Forward Warning

Just a quick headsup to those visiting this and other similar threads looking for a way to parallelize EntityFramework using async+await+task tool-set: The pattern shown here is sound, however, when it comes to the special snowflake of EF you will not achieve parallel execution unless and until you use a separate (new) db-context-instance inside each and every *Async() call involved.

This sort of thing is necessary due to inherent design limitations of ef-db-contexts which forbid running multiple queries in parallel in the same ef-db-context instance.

Capitalizing on the answers already given, this is the way to make sure that you collect all values even in the case that one or more of the tasks results in an exception:

 public async Task<string> Foobar() { async Task<string> Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) { return DoSomething(await a, await b, await c); } using (var carTask = BuyCarAsync()) using (var catTask = FeedCatAsync()) using (var houseTask = SellHouseAsync()) { if (carTask.Status == TaskStatus.RanToCompletion //triple && catTask.Status == TaskStatus.RanToCompletion //cache && houseTask.Status == TaskStatus.RanToCompletion) { //hits return Task.FromResult(DoSomething(catTask.Result, carTask.Result, houseTask.Result)); //fast-track } cat = await catTask; car = await carTask; house = await houseTask; //or Task.AwaitAll(carTask, catTask, houseTask); //or await Task.WhenAll(carTask, catTask, houseTask); //it depends on how you like exception handling better return Awaited(catTask, carTask, houseTask); } } 

Forward Warning

Just a quick headsup to those visiting this and other similar threads looking for a way to parallelize EntityFramework using async+await+task tool-set: The pattern shown here is sound, however, when it comes to the special snowflake of EF you will not achieve parallel execution unless and until you use a separate (new) db-context-instance inside each and every *Async() call involved.

This sort of thing is necessary due to inherent design limitations of ef-db-contexts which forbid running multiple queries in parallel in the same ef-db-context instance.

Capitalizing on the answers already given, this is the way to make sure that you collect all values even in the case that one or more of the tasks results in an exception:

  var car = (Car) null; var cat = (Cat) null; var house = (House) null; using (var carTask = BuyCarAsync()) using (var catTask = FeedCatAsync()) using (var houseTask = SellHouseAsync()) { try {  await Task.WhenAll(carTask, catTask, houseTask); //or Task.WhenAny(carTask, catTask, houseTask);  } finally {  car = carTask.Status == TaskStatus.RanToCompletion ? await carTask : null; cat = catTask.Status == TaskStatus.RanToCompletion ? await catTask : null;  house = houseTask.Status == TaskStatus.RanToCompletion ? await houseTask : null;  }  if (cat == null || car == null || house == null)  throw new SomethingFishyGoingOnHereException("..."); } 

The aggregate exception which contains one or more sub-exceptions will still be thrown at the end. It's up to the calling environment to handle that properly.

Forward Warning

Just a quick headsup to those visiting this and other similar threads looking for a way to parallelize EntityFramework using async+await+task tool-set: The pattern shown here is sound, however, when it comes to the special snowflake of EF you will not achieve parallel execution unless and until you use a separate (new) db-context-instance inside each and every *Async() call involved.

This sort of thing is necessary due to inherent design limitations of ef-db-contexts which forbid running multiple queries in parallel in the same ef-db-context instance.

Capitalizing on the answers already given, this is the way to make sure that you collect all values even in the case that one or more of the tasks results in an exception:

 public async Task<string> Foobar() { async Task<string> Awaited(Task<Cat> a, Task<House> b, Task<Tesla> c) {   return DoSomething(await a, await b, await c);   }   using (var carTask = BuyCarAsync()) using (var catTask = FeedCatAsync()) using (var houseTask = SellHouseAsync()) { if (carTask.Status == TaskStatus.RanToCompletion //triple  && catTask.Status == TaskStatus.RanToCompletion //cache  && houseTask.Status == TaskStatus.RanToCompletion) { //hits  return Task.FromResult(DoSomething(catTask.Result, carTask.Result, houseTask.Result)); //fast-track   }  cat = await catTask;  car = await carTask;  house = await houseTask;  //or Task.AwaitAll(carTask, catTask, houseTask);  //or await Task.WhenAll(carTask, catTask, houseTask); //it depends on how you like exception handling better      return Awaited(catTask, carTask, houseTask);   }  } 

The aggregate exception which contains one or more sub-exceptions will still be thrown at the end. It's up to the calling environment to handle that properly.