异步等待和C＃中的任务

Question

I'm testing the async await and task functionality but it seems i'm missing something

When I write like this A being starting point .

void A()
{
   Debug.WriteLine("pre B");
   B();
   Debug.WriteLine("post B");
}

async void B()
{
    Debug.WriteLine("pre C");
    await C();
    Debug.WriteLine("post C")
}

async Task C()
{
   await Task.Yield();
   Debug.WriteLine("pre D");
   await D();
   Debug.WriteLine("post D");
}

async Task D()
{
   Debug.WriteLine("inside D");
}

I get output in debug console as

pre B,
pre C,
pre D,
inside D,
post D,
post C,
post B

Is it running asynchronously?? I guess not, what thought it should run like

pre B,
pre C,
post B,
post C,
pre D,
inside D,
post D

So what's the problem here?

Answer 1

I recommend you read my async intro and follow up with my async best practices article . In particular, one of the best practices is to only use async void for event handlers.

The whole point of async is to enable asynchronous code while keeping that code written in a similar way to synchronous code . So if an outer method await s the task returned from an inner method, then the outer method will not continue executing until the inner method completes.

So, for example, synchronous code may look like this:

void A()
{
  Debug.WriteLine("pre B");
  B();
  Debug.WriteLine("post B");
}

void B()
{
  Debug.WriteLine("inside B");
  Thread.Sleep(1000);
  Debug.WriteLine("still inside B");
}

The corresponding asynchronous code would be:

async Task A()
{
  Debug.WriteLine("pre B");
  await B();
  Debug.WriteLine("post B");
}

async Task B()
{
  Debug.WriteLine("inside B");
  await Task.Delay(1000);
  Debug.WriteLine("still inside B");
}

Even though the code will now execute asynchronously, the output is exactly the same as the synchronous version.

If you want one method to start concurrent operations and then continue, you can just call the methods and then do the await later:

async Task A()
{
  // Start both tasks
  Debug.WriteLine("pre B1");
  Task b1 = B();
  Debug.WriteLine("post B1, pre B2");
  Task b2 = B();
  Debug.WriteLine("post B2, pre await");

  // (asynchronously) wait for them to complete
  await Task.WhenAll(b1, b2);
  Debug.WriteLine("post await");
}

async Task B()
{
  Debug.WriteLine("inside B");
  await Task.Delay(1000);
  Debug.WriteLine("still inside B");
}

And in this case, you'll see both executions of B start, and A will continue executing after both B s complete.

Answer 2

I changed the code now it looks like

using System;
using System.Threading.Tasks;

namespace TaskClass
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Pre A");
            A();
            Console.WriteLine("Post A");
            Console.ReadKey();
        }
        static async Task A()
        {
            Console.WriteLine("pre B");
            await B();
            Console.WriteLine("post B");
        }

        static async Task B()
        {
            Console.WriteLine("inside B");
            await Task.Delay(10000);
            Console.WriteLine("still inside B");
        }

    }
}

And output i'm getting is as suspected.
Pre A

pre B

inside B

Post A

still inside B

post B

So you see as soon as I'm hitting await Task.Delay(10000); the control goes back to Main method, as evident from the fact that its printing Post A before still inside B also after Console.WriteLine("Post A"); It waits for Console.ReadKey(); only because as soon as I hit any key execution stops. It doesn't wait for Console.WriteLine("still inside B"); .

So simple yet so strange. .net!! :)

Answer 3

I guess, that it runs sync cuz you`re using await statements, which waits for your methods to be done. So if you want to get result like 2d variant - try not to use await

Answer 4

That's normal. Async/Await means that the method is suspended until the task is complete. That task runs asynchronously but the current thread waits for it and the current thread is no blocked.

This is specially useful if you don't want to block the ui thread when a method waits for a result that may be long to come.

From MSDN

Async Improves Responsiveness

Asynchrony is essential for activities that are potentially blocking, such as when your application accesses the web. Access to a web resource sometimes is slow or delayed. If such an activity is blocked within a synchronous process, the entire application must wait. In an asynchronous process, the application can continue with other work that doesn't depend on the web resource until the potentially blocking task finishes.

The following table shows typical areas where asynchronous programming improves responsiveness. The listed APIs from the .NET Framework 4.5 and the Windows Runtime contain methods that support async programming.

Application area

Supporting APIs that contain async methods

Web access

HttpClient , SyndicationClient

Working with files

StorageFile, StreamWriter, StreamReader, XmlReader

Working with images

MediaCapture, BitmapEncoder, BitmapDecoder

WCF programming

Synchronous and Asynchronous Operations

Asynchrony proves especially valuable for applications that access the UI thread because all UI-related activity usually shares one thread. If any process is blocked in a synchronous application, all are blocked. Your application stops responding, and you might conclude that it has failed when instead it's just waiting

For example, you can have a method that returns a value.

public async Task<int> LongComputation()

And then, in your code you have:

var result = await LongComputation();

The current thread is not blocked. When the result is available, you get it in your variable and you can continue with it in your current thread.

---

If you want to launch a new task asynchronously, you can do it like that

Task.Factory.StartNew(async () =>
                {
                    Debug.WriteLine("async start");
                    await Task.Delay(5000);
                    Debug.WriteLine("async end");
                });

---

In your method B, you can try the following

async void B()
{
    Debug.WriteLine("pre C");
    var taskC = C();
    Debug.WriteLine("post C")
    await taskC;
}