异步编程

采用异步编程的理由：
1.避免后台任务阻塞UI线程
2.避免CPU浪费时间等待I/操作O
3.需要所有处理器为我所用
由于切管线程的操作比较麻烦，如果只是执行短的任务，可能调度多个线程的开销，超过实际的代码开销。
为了避免频繁创建线程而产生开销，每个托管进程维护一个线程池。
为了避免切换线程而产生开销，因为建议使用任务
task内部使用了线程池，且在把线程归还线程池之前，关于在同一个线程中顺序执行多个Task
可以通过对多个委托对象的只能调度来实现，有效的避免了时间片浪费问题（小任务导致上下文频繁切换）
TPL task parallel library
Task.start()
Task.contonueWith()

在非IO阻塞中使用Task

   string filename = "D:\\temp.txt";
    int chuncSize = 4096;
    var buf = new byte[chuncSize];
    //IsAsync属性检测文件句柄是否以异步打开， 当属性为时 true ，流将使用重叠的 i/o 以异步方式执行文件操作。
    // 当 IsAsync 属性为false 并且您调用异步读写操作时，UI 线程仍不会被阻止，但实际的 i/o 操作将以同步方式执行。
    var fileStream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read, chuncSize, useAsync: true);
    var task = fileStream.ReadAsync(buf, 0, buf.Length);
    task.ContinueWith((readTask) =>
    {
        int amoutRead = readTask.Result;
        fileStream.Dispose();
        Console.WriteLine($"async read {amoutRead}");
        Console.WriteLine(System.Text.Encoding.ASCII.GetString(buf));
    });
    fileStream.Dispose();

在真实的场合中，往往需要在流中读取多次草能获得全部数据 比如说文件大于给定的缓冲区的大小，或者需要处理网络流中的数据，我们需要从流中连续获取数据知道没有数据可读
因此需要两个task，外层task用来读取所有数据，内部task用来每次获取

   private static Task<int> AsyncRead(string fileName)
    {
        int chuckSize = 20;
        var buf = new byte[chuckSize];
        //生成伪task
        var tcs = new TaskCompletionSource<int>();

        var fileContents = new MemoryStream();
        var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, chuckSize,true);
        fileContents.Capacity += chuckSize;
       
        var task = fileStream.ReadAsync(buf, 0, buf.Length);
        task.ContinueWith((readTask) => {
            ContinueRead(readTask, fileStream, fileContents, buf, tcs);
        });
        //tcs.setReault会让阻塞继续执行
        return tcs.Task;
    }

    private static void ContinueRead(Task<int> readTask, FileStream fileStream, MemoryStream fileContents,
        byte[] buf, TaskCompletionSource<int> tcs)
    {
        if (readTask.IsCompleted)
        {
            int readByte = readTask.Result;
           
            if (readByte > 0)
            {
                fileContents.Write(buf, 0, readByte);
                var newTask = fileStream.ReadAsync(buf, 0, buf.Length);
                newTask.ContinueWith((task) => { ContinueRead(task, fileStream, fileContents, buf, tcs); });
            }
            else
            {
               //获取完毕，数据处理。释放资源
                tcs.TrySetResult((int)fileContents.Length);
                fileStream.Dispose();
                Console.WriteLine($"BackAsync:{System.Text.Encoding.ASCII.GetString(fileContents.GetBuffer())}");
                fileContents.Dispose();
            }

        }
    }

Async 和Await
在标记为async的方法的内部，await可以等待Task<T>
在await之前的操作位于调用者线程
在await之后的操作实在ContinuationTask中运行
所有的await的都必须位于编辑为async的方法中，如果从不等待的逻辑来说，所有的
后台线程都可以使用continuation Task来运行
经典用法：
后台耗时程序刷新UI:

private void Button_Click(object sender, RoutedEventArgs e)
{
    Task.Run(()=> {
        string str = MyTextShow();
        this.Dispatcher.Invoke(() => { this.txtShow.Text = str; });
    });
}

private string MyTextShow()
{
    Thread.Sleep(2000);
    return "Hello Wrold";
}

private async void Button_Click_1(object sender, RoutedEventArgs e)
{
    this.txtShow.Text = await Task.Run(MyTextShow);
}

await之前，以阻塞的形式进行，遇到await关键字时，调用线程将挂起，知道返回task,提取task中的值