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