【C#】C#线程_I/O限制的异步操作

目录结构：

contents structure [+]

1. 为什么需要异步IO操作
2. C#的异步函数
1. async和await的使用
2. async和Task的区别
3. 异步函数的状态机
1. 异步函数如何转化为状态机
2. 如何扩展异步函数
4. FCL中的异步IO操作
1. FileStream类
5. 异步实现服务器
6. 如何取消异步IO操作

在这篇文章中，笔者将会讨论如何执行异步的IO操作。上面一篇文章，笔者介绍了如何执行异步计算操作。在读完本文后，将异步应用到IO操作中，能够提高读取的效率。

1.为什么需要异步IO操作

关于异步操作，想必读者已知道异步IO操作，笔者在这里展示FileStream类读取本地文件的过程。首先展示FileStream类同步读取IO的流程图。

上面的执行流程中，在第4步Windows将IRP数据包传送给恰当的设备驱动的IRP队列（每个设备驱动程序都维护着自己的IRP队列，其中包含了机器上运行的所有进程发出的I/O请求）。在IRP数据包到达时，设备驱动程序将IRP信息传给物理硬件设备上的安装电路板，然后由硬件驱动设备执行请求的I/O操作，也就是第5个步骤。

当硬件驱动设备执行I/O操作期间，发出了I/O请求的线程将无事可做，所以Windows将线程变成睡眠线程，防止它浪费CPU的时间（步骤6）。这当然好，虽然线程不浪费时间，但其仍然浪费空间（内存），这当然就不好了。

当硬件设备执行完I/0操作。然后Windows会唤醒你的线程，把它调度给一个CPU，使其从内核模式返回至用户模式，然后返回至托管代码（步骤7、8、9）。

上面的步骤看起来很不错，但是依旧存在两个问题：1.请求的数量越来越多，创建的线程就越来越多，那么被阻塞的线程就会越来越多，这样会更浪费内存。2.用执行结果来响应请求，如果请求的数量非常多，那么解锁的阻塞线程也就很多，而且机器上的线程数都会远远大于CPU数，所以在阻塞线程被集中解锁期间CPU很有可能会频繁地发生上下文切换，损害性能。

下面展示Windows如何异步读取I/O流，仍然使用FileStream来构建对象，但是需要传递FileOptions.Asynchronous标志，告诉Windows希望文件的读/写以异步的方式进行。

在使用FileOptions.Asynchronous创建FileStream对象后，就应该使用ReadAsync(...)来读取文件，而不是Read(...)。在ReadAsync内部分配一个Task<Int32>对象来代表用于完成的读取操作的代码。然后ReadAsync调用Win32ReadFile函数（步骤1），ReadFile分配IRP数据包（步骤2），然后将其传递给Windows内核（步骤3）。Windows内核把IRP数据包添加到IRP队列中（步骤4）。此时线程不会再阻塞，而是可以直接运行返回至你的代码。所以线程能够立即从ReadAsync调用中返回（步骤5、6、7）。

在调用ReadAsync后返回一个Task<Int32>对象，可以在该对象上调用ContinueWith来登记任务完成时执行的回调方法，然后在回调方法中处理数据。当硬件设备处理好IRP后（步骤a）。硬件设备会把IRP放到CLR的线程池中队列中（步骤b）。将来某个时候，一个线程池会提取完成的IRP并执行任务的代码，最终要么设置异常（如果发生异常），要么返回结果（步骤c）。在知道这些之后，就知道使用异步I/O可以尽量的减少同步I/O访问存在的那些问题。

2.C#的异步函数

之前的一篇文章中，我们讨论了《计算限制的异步操作》，其中绝大部分代码都是使用Task来完成的。C#还为我们提供了另一种异步糖语法—异步函数，使用异步函数时可以以顺序的步骤写异步的代码，感觉像是在进行同步操作。Task和异步函数的功能类似，但他们之前还是有本质的差别。

2.1 async和await的使用

