1 例子1：
2
3 public class MyClass
4 {
5 public MyClass()
6 {
7 DisplayValue(); //这里不会阻塞
8 System.Diagnostics.Debug.WriteLine("MyClass() End.");
9 }
10 public Task<double> GetValueAsync(double num1, double num2)
11 {
12 return Task.Run(() =>
13 {
14 for (int i = 0; i < 1000000; i++)
15 {
16 num1 = num1 / num2;
17 }
18 return num1;
19 });
20 }
21 public async void DisplayValue()
22 {
23 double result = await GetValueAsync(1234.5, 1.01);//此处会开新线程处理GetValueAsync任务，然后方法马上返回
24 //这之后的所有代码都会被封装成委托，在GetValueAsync任务完成时调用
25 System.Diagnostics.Debug.WriteLine("Value is : " + result);
26 }
27 }
28
29 上面在MyClass的构造函数里调用了async关键字标记的异步方法DisplayValue()，DisplayValue()方法里执行了一个await关键字标记的异步任务GetValueAsync()，这个异步任务必须是以Task或者Task<TResult>作为返回值的，而我们也看到，异步任务执行完成时实际返回的类型是void或者TResult，DisplayValue()方法里await GetValueAsync()之后的所有代码都会在异步任务完成时才会执行。
30
31 DisplayValue()方法实际执行的代码如下：
32
33 public void DisplayValue()
34 {
35 System.Runtime.CompilerServices.TaskAwaiter<double> awaiter = GetValueAsync(1234.5, 1.01).GetAwaiter();
36 awaiter.OnCompleted(() =>
37 {
38 double result = awaiter.GetResult();
39 System.Diagnostics.Debug.WriteLine("Value is : " + result);
40 });
41 }
42 可以看到，async和await关键字只是把上面的代码变得更简单易懂而已。
43 程序的输出如下：
44
45 MyClass() End.
46
47 Value is : 2.47032822920623E-322
48
49 普通Function执行异步调用：
50
51 public static class TaskAsyncHelper
52 {
53 /// <summary>
54 /// 将一个方法function异步运行，在执行完毕时执行回调callback
55 /// </summary>
56 /// <param name="function">异步方法，该方法没有参数，返回类型必须是void</param>
57 /// <param name="callback">异步方法执行完毕时执行的回调方法，该方法没有参数，返回类型必须是void</param>
58 public static async void RunAsync(Action function, Action callback)
59 {
60 Func<System.Threading.Tasks.Task> taskFunc = () =>
61 {
62 return System.Threading.Tasks.Task.Run(() =>
63 {
64 function();
65 });
66 };
67 await taskFunc();
68 if (callback != null)
69 callback();
70 }
71 /// <summary>
72 /// 将一个方法function异步运行，在执行完毕时执行回调callback
73 /// </summary>
74 /// <typeparam name="TResult">异步方法的返回类型</typeparam>
75 /// <param name="function">异步方法，该方法没有参数，返回类型必须是TResult</param>
76 /// <param name="callback">异步方法执行完毕时执行的回调方法，该方法参数为TResult，返回类型必须是void</param>
77 public static async void RunAsync<TResult>(Func<TResult> function, Action<TResult> callback)
78 {
79 Func<System.Threading.Tasks.Task<TResult>> taskFunc = ()=>
80 {
81 return System.Threading.Tasks.Task.Run(()=>
82 {
83 return function();
84 });
85 };
86 TResult rlt = await taskFunc();
87 if(callback != null)
88 callback(rlt);
89 }
90 }
91 使用很简单，将方法名作为参数传进去就行了.
92
93 例子2：
94
95 /*
96 public Task<int> Write(byte[] data, int len)
97 {
98 return Task.Run(() =>
99 {
100 byte[] ds = new byte[] { 0x58, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 08, 0x4c };
101 if (HwPort.IsOpen) HwPort.Write(ds, 0, ds.Length);
102 return len;
103 });
104 }
105 public async void WriteAsync(byte[] data = null, int len = 0)
106 {
107 int rt = await Write(data, len);
108 Console.WriteLine("async/await: " + rt);
109 }
110 */
111 public async void Write(byte[] data = null, int len = 0)
112 {
113 var rt = await Task.Run(() =>
114 {
115 byte[] ds = new byte[] {0x58, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 08, 0x4c};
116 if (HwPort.IsOpen) HwPort.Write(ds, 0, ds.Length);
117 return len;
118 });
119 Console.WriteLine("async/await completed.[" + rt + "]");
120 }
