CODEWITHSUNDEEP
async-awaitasp.net-web-api2
developer9969
developer9969

Reputation: 5236

async methods calling sync methods

New to async and trying to understand when it makes sense to use it. We are going to have lots methods in webapi2 calling legacy webservices.

We have lots of low level dlls (Company.Dal.dll,Company.Biz.dll) etc.. that have methods that are not async

Question Does async has to be all the way really ? Is there any benefit of having an high level dll (all method async) calling low level dlls (dal,biz etc legacy code) where none of the method are async?

Is it there any benefit in having just the high level component to be async and the rest syncronous?

enter image description here

Many thanks for clarification Any good tutorials explaning this concept

Upvotes: 0

Views: 68

Answers (2)

Harald Coppoolse
Harald Coppoolse

Reputation: 30512

A thread can only do one thing at a time. If procedures keep your thread busy, there is no sense in making them async.

However if there are periods where the thread in your procedure has to wait for something else to finish, your thread might do something useful instead. In those circumstances async-await becomes useful.

Eric lippert once explained async-await with a restaurant metaphor (search on the page for async-await). If you have a cook who has to wait until the bread is toasted, this cook could do something else, like cooking an egg, and get back to the toaster when the "something else" is finished, or when has to wait for something, like await for the egg to be cooked.

In software the things where your thread typically will do nothing except waiting for something to finish is when reading / writing to disk, sending or receiving data over the network etc. Those are typically actions where you can find async versions as well as non-async versions of the procedure. See for instance classes like Stream, TextReader, WebClient, etc.

If your thread has to do a lot of calculations, it is not useful to make the function async, because there is no moment your thread will not do anything but wait, so your thread won't have time to do other things.

However, if your thread could do something useful while the calculations are done, consider letting another thread do those calculations while your thread is doing the other useful stuff:

private async Task<int> MyLengthyProcedure(...)
{
    Task<int> calculationTask = Task.Run( () => DoCalculations(...));
    // while one of the threads is doing the calculations,
    // your thread could do other useful things:
    int i = DoOtherCalculations();

    // or if there are calculations that could be performed
    // by separate threads simultaneously, start a second task
    Task<int> otherCalculationTask = Task.Run( () => DoEvenMoreCalculations(...));

    // now two threads are doing calculations. This thread is still free to
    // do other things

    // after a while you need the result of both calculations:
    await Task.WhenAll( new Task[] {calculationTask, otherCalculationTask});

    // the int return value of DoCalculations and DoOtherCalculations are in
    // the Result property of the task object:
    int j = calculationTask.Result;
    int k = otherCalculationTask.Result;
    return i + j + k;
;

Upvotes: 0

svick
svick

Reputation: 244998

Using async only makes sense if you actually await something. If you don't, the async method will actually be completely synchronous (and you get a warning from the compiler about it).

In this case, async doesn't have any advantages, only disadvantages: the code is more complex and less efficient.

Upvotes: 1

Related Questions