async和await是C#异步函数编程的核心，async和await是从.NET Framwork 4.5提供的新关键字，被async标记的方法表明该方法应该以异步的方式运行；await操作符用于标记异步函数执行完成后状态机恢复的位置（注意，这里不是等待），同时指示包含该await操作符的方法以异步的方式运行。如果async中不包含await，那么async会以同步的方式运行。
下面展示异步访问网络的步骤：

        static void Main(string[] args)
        {
            Task<int> task= AccessTheWebAsync();
            task.ContinueWith((t) => {
                Console.WriteLine(t.Result);
            });
            Console.ReadLine();
        }
        static async Task<int> AccessTheWebAsync() {
            //需要引入System.Net.Http程序集
            HttpClient httpClient = new HttpClient();

            Task<string> getStringTask = httpClient.GetStringAsync("https://www.baidu.com/");

            // await操作符挂起AccessTheWebAsync方法
            //   AccessTheWebAsync不能够继续执行，直到getStringTask任务完成。
            //   AccessTheWebAsync可以从这里直接异步返回给AccessTheWebAsync的调用者。
            //   当getStringTask任务完成后，状态机可以直接从这里恢复，并且await操作符会返回任务的Result值。
            String urlContents = await getStringTask;

            //返回长度
            return urlContents.Length;
        }

使用async和await有以下几点需要注意：
1.方法名应该以Async结尾（比如：AccessTheWebAsync）。
2.方法应该包含有async修饰符。
3.方法的返回类型应该是Task<TResult>或Task或void或其他类型（从C#7.0，.NET Core开始，其他类型的返回值应该提供GetAwaiter方法）。
4.方法中至少应该包含一个await表达式。

2.2 Async和Task的区别

Async和Task是非常相似的，但是都可以用于异步执行。但是他们之间也是有本质区别的，相信读者看完文章开篇的“为什么需要进行异步I/O操作”的过程已经有所了解了。接下来，笔者想再延伸一下，之所以要使用异步函数来进行异步I/O操作，而不推荐使用Task重新创建一个线程池线程来访问异步I/O操作，就是因为阻塞。

当异步函数的线程遇到阻塞时，并有线程被真正阻塞在哪里，当阻塞被完成后，再从线程池中唤醒一个线程用来执行之后的任务。当线程池遇到阻塞时，那么那个线程是被真正阻塞了的。

例如：

        static async void Test1()
        {
            Console.WriteLine("thread id before await:" + Thread.CurrentThread.ManagedThreadId);

            HttpClient hc = new HttpClient();
            HttpResponseMessage hrm = await hc.GetAsync("http://www.baidu.com");

            Console.WriteLine(hrm.StatusCode);

            Console.WriteLine("thread id after await:" + Thread.CurrentThread.ManagedThreadId);
        }

通过这个异步函数，你一般都会看到await前后是被不同的线程执行的。

        static void Test2(){
            Task task = new Task(() => {
                Console.WriteLine("thread id:" + Thread.CurrentThread.ManagedThreadId);
                //做一些阻塞动作
            });

            task.ContinueWith((tk) => {
                Console.WriteLine("thread id:" + Thread.CurrentThread.ManagedThreadId);
            });

            task.Start();
        }

通过这个，你会看到两个Thread id是相同的。

最后总结一下，

async和Task非常相似，都可以用于执行异步操作。但是异步函数（async）遇到阻塞后，其线程会被回收，用于执行线程池中的其他任务，当阻塞完成后，其会从线程池中唤醒另一个线程（这个线程和之前的线程也有可能是同一个线程，几率很小），用于执行await后面的动作。Task创建的额外线程遇到阻塞时，其创建的线程是会被阻塞的，直到阻塞完成后，线程才能继续执行。

3.异步函数的状态机

3.1 异步函数如何转化为状态机

通常情况下，观察编译器给我们编译好的代码，可以帮助我们更好的理解我们的代码。像async和await操作符，编译器其实是把这些操作符转化成了一种状态机的机制。将含有async和await的代码编译为IL代码，再将IL代码反编译为C#代码，就可以得到状态机。
比如：

    class Type { }

    class Program
    {

        private static async Task<Type> Method1()
        {
            /*执行一些异步操作，最后返回一个Type类型的数据*/
            HttpClient httpClient = new HttpClient();
            String result= await httpClient.GetStringAsync("http://www.baidu.com");

            return new Type();
        }

        private static async Task<String> MyMethodAsync() {

            Type result1 = await Method1();

            return result1.ToString();
        }

        static void Main(string[] args)
        {
        }
    }

