-5

Can you briefly explain me why the first two rows of this code are not running parallel? How could I make it work paralell?

SensorLeft and SensorRight are of the same class, and Distance is a public property of it which needs some time to be calculated when calling its get method.

What am I doing wrong? Should I make the Distance calculation as an async function instead to be right?

public async void GetDistance()
{
    await Task.Run(() => LeftDistance = SensorLeft.Distance);
    await Task.Run(() => RightDistance = SensorRight.Distance);
    Distance = RightDistance < LeftDistance ? RightDistance:LeftDistance;
}
Improve this question
4
  • When you await the first task you are waiting for it to finish before moving to the next line of code. Assign the tasks first then use Task.WhenAll to let them run at the same time. Commented Jan 25, 2018 at 17:43
  • async void is only meant for event handlers.You should use async Task. await means await for an asynchronous operation to finish. It's Task.Run that starts work in parallel, not await. If you want the operations to run in parallel store the returned tasks in an array and use await Task.WhenAll(tasks) to wait for both of them to finish. Commented Jan 25, 2018 at 17:46
  • Also unless you are calling an async method that does IO Completion Ports, this is not only slower, but using threads causing possibly even more performance problems. Commented Jan 25, 2018 at 17:58
  • 1
    Remember, await does not make something asynchronous. Await checks to see if a task is complete, and if it is not, returns so that the caller can find more work to do. In that case the remainder of the method is made into the completion of the awaited task. If you think that await makes something asynchronous, purge that incorrect belief from your mind today. Commented Jan 25, 2018 at 18:13

1 Answer 1

Reset to default
-1

When the compiler encounters await keyword it will automatically schedule a task in task scheduler. The operation waits (in a non-blocking manner) for the task to complete before continue to do the rest of the code block.

To make your code run in parallel you need to modify it into 

public async Task GetDistance()
{
    var leftDTask = Task.Run(() => LeftDistance = SensorLeft.Distance);
    var rightDTask= Task.Run(() => RightDistance = SensorRight.Distance);
    await Task.WhenAll(leftDTask,rightDTask);
    Distance = RightDistance < LeftDistance ? RightDistance:LeftDistance;
}

Task.WhenAll has an overload to return Task<TResult[]> Task.WhenAll<TResult[]>. and you can replace your code into 

public async Task GetDistance()
{
    var leftDTask = Task.Run(() => SensorLeft.Distance);
    var rightDTask= Task.Run(() => SensorRight.Distance);
    var results= await Task.WhenAll(leftDTask,rightDTask);
    Distance = Math.Min(results[0],results[1]);
}

However, this is not a good solution. If you want the get distance truly asynchronous, you should make an asynchronous get method rather wrap it into Task.Run.

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

2 Comments

Thank you! What is the difference in wrapping it into Task.Run or making the get async? Btw can I make a property getter async or I must make it as a function?
The property getter does not support async, you must make a getter function. I admitted that wrapping a synchronous operation into Task.Run is a quickest way to make an asynchronous operation but it isn't recommended. Stephen Toub MSFT has a better explanation in this blog blogs.msdn.microsoft.com/pfxteam/2012/03/24/…

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.