Stuck with async await thread

Question

In constructor I want to call one method type :

private async Task OnLoadPrometDanKorisnikDatum

and I want to wait that method while its finish, and I have more method(3) like this and I want to call this 3 methods in background thread and don't wait him to finish, just want to wait first method. And I want to them executing parallel. I have methods async Task,and in constructor of view model I call like this

OnLoadPrometDanKorisnikDatum(KorisnikID, PomocnaDnDDatnaDat, 
    DatumVrednost).Wait();
OnLoadPrometNedelja(KorisnikID, PomocnaDnDDatnaDatNedelja).Wait();

if I don't place .Wait() on the end, program doesn't work. I see in debug mode they run asynchronly, but time spent tell me that they sub(one method time + second method time + ....). Can someone help me, this is for me very stuf...

Answer 1

Answer

The best way to handle your scenario is to use async void.

I recommend first reading the Explanation section below to fully understand the best practices around async void.

public MyConstructor()
{
    ExecuteAsyncMethods();
}

async void ExecuteAsyncMethods()
{ 
    try
    {
        await OnLoadPrometDanKorisnikDatum(KorisnikID, PomocnaDnDDatnaDat, DatumVrednost);
        await OnLoadPrometNedelja(KorisnikID, PomocnaDnDDatnaDatNedelja);
    }
    catch(Exception e)
    {
        //Handle Exception
    }
}

Explanation

Many C# devs are taught "Never use async void", but this is one of the few use-cases for it.

Yes async void can be dangerous and here's why:

• Cannot await an async avoid method
• Can lead to race conditions
• Difficult to catch an Exception thrown by async void methods
  • E.g. the following try/catch block will not catch the Exception thrown here:

public MyConstructor()
{
    try
    {
        //Cannot await `async void`
        AsyncVoidMethodWithException();
    }
    catch(Exception e)
    {
        //Will never catch the `Exception` thrown in  `AsyncVoidMethodWithException` because `AsyncVoidMethodWithException` cannot be awaited
    }

    //code here will be executing by the time `AsyncVoidMethodWithException` throws the exception
}

async void AsyncVoidMethodWithException()
{
    await Task.Delay(2000);
    throw new Exception();
}

That being said, as long as we wrap the contents of our entire async void in a try/catch block, we will be able to catch the exception, like so:

public MyConstructor()
{
    AsyncVoidMethodWithException();
}

async void AsyncVoidMethodWithException()
{
    try
    {
        await Task.Delay(2000);
        throw new Exception();
    }
    catch(Exception e)
    {
        //Exception will be caught and successfully handled 
    }
}

SafeFireAndForget

I created a library to help with this and its additional benefit is that it avoids writing async void code that could be potentially misused by future devs.

It's open source and also available on NuGet:

• Source Code
• NuGet Package

SafeFireAndForget

SafeFireAndForget allows us to safely execute a Task whilst not blocking the calling thread and without waiting for it to finish before moving to the next line of code.

Below is a simplified version of SafeFireAndForget that you can add to your project.

However, I recommend copy/pasting its complete source code or adding its NuGet Package to your library to get a more robust implementation

public static async void SafeFireAndForget<TException>(this Task task, Action<TException> onException = null, bool continueOnCapturedContext = false) where TException : Exception
{
    try
    {
        await task.ConfigureAwait(continueOnCapturedContext);
    }
    catch (TException ex) when (onException != null)
    {
        onException(ex);
    }
}

Using SafeFireAndForget

To use SafeFireAndForget, append it to your method call like so:

OnLoadPrometDanKorisnikDatum(KorisnikID, PomocnaDnDDatnaDat, DatumVrednost).SafeFireAndForget();
OnLoadPrometNedelja(KorisnikID, PomocnaDnDDatnaDatNedelja).SafeFireAndForget();

To handle any Exception thrown by that Task, use onException. Here's an example that prints the Exception to the Debug Console:

OnLoadPrometDanKorisnikDatum(KorisnikID, PomocnaDnDDatnaDat, DatumVrednost).SafeFireAndForget(ex => Debug.WriteLine(ex));
OnLoadPrometNedelja(KorisnikID, PomocnaDnDDatnaDatNedelja).SafeFireAndForget(ex => Debug.WriteLine(ex));