编译为IL代码后，再利用ILSPY把IL代码反编译为C#代码,在返编译IL代码的时候，需要注意，不能勾选“decompile async methods(async/await)”

然后就可以看到async和await转化成的状态机

通过查看反编译后的C#代码，C#中的异步函数的运行过程，可以用下图进行简单的概括：

但任务未完成时，isCompleted返回false，所以会在onCompleted登记任务完成时会调用的action动作，action动作执行完成后，会再一次调用MoveNext，然后isCompleted就返回true,此时就可以通过GetResult获得结果。

3.2 如何扩展异步函数

在扩展性方面，能用Task对象包装一个即将完成的操作，就可以使用await操作符来等待该操作。

下面是一个TaskLogger类，可用它显示未完成的异步操作。

    static class TaskLogger {
        public enum TaskLogLevel { None,Pending}
        public static TaskLogLevel LogLevel { get; set; }

        public sealed class TaskLogEntry {
            public Task Task { get; internal set; }
            public String Tag { get; internal set; }
            public DateTime LogTime { get; internal set; }
            public String CallerMemberName { get; internal set; }
            public String CallerFilePath { get; internal set; }
            public Int32 CallerLineNumber { get; internal set; }
            public override string ToString()
            {
                return String.Format("LogTime={0},Tag={1},Member={2},File={3}({4})",
                    LogTime,Tag??"(none)",CallerMemberName,CallerFilePath,CallerLineNumber);
            }
        }

        private static readonly ConcurrentDictionary<Task, TaskLogEntry> s_log = new ConcurrentDictionary<Task, TaskLogEntry>();

        public static IEnumerable<TaskLogEntry> GetLogEntries() { return s_log.Values;}

        public static Task<TResult> Log<TResult>(this Task<TResult> task, String tag = null,
            [CallerMemberName] String callerMemberName=null,
            [CallerFilePath] String callerFilePath=null,
            [CallerLineNumber] Int32 callerLineNumber=-) {

                return (Task<TResult>)Log(task, tag, callerMemberName, callerFilePath, callerLineNumber);
        }

        public static Task Log(this Task task, String tag = null,
           [CallerMemberName] String callerMemberName = null,
           [CallerFilePath] String callerFilePath = null,
           [CallerLineNumber] Int32 callerLineNumber = -) {
               if (LogLevel == TaskLogLevel.None) {
                   return task;
               }
               var logEntry = new TaskLogEntry {
                   Task=task,
                   LogTime=DateTime.Now,
                   Tag=tag,
                   CallerMemberName=callerMemberName,
                   CallerFilePath=callerFilePath,
                   CallerLineNumber=callerLineNumber
            };

               s_log[task] = logEntry;

               //附加一个异步任务，当一个任务执行完成后，应该将其从清单中移除
               task.ContinueWith(t => {
                   TaskLogEntry entry;
                   s_log.TryRemove(t,out entry);
               },TaskContinuationOptions.ExecuteSynchronously);

               return task;
        }
    }

Callation类，用于取消正在执行的异步操作

    static class Cancellation
    {
        public struct Void { }

        public static async Task WithCancellation(this Task originalTask, CancellationToken ct)
        {
            //创建在Cancellation被取消时完成的一个Task
            var cancelTask = new TaskCompletionSource<Void>();

            using (ct.Register(t => ((TaskCompletionSource<Void>)t).TrySetResult(new Void()), cancelTask)) {

                //创建在原始Task或CancellationToken Task完成时都完成的一个Task
                Task any = await Task.WhenAny(originalTask,cancelTask.Task);

                //任务Task因为CancellationToken而完成，就抛出OperationCanceledException
                if (any == cancelTask.Task)
                    ct.ThrowIfCancellationRequested();
            };

            //等待原始任务；若任务失败，它将抛出一个异常
            await originalTask;
        }
    }

