异步方法即使被调用也不会被执行

Question

My workflow: Constructor -> Calls async Method 1 -> Calls async Method 2 -> Calls async Method 3

Constructor:

public MyConstructor() {
    Method1();
}

Method1:

private async void Method1() {
    //do some stuff
    await Method2();
    //do some more stuff
}

Method 2:

protected internal async Task Method2() {
    //do some stuff
    var x = await Method3("someParams");
    //do some more stuff
}

Method 3:

public async Task<List<string>> Method3(string someParams) {
    Debug.WriteLine("I am here"); //Breakpoint doesn't get hit, no output "I am here"
}

Yeah I know, you probably wonder why I am using so many different async methods.. But there is some more stuff going on (but nothing that influences the problem!). The problem is, Debug.WriteLine("I am here"); does not get hit, and no exception is thrown.

What am I doing wrong?

Answer 1

In a nutshell: yes, as @fknx mentioned in a comment, the problem is that the code executes asynchronously and is not awaited, therefore the app exits before reaching the line in question.

There are a couple of bad practices in your example:

async void method

It is not a good idea to create such things as you loose track of the task. Please always define Task as the return value, it does not cost anything and it will help you write a correct API.

asynchronous call in a constructor

This is not a good design either, because (as you mentioned) you cannot await this method in a constructor so you will just fire up the task and loose it. Please consider using an async Init method instead.

So instead of this:

public class MyCustomClass
{
    public MyCustomClass()
    {
        // BAD CODE, do not do this
        Method1();
    }

    private async Task Method1()
    {
        //do some stuff
        await Method2();
        //do some more stuff
    }
}

You could do this:

class Program
{
    static void Main(string[] args)
    {
        var m = new MyCustomClass();

        m.InitializeAsync().Wait();

        Console.WriteLine("Before exit...");
    }
}

public class MyCustomClass
{
    public MyCustomClass()
    {
        // in a constructor you should not do anything async
    }

    public async Task InitializeAsync()
    {
        await Method1();
    }

    private async Task Method1()
    {
        //do some stuff
        await Method2();
        //do some more stuff
    }
}

It is absolutely OK to Wait for an async method in the Main method , or to be precise your console app should have only one Wait (or WaitAll, or whatever) method in the main method (and nowhere else) if you want to create a truly async app.