异步等待一个简单的包装方法

Question

If I write a method that is just wrapping an async method such as this:

public async Task WrapMethodAsync()
{
    using(var smtpClient = new SmtpClient())
    {
        await smtpClient.SendMailAysnc(new MailMessage());
    }
}

Is that the same as doing the following:

public Task WrapMethodAsync()
{
    using(var smtpClient = new SmtpClient())
    {
        return smtpClient.SendMailAysnc(new MailMessage());
    }
}

Or is the latter not actually running asynchronously?

Answer 1

In this exact scenario the two cases are extremely different because of the using scope.

In the first case you wait (asynchronously) for the SendMailAysnc operation to complete before disposing of the client while in the other case you don't so you would dispose of the client while the operation is still running .

In the general case where there isn't a difference in the general behavior. For example this:

public async Task Run()
{
    throw new Exception("stored");
    await Task.Delay(-1);
}

VS this:

public Task Run()
{
    throw new Exception("thrown");
    return Task.Delay(-1);
}

The difference is that the async method has a slight overhead of the whole async mechanism (including a state machine) while the non- async task-returning method has a different exception semantics as exceptions are thrown directly and not stored in the returned task .

Answer 2

The first snippet disposes of the client after the mail is sent, the latter disposes of the client after it starts sending the mail, but before it has finished. Assuming the client isn't supposed to be disposed while it is sending messages, it means that the first solution is very problematic.

Additionally, the error handling semantics are different; exceptions in constructing the Task in the first snippet will result in the method throwing an exception, whereas in the second snippet they result in the return task being marked as Faulted with the appropriate exception set.