最后，展示如何使用

    class Program
    {
        static void Main(string[] args)
        {
            Go();
            Console.ReadLine();
        }
        public static async Task Go() {
#if DEBUG
            //使用TaskLogger会影响内存和性能，所以只在调试生成中启用它
            TaskLogger.LogLevel=TaskLogger.TaskLogLevel.Pending;
#endif
            //初始化3个任务；为了测试TaskLogger，我们显示控制持续时间
            var tasks = new List<Task>{
                Task.Delay().Log("2s op"),
                Task.Delay().Log("5s op"),
                Task<String>.Delay().Log("8s op"),
            };

            try
            {
                //等待全部任务，但在3秒后取消；只有一个任务能够按时完成
                await Task.WhenAll(tasks).WithCancellation(new CancellationTokenSource().Token);
            }
            catch (OperationCanceledException) {
                //查询logger哪些任务尚未完成，按照从等待时间从最长到最短的顺序排序
                foreach (var op in TaskLogger.GetLogEntries().OrderBy(tle => tle.LogTime)) {
                    Console.WriteLine(op);
                }
            }
        }
    }

我的得到如下的输出结果：

LogTime=2018/11/7 1:30:41,Tag=8s op,Member=Go,File=e:\MyLearn\ConsoleApplication1\Program.cs(28)
LogTime=2018/11/7 1:30:41,Tag=5s op,Member=Go,File=e:\MyLearn\ConsoleApplication1\Program.cs(27)

除了增强使用Task的灵活性，异步函数对另一个扩展性有力的地方在于编译器可以在await的任何操作数上调用GetAwaiter。所以操作数不一定是Task对象。可以是任何任意类型，只要提供一个调用GetAwaiter的方法就可以了。
例如：

    public sealed class EventAwaiter<TEventArgs> : INotifyCompletion {
        private ConcurrentQueue<TEventArgs> m_events = new ConcurrentQueue<TEventArgs>();

        private Action m_continuation;

        //状态机调用GetAwaiter获得Awaiter,这里返回自己
        public EventAwaiter<TEventArgs> GetAwaiter() { return this; }

        //告诉状态机是否发生了任何事件
        public Boolean IsCompleted { get { return m_events.Count > ; } }

        //状态机告诉我们以后要调用什么方法，continuation中包含有恢复状态机的操作
        public void OnCompleted(Action continuation) {
            Volatile.Write(ref m_continuation,continuation);
        }

        //状态机查询结果，这是awaiter操作符的结果
        public TEventArgs GetResult() {
            TEventArgs e;
            m_events.TryDequeue(out e);
            return e;
        }

        public void EventRaised(Object sender, TEventArgs eventArgs) {
            m_events.Enqueue(eventArgs);

            //如果有一个等待运行的延续任务，该线程会运行它
            Action continuation = Interlocked.Exchange(ref m_continuation, null);
            if (continuation != null) {
                continuation();//恢复状态机
            }
        }
    }

在EventAwaiter类在事件发生的时候从await操作符返回。在本例中，一旦AppDomain中的任何线程抛出异常，状态机就会继续。

        private static async void ShowException() {
            var eventAwaiter = new EventAwaiter<FirstChanceExceptionEventArgs>();
            AppDomain.CurrentDomain.FirstChanceException += eventAwaiter.EventRaised;

            while (true) {
                Console.WriteLine((await eventAwaiter).Exception.GetType());
            }
        }

笔者自定义的EventAwaiter<TEventArgs>提供了GetAwaiter()、isCompleted()、onCompleted(Action continuation)、GetResult()几个重要的方法，其实这几个方法恰好对应了第3.1中“异步函数如何转化为状态机”中状态机需要操作的各个方法，在3.1中笔者给出一张状态机执行的流程图，这里就不再贴那张图片了。

笔者接下来结合这个案例，说一说本例的流程：

a.当执行到await eventAwaiter时，会去调用eventAwaiter的GetAwaiter()方法，然后得到Awaiter对象。

