异步函数Demo

         private static async Task<String> IssueClientRequestAsync(string serverName, string message)
         {
             Console.WriteLine("进入IssueClientRequestAsync");
             //NamedPipeClientStream 公开 System.IO.Stream 周围命名管道，支持同步和异步读取和写入操作。
             //新实例初始化 System.IO.Pipes.NamedPipeClientStream 使用指定的管道和服务器名称，以及指定的管道方向和管道选项的类。
             // 参数:
             //   serverName:
             //     要连接的远程计算机的名称，或者为“.”，以指定本地计算机。
             //
             //   pipeName:
             //     管道的名称。
             //
             //   direction:
             //     确定管道方向的枚举值之一。（此处指定的管道方向是双向的）
             //
             //   options:
             //     确定如何打开或创建管道的枚举值之一。
             using (var pipe = new NamedPipeClientStream(serverName, "PipeName", PipeDirection.InOut, PipeOptions.Asynchronous | PipeOptions.WriteThrough))
             {
                 Console.WriteLine("Connect");
                 //连接到具有无限超时值的等待的服务器。
                 //必须在设置ReadMode之前连接
                 pipe.Connect();

                 Console.WriteLine("ReadMode");
                 //对象的读取模式
                 //指示是发送和读取的 消息流 的形式在管道中的数据，另外还有字节流（Byte）
                 pipe.ReadMode = PipeTransmissionMode.Message;

                 Console.WriteLine("request");
                 byte[] request = Encoding.UTF8.GetBytes(message);

                 Console.WriteLine("WriteAsync");
                 //将字节序列异步写入当前流，并将流的当前位置提升写入的字节数。
                 //   buffer:
                 //     从中写入数据的缓冲区。
                 //
                 //   offset:
                 //     buffer 中的从零开始的字节偏移量，从此处开始将字节复制到该流。
                 //
                 //   count:
                 //     最多写入的字节数。
                 await pipe.WriteAsync(request, , request.Length);

                 Console.WriteLine("response");
                 byte[] response = new byte[];

                 Console.WriteLine("ReadAsync");
                 //从当前流异步读取字节序列，并将流中的位置提升读取的字节数。
                 //   buffer:
                 //     数据写入的缓冲区。
                 //
                 //   offset:
                 //     buffer 中的字节偏移量，从该偏移量开始写入从流中读取的数据。
                 //
                 //   count:
                 //     最多读取的字节数。
                 int bytesRead = await pipe.ReadAsync(response, , response.Length);

                 Console.WriteLine("retuen");
                 return Encoding.UTF8.GetString(response, , bytesRead);
             }
         }

         private static void NamedPipeClientStreamTest()
         {
             using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", "testpipe", PipeDirection.In))
             {

                 // Connect to the pipe or wait until the pipe is available.
                 Console.Write("Attempting to connect to pipe...");
                 pipeClient.Connect();

                 Console.WriteLine("Connected to pipe.");
                 Console.WriteLine("There are currently {0} pipe server instances open.", pipeClient.NumberOfServerInstances);
                 using (StreamReader sr = new StreamReader(pipeClient))
                 {
                     // Display the read text to the console
                     string temp;
                     while ((temp = sr.ReadLine()) != null)
                     {
                         Console.WriteLine("Received from server: {0}", temp);
                     }
                 }
             }
         }