[.NET] 利用 async & await 进行异步 IO 操作

利用 async & await 进行异步 IO 操作

【博主】反骨仔　　【出处】http://www.cnblogs.com/liqingwen/p/6082673.html 　　

序　　

　　上次，博主通过《利用 async & await 的异步编程》这篇点睛之作初步介绍了 async & await 的基本用法及异步的控制流和一些其它的东西；　　

　　接着，博主通过《怎样使用 async & await 一步步将同步代码转换为异步编程》这篇随笔诱导大家如何一步步转换自己的同步代码；

　　今天，我们来一起看看如何用异步进行 IO 操作。

目录

• 使用异步特性实现 IO 操作的意义
• 使用带异步的 FileStream 类
• 异步写入文本
• 异步读取文本
• 并行异步 I/O

使用异步特性实现 IO 操作的意义

• 异步特性有利于增强 App 的响应能力。因为一个操作的 UI 线程可以执行其他工作。如果 UI 线程需要执行较长时间的代码(如 > 1s)，UI 会阻塞到 I/O 完成，这时用户界面线程才可以重新处理键盘、鼠标输入和其他操作。

• 在本地进行文件访问也许效率非常高，但是，假如该文件在远程的服务器上呢？
  

• 使用异步额外增加的开销很小，不大。

• 异步任务可以并行运行。

使用带异步的 FileStream 类

　　这里使用 FileStream 类，它带有一个参数 useAsync，可以避免在许多情况下阻塞线程池的线程。可以通过 useAsync = true 来进行启用或在构造函数中进行参数调用。

　　但是我们不能对 StreamReader 和 StreamWriter 中的参数进行设置。但是，如果你想使用该参数 useAsync，则需要自己新建一个 FileStream 对象。请注意，异步调用是在 UI 中的，即使线程池线程阻塞，在 await 期间，用户界面线程也不会被阻塞。

异步写入文本

　　下面的示例是将文本写入到文件。在每个 await 语句中，都会立即退出。当文件 I/O 完成时，方法会执行 await 语句后面的语句。请注意异步修饰符在使用 await 语句方法的定义。

        private async void btnWrite_Click(object sender, RoutedEventArgs e)
        {
            await WriteTextAsync();
        }

        /// <summary>
        /// 异步写入文件
        /// </summary>
        /// <returns></returns>
        private async Task WriteTextAsync()
        {
            var path = $"temp.txt";
            var content = Guid.NewGuid().ToString();

            using (var fs = new FileStream(path,
                FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, bufferSize: 4096, useAsync: true))
            {
                var buffer = Encoding.UTF8.GetBytes(content);

                //var writeTask = fs.WriteAsync(buffer, 0, buffer.Length);
                //await writeTask;
                await fs.WriteAsync(buffer, 0, buffer.Length);
            }
        }

　　行号 17 的语句可以修改为：

  //await fs.WriteAsync(buffer, 0, buffer.Length);
  //可以改为
  var writeTask = fs.WriteAsync(buffer, 0, buffer.Length);
  await writeTask;

　　第一个语句（行号 1）返回任务并导致进程的文件。使用等待的第二个语句（行号3、4）导致方法立即退出并返回其他任务。当随后处理的文件完成时，执行回 await 的语句。 

异步读取文本

　　下面的示例是从文件中读取文本。将文本缓冲区的内容放入 StringBuilder。不同于在前面的示例，会不断 await 一个读取的长度值。ReadAsync 方法返回 Task<Int32>，即 Task<int>，因此，等待的计算生成一个 Int32 值(numRead)，在操作完成之后。

        /// <summary>
        /// 异步读取文本
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        private async Task<string> ReadTextAsync(string fileName)
        {
            using (var fs = new FileStream(fileName,
                FileMode.OpenOrCreate, FileAccess.Read, FileShare.None, bufferSize: 4096, useAsync: true))
            {
                var sb = new StringBuilder();
                var buffer = new byte[0x1000];  //十六进制 等于十进制的 4096
                var readLength = 0;

                while ((readLength = await fs.ReadAsync(buffer, 0, buffer.Length)) != 0)
                {
                    var text = Encoding.UTF8.GetString(buffer, 0, readLength);
                    sb.Append(text);
                }

                return sb.ToString();
            }
        }

        private async void btnRead_Click(object sender, RoutedEventArgs e)
        {
            var fileName = $"temp.txt";
            if (!File.Exists(fileName))
            {
                Debug.WriteLine($"文件找不到：{fileName}");
                return;
            }

            try
            {
                var content = await ReadTextAsync(fileName);
                Debug.WriteLine(content);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
        }

并行异步 I/O

　　下面的示例通过编写多个文本文件进行演示并行处理。对于每个文件，WriteAsync 方法返回后将被添加到任务列表的集合中。在处理完成所有的任务时，await Task.WhenAll(tasks); 语句将退出方法并恢复执行。

　　在任务完成后，进入 finally 块的将所有 FileStream 实例进行清理回收。如果直接在 using 语句中创建 FileStream 实例，则 FileStream 实例可能在任务完成之前就被处理。

　　【注意】所有性能提高几乎完全是异步并行处理。异步的优点是它不会占用多个线程，也就是说，它不会占用用户界面线程。

        /// <summary>
        /// 异步写入多个文件
        /// </summary>
        /// <param name="folder"></param>
        /// <returns></returns>
        private async Task WriteMultiTextAsync(string folder)
        {
            var tasks = new List<Task>();
            var fileStreams = new List<FileStream>();

            try
            {
                for (int i = 1; i <= 10; i++)
                {
                    var fileName = Path.Combine(folder, $"{i}.txt");
                    var content = Guid.NewGuid().ToString();
                    var buffer = Encoding.UTF8.GetBytes(content);

                    var fs = new FileStream(fileName,
        FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, bufferSize: 4096, useAsync: true);
                    fileStreams.Add(fs);

                    var writeTask = fs.WriteAsync(buffer, 0, buffer.Length);
                    tasks.Add(writeTask);
                }

                await Task.WhenAll(tasks);
            }
            finally
            {
                foreach (var fs in fileStreams)
                {
                    fs.Close();
                    fs.Dispose();
                }
            }
        }

        private async void btnWriteMulti_Click(object sender, RoutedEventArgs e)
        {
            var folder = $"temp";

            if (!Directory.Exists(folder))
            {
                Directory.CreateDirectory(folder);
            }

            await WriteMultiTextAsync(folder);
        }

　　在使用 WriteAsync 和 ReadAsync 方案时，你可以指定 CancellationToken，来在中途取消操作。 

同系列的随笔

• 利用 async & await 的异步编程

• 怎样使用 async & await 一步步将同步代码转换为异步编程

• 走进异步编程的世界 - 开始接触 async/await

• 走进异步编程的世界 - 剖析异步方法（上）

• 走进异步编程的世界 - 剖析异步方法（下）

• 走进异步编程的世界 - 在 GUI 中执行异步操作

---

 【参考】https://docs.microsoft.com/en-us/dotnet/articles/csharp/programming-guide/concepts/async/using-async-for-file-access