b.查询Awaiter对象和IsCompleted()方法，判断当前Awaiter是否发生了事件。

c.若Awaiter还没有发生事件，就调用OnCompleted(Action)方法，并且传递一个Action委托给OnCompleted()方法，其中的Action委托里就包含了恢复状态机的逻辑。

d.此时还没有线程执行恢复状态机的代码，await eventWaiter 的线程将会被阻塞。

e.当结合本例的程序逻辑，当出现异常时EventRaised会被调用，然后在EventRaised中会恢复状态机，唤醒await eventWaiter阻塞的线程。

f.状态机然后会再次调用IsCompleted方法判断是否有事件，这时m_events 已经有一个事件了，所以IsCompleted会返回true。

g.状态机接着调用GetResult，并且将结果值赋值给await关键字的表达式。

最后演示这一切是如何工作的：

       static void Main(string[] args)
        {
            ShowException();

            for (int i = ; i < ; i++) {
                try
                {
                    switch (i) {
                        case : throw new InvalidCastException();
                        case : throw new InvalidOperationException();
                        case : throw new ArgumentException();
                    }
                }
                catch (Exception) {
                }
            }
            Console.ReadLine();
        }

4.FCL中的异步IO操作

FCL中的异步函数非常容易辨认，因为命名规范要求异步函数必须加上Async的后缀。在FCL中，支持I/O操作的许多类型都提供了XxxAsync方法
例如：
a.System.IO.Stream的所有派生类都提供了ReadAsync，WriteAsync，FlushAsync和CopyToAsync方法
b.System.IO.TextReader的所有派生类都提供了ReadAsync，ReadLineAsync，ReadToEndAsync和ReadBlockAsync方法。System.IO.TextWriter的派生类提供了WriteAsync,WriteLineAsync和FlushAsync.
c.System.Net.Http.HttpClient 类提供了GetAsync,GetStreamAsync,GetByteArrayAsync,PostAsync,PutAsync,DeleteAsync和其他许多方法。
d.System.Net.WebRequest的所派生类(包括FileWebRequest,FtpWebRequest和HttpWebRequest)都提供了GetRequestStreamAsync和GetResponseAsync方法。
e.System.Data.SqlClient.SqlCommand类提供了ExecuteDbDataReaderAsync,ExecuteNonQueryAsync,ExecuteReaderAsync,ExecuteScalarAsync和ExecuteXmlReaderAsync方法。
f.生成Web服务代理工具（比如SvcUtil.exe）也生成了XxxAsync方法。

这里笔者以System.Net.Http.HttpClient来举例：

        static async void Go() {
            HttpClient httpClient = new HttpClient();
            Stream stm = await httpClient.GetStreamAsync("http://www.baidu.com");

            StreamReader sr = new StreamReader(stm);
            String line= "";
            while ((line = await sr.ReadLineAsync()) != null) {
                Console.WriteLine(line);
            }
        }

FCL中有许多编程都使用了BeginXxx/EndXxx方法模型和IAsyncResult接口，还有基于事件的编程模型，它也提供了XxxAsync方法（不返回Task对象），能在异步操作完成时调用事件处理程序。这两种编程模型都已经过时，使用Task的新模型才是你的首要选择。

在FCL中，有一些类缺少XxxAsync方法，只提供了BeginXxx和EndXxx方法。可以通过TaskFactory将其转化为基于Task的模型。
BeginExecuteXXX 和EndExecuteXXX 使用TaskFactory来转化的步骤，例如：
返回值= Task.Factory.FromAsync(BeginEexcuteXXX,EndExecuteXXX,...);
返回值是EndExecute的返回值。

