发现自己有点懒了！也可能是越往后越难了，看书理解起来有点费劲，所以这两天就每天更新一点学习笔记吧。
4.5 将APM模式转化为任务
书上提供的三种方式
方式一：
1 class Program
2 {
3 //定义一个委托
4 private delegate string AsynchronousTask(string threadName);
5
6 static void Main(string[] args)
7 {
8 //实例化一个委托对象，绑定Test函数
9 AsynchronousTask d = Test;
10
11 Console.WriteLine("Option 1");
12 //调用TaskFactory<TResult> Factory.FromAsync()方法，这个方法有很多重载函数
13 //这个方法是 public Task<TResult> FromAsync(IAsyncResult asyncResult, Func<IAsyncResult, TResult> endMethod);
14 Task<string> task = Task<string>.Factory.FromAsync(
15 d.BeginInvoke("AsyncTaskThread", Callback, "a delegate asynchronous call"), d.EndInvoke);
16 //绑定任务执行完的后续操作
17 task.ContinueWith(t => Console.WriteLine("Callback is finished, now running a continuation! Result: {0}",
18 t.Result));
19
20 //循环打印状态信息
21 while (!task.IsCompleted)
22 {
23 Console.WriteLine(task.Status);
24 Thread.Sleep(TimeSpan.FromSeconds(0.5));
25 }
26 Console.WriteLine(task.Status);
27 Thread.Sleep(TimeSpan.FromSeconds(1));
28
29 Console.WriteLine("----------------------------------------------");
30 Console.WriteLine();
31 }
32
33 //定义一个回调函数
34 private static void Callback(IAsyncResult ar)
35 {
36 Console.WriteLine("Starting a callback...");
37 Console.WriteLine("State passed to a callbak: {0}", ar.AsyncState);
38 Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
39 Console.WriteLine("Thread pool worker thread id: {0}", Thread.CurrentThread.ManagedThreadId);
40 }
41
42 //定义一个委托函数
43 private static string Test(string threadName)
44 {
45 Console.WriteLine("Starting...");
46 Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
47 Thread.Sleep(TimeSpan.FromSeconds(2));
48 Thread.CurrentThread.Name = threadName;
49 return string.Format("Thread name: {0}", Thread.CurrentThread.Name);
50 }
方式二：
与方式一差不多，但是使用了TaskFactory<TResult> Factory.FromAsync()方法的另一种重载，该重载并不允许指定一个将会在异步委托调用后被调用的回调函数。但是可以使用后续操作替代它。如果回调函数非常重要，建议使用第一种。
1 class Program
2 {
3 //定义一个委托
4 private delegate string AsynchronousTask(string threadName);
5
6 static void Main(string[] args)
7 {
8 //实例化一个委托对象，绑定Test函数
9 AsynchronousTask d = Test;
10
11 Console.WriteLine("Option 2");
12 //调用TaskFactory<TResult> Factory.FromAsync()方法，这个方法有很多重载函数
13 /*
14 * 这个方法重载是
15 * public Task<TResult> FromAsync<TArg1>(Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod,
16 * Func<IAsyncResult, TResult> endMethod,
17 * TArg1 arg1,
18 * object state);
19 */
20 Task<string> task= Task<string>.Factory.FromAsync(d.BeginInvoke,d.EndInvoke,
21 "AsyncTaskThread",
22 "a delegate asynchronous call");
23
24 //绑定任务执行完的后续操作
25 task.ContinueWith(t => Console.WriteLine("Task is completed, now running a continuation! Result: {0}",
26 t.Result));
27
28 //循环打印状态信息
29 while (!task.IsCompleted)
30 {
31 Console.WriteLine(task.Status);
32 Thread.Sleep(TimeSpan.FromSeconds(0.5));
33 }
34 Console.WriteLine(task.Status);
35 Thread.Sleep(TimeSpan.FromSeconds(1));
36
37 Console.WriteLine("----------------------------------------------");
38 Console.WriteLine();
39 }
40
41 //定义一个委托函数
42 private static string Test(string threadName)
43 {
44 Console.WriteLine("Starting...");
45 Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
46 Thread.Sleep(TimeSpan.FromSeconds(2));
47 Thread.CurrentThread.Name = threadName;
48 return string.Format("Thread name: {0}", Thread.CurrentThread.Name);
49 }
方式三：
1 class Program
2 {
3 private delegate string IncompatibleAsynchronousTask(out int threadId);
4
5 static void Main(string[] args)
6 {
7 int threadId;
8 IncompatibleAsynchronousTask e = Test;
9
10 Console.WriteLine("Option 3");
11
12 IAsyncResult ar = e.BeginInvoke(out threadId, Callback, "a delegate asynchronous call");
13
14 /*这是一个小技巧，EndMethod使用了out参数，与FromAsync的方法重载并不兼容。
15 * 然而，可以很轻松地将EndMethod调用封装到一个lambda表达式当中，从而适合
16 * 工厂方法。
17 */
18 Task<string> task = Task<string>.Factory.FromAsync(ar, _ => e.EndInvoke(out threadId, ar));
19 task.ContinueWith(t =>
20 Console.WriteLine("Task is completed, now running a continuation! Result: {0}, ThreadId: {1}",
21 t.Result, threadId));
22
23 while (!task.IsCompleted)
24 {
25 Console.WriteLine(task.Status);
26 Thread.Sleep(TimeSpan.FromSeconds(0.5));
27 }
28 Console.WriteLine(task.Status);
29
30 Thread.Sleep(TimeSpan.FromSeconds(1));
31 }
32
33 private static void Callback(IAsyncResult ar)
34 {
35 Console.WriteLine("Starting a callback...");
36 Console.WriteLine("State passed to a callbak: {0}", ar.AsyncState);
37 Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
38 Console.WriteLine("Thread pool worker thread id: {0}", Thread.CurrentThread.ManagedThreadId);
39 }
40
41 private static string Test(out int threadId)
42 {
43 Console.WriteLine("Starting...");
44 Console.WriteLine("Is thread pool thread: {0}", Thread.CurrentThread.IsThreadPoolThread);
45 Thread.Sleep(TimeSpan.FromSeconds(2));
46 threadId = Thread.CurrentThread.ManagedThreadId;
47 return string.Format("Thread pool worker thread id was: {0}", threadId);
48 }
49
总结：感觉这个在日常工作当中使用的真的不是很多，比较晦涩难懂，暂且记住有TaskFactory<TResult> Factory.FromAsync()这个方法，通过这个方法可以将APM转化成TPL
4.6 将EAP模式转换成任务
例子先上：
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 //实例化一个TaskCompletionSource<TResult>，它是实现EAP转化成TPL的关键
6 var tcs = new TaskCompletionSource<int>();
7
8 var worker = new BackgroundWorker();
9 worker.DoWork += (sender, eventArgs) =>
10 {
11 eventArgs.Result = TaskMethod("Background worker", 5);
12 };
13
14 worker.RunWorkerCompleted += (sender, eventArgs) =>
15 {
16 //如果有错就抛出异常
17 if (eventArgs.Error != null)
18 {
19 tcs.SetException(eventArgs.Error);
20 }
21 //如果是取消操作，就取消操作
22 else if (eventArgs.Cancelled)
23 {
24 tcs.SetCanceled();
25 }
26 else
27 {
28 //正常情况返回结果
29 tcs.SetResult((int)eventArgs.Result);
30 }
31 };
32
33 //运行任务
34 worker.RunWorkerAsync();
35
36 //获取结果
37 int result = tcs.Task.Result;
38
39 Console.WriteLine("Result is: {0}", result);
40 }
41
42 static int TaskMethod(string name, int seconds)
43 {
44 Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
45 name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
46 Thread.Sleep(TimeSpan.FromSeconds(seconds));
47 return 42 * seconds;
48 }
4.7 实现取消选项
我们在前面说过线程工作的取消需要依靠两个类来实现，分别是CancellationTokenSource和CancellationToken这两个类
1 class Program
2 {
3 private static void Main(string[] args)
4 {
5 //定义一个CancellationTokenSource类
6 var cts = new CancellationTokenSource();
7 //创建第一个任务，这里有个很奇怪的第地方，cts.Token被传了两次
8 //分别传给了TaskMethod方法个Task的构造函数，为什么这么做呢？
9 var longTask = new Task<int>(() => TaskMethod("Task 1", 10, cts.Token), cts.Token);
10 //打印任务状态
11 Console.WriteLine(longTask.Status);
12 //取消任务
13 cts.Cancel();
14 //再次打印任务状态
15 Console.WriteLine(longTask.Status);
16 Console.WriteLine("First task has been cancelled before execution");
17
18 //创建第二个任务
19 cts = new CancellationTokenSource();
20 longTask = new Task<int>(() => TaskMethod("Task 2", 10, cts.Token), cts.Token);
21 //启动任务
22 longTask.Start();
23 for (int i = 0; i < 5; i++ )
24 {
25 Thread.Sleep(TimeSpan.FromSeconds(0.5));
26 Console.WriteLine(longTask.Status);
27 }
28 //取消任务
29 cts.Cancel();
30 //打印任务状态
31 for (int i = 0; i < 5; i++)
32 {
33 Thread.Sleep(TimeSpan.FromSeconds(0.5));
34 Console.WriteLine(longTask.Status);
35 }
36
37 Console.WriteLine("A task has been completed with result {0}.", longTask.Result);
38 }
39
40 private static int TaskMethod(string name, int seconds, CancellationToken token)
41 {
42 Console.WriteLine("Task {0} is running on a thread id {1}. Is thread pool thread: {2}",
43 name, Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
44 for (int i = 0; i < seconds; i ++)
45 {
46 Thread.Sleep(TimeSpan.FromSeconds(1));
47 //如果任务被取消，就返回-1
48 if (token.IsCancellationRequested) return -1;
49 }
50 return 42*seconds;
51 }
52 }
cts.Token被传了两次为什么呢？如果在任务实际启动前取消它，该任务的TPL基础设施有责任处理该取消操作，因为这些代码根本不会被执行，通过得到第一个任务的状态可以知道它被取消了。如果尝试对该任务调用Start方法，将会得到InvalidOperationException异常。
解释：
如果在Task构造函数当中取消了，cts.Token这个参数，那么在Cts.Cancel()后面执行longTask.Start(); 会出现什么情况呢？
如下图所示，任务只有在运行操作的时候才能检查到取消操作。所以才会有WaitingToRun这个状态出现。
如果添加了这个参数，结果如下：
这个时候，在取消操作执行完后，执行开始操作就会抛出异常。
时间： 2024-12-16 07:08:22