Return "normal" variable from async Task Method

Question

In one of my methods, I want to create a car like this:

public string[] CreateCar()
{
    string[] wheels = CreateWheels();

    // Also add motor and other stuff here
    string[] motor = ...;

    return new string[][]{ wheels, motor, ... };
}

Here four wheels a created and they don't depend on each other. Hence, I can place them in multiple tasks, do be parallelised. (In my real code, this is not possible with a parallel-for loop)

public string[] CreateWheels()
{
    Task FL = Task.Run(() => CreateWheel("front left");
    Task FR = Task.Run(() => CreateWheel("front right");
    Task BL = Task.Run(() => CreateWheel("back left");
    Task BR = Task.Run(() => CreateWheel("back right");

    // Here I really want to wait for all wheels to be created!
    // STOP THE PROCESS HERE UNTIL ALL WHEELS ARE COMPLETED!!!
    string[] wheels = await Wask.WhenAll(FL, FR, BL, BR); 

    return wheels;
}

And one single wheel is created something like that:

public string CreateWheel(string position)
{
    // Here a wheel is created, whatever it takes :)
    return "wheel " + position;
}

My problem now is the following:
In order to get the code compiled, it forces me to mark CreateWheels as an async-Method. Otherwise I cannot use await.
⇒ But this forces me to change its return-value to be a Task<string[]>
⇒ However, then I need to put an await in front of CreateWheels() in the CreateCar-Method in order to get the string array and not the Task itself

⇒ Then the cycle repeats, since now, there is an await in the CreateWheels, forcing me to make it async ... and so on, and so on ...

This cycle repeats all the way up, until it finally comes to a void method, where you don't need to extract the return value with an await

What is the way out of this cycle, if I only want to wait for all wheels to be finished at the marked point?

Unless CreateCar is a particularity demanding method then I don't see why you want to use Task.Run to execute it. — Sean
– Sean, Commented Mar 27, 2020 at 14:04
string[] wheels = Task.WhenAll(FL, FR, BL, BR).Result; should work — UnholySheep
– UnholySheep, Commented Mar 27, 2020 at 14:05
@UnholySheep: oh thats nice! Do all tasks still get executed in parallel then? — Pixel_95
– Pixel_95, Commented Mar 27, 2020 at 14:06
Is there a reason you don't want to make the code async all the way down? — Tyler Hundley
– Tyler Hundley, Commented Mar 27, 2020 at 14:12
As others have mentioned async tends to be "infectious" in a way. Depending on how deeply nested this code is it can be kind of a pain to swap everything over, but its less of a pain than trying to debug any deadlock conditions you may end up with from using .Result on a task IMO. — Tyler Hundley
– Tyler Hundley, Commented Mar 27, 2020 at 14:23

Marc Gravell · Accepted Answer · 2020-03-27 14:13:59Z

2

If you want this to be synchronous, then Task.WaitAll may help, i.e.

Task.WaitAll(FL, FR, BL, BR);
var wheels = new[] {FL.Result, FR.Result, BL.Result, BR.Result};

If you want this to be asynchronous, you'll need to make the method async [Value]Task<string[]>, and propagate the async-ness throughout. Async is adhesive - it sticks to everything; but:

string[] wheels = await Task.WhenAll(FL, FR, BL, BR);

However, frankly, I suspect that there's no need for either in this case; parallelism isn't cheap - and is probably adding a lot more overhead than it is worth here.

edited Mar 27, 2020 at 14:13

answered Mar 27, 2020 at 14:07

Marc Gravell

1.1m273 gold badges2.6k silver badges3k bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Theodor Zoulias · Accepted Answer · 2021-01-18 06:16:23Z

1

It is possible to achieve parallelism by starting multiple tasks with Task.Run, but why not use a specialized tool for the job like the PLINQ library? Not only you'll avoid using the Task.Result property, which is notorious for causing nasty deadlocks when combined with await, but you'll also get the ability to define the maximum degree of parallelism as a bonus:

var wheelNames = new[] { "front left", "front right", "back left", "back right" };
string[] wheels = wheelNames
    .AsParallel()
    .AsOrdered()
    .WithDegreeOfParallelism(4)
    .Select(x => CreateWheel(x))
    .ToArray();

edited Jan 18, 2021 at 6:16

answered Mar 27, 2020 at 15:32

Theodor Zoulias

46.1k8 gold badges112 silver badges155 bronze badges

Comments

Buh Buh · Accepted Answer · 2020-03-27 14:10:26Z

0

string[] wheels = Wask.WhenAll(FL, FR, BL, BR).Result;

would do what you want. Those individual Tasks will still be run in parallel.

The downside is that your calling thread will block until these tasks are all resolved.

answered Mar 27, 2020 at 14:10

Buh Buh

7,5262 gold badges38 silver badges64 bronze badges

3 Comments

Pixel_95 Over a year ago

NIce thanks! That my calling thread is block cannot be avoided anyways, if the following code depends on the outcome of CreateWheels() right?

Tyler Hundley Over a year ago

Instead of using WhenAll().Result why not use WaitAll() since it is the synchronous counterpart to WhenAll?

Buh Buh Over a year ago

@TylerHundley Either is ok. WhenAll will unwrap all the tasks in one go and leave you with a normal array of strings. If you compare my answer to Marc's then you see that even after calling WaitAll he still has to deal with several Tasks and call Result several times. But it's just preference.

Collectives™ on Stack Overflow

Return "normal" variable from async Task Method

3 Answers 3

Comments

Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related