例如：NamedPipeServerStream类定义了BeginWaitForConnection和EndWaitForConnection，但是没有定义WaitForConnectionAsync方法，可以按照如下代码来完成转化。

        static async void StartServer() {
            while (true) { //循环不停的接受来自客户端的链接
                var pipe = new NamedPipeServerStream(c_pipeName,PipeDirection.InOut,-,PipeTransmissionMode.Message,PipeOptions.Asynchronous|PipeOptions.WriteThrough);

                //异步的接受来自客户端的连接
                //用TaskFactory的FromAsync将旧的异步编程模型转化为新的Task模型
                //当没有客户端连接时，线程将会挂起，并且允许方法已异步的方式返回调用者（本例中未有返回）
                //当有客户端连接后，立即唤醒状态机，线程继续执行。
                await Task.Factory.FromAsync(pipe.BeginWaitForConnection,pipe.EndWaitForConnection,null);

                //为客户端提供服务
                //startServiceConnectionAsync 也是异步方法，所以能够立即返回
                startServiceConnectionAsync(pipe);
            }
        }

FCL没有提供任何的辅助方法将旧的、基于事件的编程模型转化为新的、基于Task的编程模型。所有只能使用硬编码的方式。例如下面演示了使用TaskCompletionSource包装使用了“基于事件的编程模型”的WebClient,以便在异步函数中等待它。

        static async Task<String> AwaitWebClient(Uri uri) {
            //System.Net.WebClient
            var wc = new System.Net.WebClient();

            //创建TaskCompletionSource及其基础Task对象
            var tcs = new TaskCompletionSource<String>();

            //字符串下载完成后，WebClient对象引发DownloadStringCompleted事件
            wc.DownloadStringCompleted += (s, e) => {
                if (e.Cancelled) tcs.SetCanceled();
                else if (e.Error != null) tcs.SetException(e.Error);
                else tcs.SetResult(e.Result);
            };

            //启动异步操作
            wc.DownloadStringAsync(uri);

            //现在可以等待TaskCompletion
            String result = await tcs.Task;

            return result;
        }

4.1 FileStream类

创建FileStream对象时，可通过FileOptions.AsyncChronous标志指定以同步方式还是异步方式进行通信。如果不指定该标志，Windows将以同步方式执行所有文件操作。当然，仍然可以调用FileStream的ReadAsync方法，对于你的应用程序，表面上是异步执行，但FileStream类在内部用另一个线程模拟异步行为。这个额外的线程纯属是浪费。

如果创建FileStream对象时指定FileOptions.AsyncChronous标志。然后，可以调用FileStream的Read方法执行一个同步操作。在内部，FileStream类会开始一个异步操作，然后立即调用线程进入睡眠状态，直到操作完成才唤醒，从而模拟同步行为，这样依然效率低下。

总之，使用FileStream时应该想好是以同步方式还是以异步方式执行I/O操作，并指定FileOptions.Asynchronous标志来指明自己的选择。如果指定了该标志，就总是调用ReadAsync。如果没有使用这个标志，就总是调用Read。这样能够获得最佳性能。如果想先对FileStream执行一些同步操作，再执行一些异步操作，那么更高效的做法是使用FileOptions.Asynchronous标志来构造它。另外也可针对同一个文件，创建两个FileStream对象，一个FileStream进行同步操作，另一个FileStream执行异步操作。

FileStream的辅助方法（Create,Open和OpenWrite）创建并返回FileStream对象，这些方法都没有指定FileOptions.Asynchronous标志，所以为了实现响应灵敏的、可伸缩性的应用程序，应避免使用这些方法。

5.异步实现服务器

FCL内建了对伸缩性很好的一些异步服务器的支持。下面列举中MSDN文档中值的参考的地方。
1.要构建异步ASP.NET Web窗体，在.aspx文件中添加Async="true"的网页指令，并参考System.Web.UI.Page的RegisterAsyncTask方法。
2.要构建异步ASP.NET MVC控制器，使你的控制器类从System.Web.Mvc.AsyncController派生，让操作方法返回一个Task<ActionResult>即可。
3.要构建异步ASP.NET 处理程序，使你的类从System.Web.HttpTaskAsyncHandler派生，重写其ProcessRequestAsync方法。
4.要构建异步WCF服务，将服务作为异步函数来实现，让它返回Task或Task<TResult>。

这里笔者讲解一下如何构建异步的ASP.NET MVC控制器，如果是.NET 4.5（支持await和async关键词）以上以及4.5的版本，那么构建异步ASP.NET非常方便，例如：

