使用主线程而不阻塞它的异步方法示例。＃

Question

In the page 18 Concurrency in C# Cookbook,Stephen Cleary define Asynchronous Programming : "A form of concurrency that uses futures or callbacks to avoid unnecessary threads." but in code all Async Method uses multi threads (Thread Pool). Can same one please show me an example of an Async Method that uses the main thread without blocking it.

Answer 1

Consider, for example, a method that sends some http request and gives you some http response. If this method would be synchronous (eg WebRequest.GetResponse() ) then 90% time this method would just wait due to network latency, and hence Thread on which this method executed would just sleep and do nothing.

When you using an async method (eg HttpClient.PostAsync() ) and await the result, then the calling method ends with the first await , so the calling thread is free to process other work or can be returned to ThreadPool. When your http response is received, then your work will be resumed.

The Thread on which the continuation will run depends on the SynchronizationContext . So, if you ran and awaited an Async method from the UI thread, then the continuation will run on the UI thread. If you ran and awaited an async method from background thread then the continuation will run on some ThreadPool Thread.

async void button_click(object sender, EventArgs args)
{
    _button.Enabled = false; // this is invoked on main thread

    var response = await _httpClient.PostAsync(request); 
    // you will not block main thread and your UI will be responsive
    // also you won't occupy ThreadPool thread for all the time to get the response

    ProcessResponse(response); // this is invoked on main thread
}

Some Async methods would just run in the background and occupy a background thread for all the time they needed to be completed, and some (IO basically) would not.

Answer 2

Consider this simple windows form program:

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    protected override void OnLoad(EventArgs e)
    {
        GetPoint();
    }

    public async void GetPoint()
    {
        var point = await RetrivePointAsync();
        MessageBox.Show(point.ToString());
    }

    public Task<Point> RetrivePointAsync()
    {
        return Task.Factory.FromAsync<Point>(
             (callback, state) => new Handler(this, callback),
             x => ((Handler)x).Point, null);
    }
}



class Handler : IAsyncResult
{
    AsyncCallback _calback;
    public Point Point { get; set; }
    public object AsyncState { get { return null; } }
    public bool CompletedSynchronously { get { return false; } }
    public bool IsCompleted { get; set; }

    public WaitHandle AsyncWaitHandle { get { return null; } }

    public Handler(Control control, AsyncCallback calback)
    {
        _calback = calback;
        control.MouseDown += control_MouseDown;
    }

    void control_MouseDown(object sender, MouseEventArgs e)
    {
        Point = e.Location;
        IsCompleted = true;
        _calback(this);
    }
}

As you see no new threads are created to create async method. My custom handler just wraps mouse down event on a form.

Answer 3

Not all async methods require a dedicated thread. Typically, those waiting for an I/O completion don't necessarily require a thread.

TaskCompletionSource allows such scenario

Answer 4

This is example from "CLR via C#" book:

private static async Task<String> IssueClientRequestAsync(String serverName, String message) { 
   using (var pipe = new NamedPipeClientStream(serverName, "PipeName", PipeDirection.InOut,  
      PipeOptions.Asynchronous | PipeOptions.WriteThrough)) { 
      pipe.Connect(); // Must Connect before setting ReadMode 
      pipe.ReadMode = PipeTransmissionMode.Message; 
      // Asynchronously send data to the server 
      Byte[] request = Encoding.UTF8.GetBytes(message); 
      await pipe.WriteAsync(request, 0, request.Length); 
      // Asynchronously read the server's response 
      Byte[] response = new Byte[1000]; 
      Int32 bytesRead = await pipe.ReadAsync(response, 0, response.Length); 
      return Encoding.UTF8.GetString(response, 0, bytesRead); 
   }  // Close the pipe 
} 

Here executing thread is released just after WriteAsync call. After network driver completes its work, execution will continue until ReadAsync, when thread will be released again until data is read.