public class TestController extends AsyncController{
  public async Task<ActionResult> Get() {
    Task<TResult> task = ...;
    return await task;
  }
}

上面的模型方法不会阻塞任何线程。在.NET 4.5 以下的话，并不支持async和await，我们仍然可以通过AsyncController来实现不阻塞任何线程的异步服务器响应：

    public class TestController : AsyncController
    {
        //开始异步会调用该方法
        public void getAsync() {
            //声明异步操作
            AsyncManager.OutstandingOperations.Increment();
            Task.Factory.StartNew(() => {//开始异步操作
                //在这里可以进行耗时的操作，并不会有线程等待
                //将结果赋值给AsyncManager.Parameters
                AsyncManager.Parameters["response"] = "abc";
                //异步结束
                AsyncManager.OutstandingOperations.Decrement();
            });
        }
        //异步结束时，会调用该方法
        //参数必需和AsyncManager.Parameters赋值key一样
        public ActionResult getCompleted(String response)
        {
            return Content(response.ToString(), "text/json");
        }
    }

上面虽然声明了两个控制器方法getAsync和getCompleted，但实际上只有get，访问也只能通过get。

在使用AsyncManager进行数据传递的时候，AsyncManager是和控制器相关联的，也就是说如果有Simple控制器和Test控制器，那么Simple控制器中的AsyncManager是不能干扰Test控制器中的AsyncManager的数的。

更详细的内容，可以看这篇文章：https://msdn.microsoft.com/cs-cz/library/ee728598(v=vs.100).aspx

6.如何取消异步IO操作

Windows一般没有提供取消未完成I/O操作的途径，这是许多开发人员都想要的功能，实现起来却很困难。毕竟，如果向服务器请求了1000个字节，然后决定不再需要这些字节，那么其实没有办法告诉服务器忘掉你的请求。在这种情况下，只能让字节照常返回，再将他们丢弃。此外，这里还发生竞态条件-取消请求的请求可能正在服务器发送响应的时候到来，要在代码中处理这种潜在的竞态条件，决定是丢弃还是使用数据。

建议实现一个WithCancellation扩展方法Task<TResult>(需要重载版本来扩展Task)上面的案例中，我们已经使用过Task的扩展版本了，下面是Task<TResult>版本：

static class CancelleationClass {
private struct Void { }//没有泛型的TaskCompletionSource类

public static async Task<TResult> WithCancellation<TResult>(this Task<TResult> originalTask, CancellationToken ct)
{
    //创建在CancellationToken被取消时完成的一个Task
    var cancelTask = new TaskCompletionSource<Void>();

    //一旦CancellationToken被取消，就完成Task
    CancellationTokenRegistration cancellationTokenRegistration = ct.Register(t =>
    {
        ((TaskCompletionSource<Void>)t).TrySetResult(new Void());
    }, cancelTask);

    //创建在原始task或cancel task完成时都完成的Task
    Task any = await Task.WhenAny(originalTask, cancelTask.Task);

    //只要是cancel task先完成，就抛出OperationCanceledException
    if (any == cancelTask.Task)
    {
        ct.ThrowIfCancellationRequested();
    }

    //释放资源
    cancellationTokenRegistration.Dispose();

    //返回原始任务
    return originalTask.Result;
}
}

按照如下的代码来使用它：

public static async Task<Int32> go() {
    var cts = new CancellationTokenSource();
    var ct = cts.Token;

    try
    {
        Int32 max = ;
        Task<Int32> task = new Task<Int32>(() => {
            Int32 result = ;
            for (int i = ; i < max; i++) {
                result += i;
                Thread.Sleep();
            }
            return result;
        });
        task.Start();

        //在指定的时间后取消操作
        Task.Delay().ContinueWith((obj) =>
        {
            cts.Cancel();
        });

        Int32 res=await task.WithCancellation<Int32>(ct);

        return res;
    }
    catch (OperationCanceledException e) {
        Console.WriteLine(e.Message);
    }
    return -;
}