• 【微软技术栈】C#.NET 中的管道操作

    C#.NET 管道为进程间通信提供了平台。 管道分为两种类型：

    • 匿名管道。

      匿名管道在本地计算机上提供进程间通信。 与命名管道相比，虽然匿名管道需要的开销更少，但提供的服务有限。 匿名管道是单向的，不能通过网络使用。 仅支持一个服务器实例。 匿名管道可用于线程间通信，也可用于父进程和子进程之间的通信，因为管道句柄可以轻松传递给所创建的子进程。在 .NET 中，可通过使用 AnonymousPipeServerStream 和 AnonymousPipeClientStream 类来实现匿名管道。

    • 命名管道。

      命名管道在管道服务器和一个或多个管道客户端之间提供进程间通信。 命名管道可以是单向的，也可以是双向的。 它们支持基于消息的通信，并允许多个客户端使用相同的管道名称同时连接到服务器进程。 命名管道还支持模拟，这样连接进程就可以在远程服务器上使用自己的权限。在 .NET 中，可通过使用 NamedPipeServerStream 和 NamedPipeClientStream 类来实现命名管道。

    1、如何：使用匿名管道进行本地进程间通信

    匿名管道在本地计算机上提供进程间通信。 它们提供的功能比命名管道少，但所需要的系统开销也少。 使用匿名管道，可以在本地计算机上更轻松地进行进程间通信。 不能使用匿名管道进行网络通信。

    若要实现匿名管道，请使用 AnonymousPipeServerStream 和 AnonymousPipeClientStream 类。

    1.1 示例 1

    下面的示例展示了如何使用匿名管道将字符串从父进程发送到子进程。 本示例在父进程中创建一个 AnonymousPipeServerStream 对象，其 PipeDirection 值为 Out。然后，父进程通过使用客户端句柄创建 AnonymousPipeClientStream 对象来创建子进程。 子进程的 PipeDirection 值为 In。

    接下来，父进程将用户提供的字符串发送给子进程。 字符串在子进程的控制台中显示。

    下面的示例展示了服务器进程。

    1. using System;
    2. using System.IO;
    3. using System.IO.Pipes;
    4. using System.Diagnostics;
    5.  
    6. class PipeServer
    7. {
    8.     static void Main()
    9.     {
    10.         Process pipeClient = new Process();
    11.  
    12.         pipeClient.StartInfo.FileName = "pipeClient.exe";
    13.  
    14.         using (AnonymousPipeServerStream pipeServer =
    15.             new AnonymousPipeServerStream(PipeDirection.Out,
    16.             HandleInheritability.Inheritable))
    17.         {
    18.             Console.WriteLine("[SERVER] Current TransmissionMode: {0}.",
    19.                 pipeServer.TransmissionMode);
    20.  
    21.             // Pass the client process a handle to the server.
    22.             pipeClient.StartInfo.Arguments =
    23.                 pipeServer.GetClientHandleAsString();
    24.             pipeClient.StartInfo.UseShellExecute = false;
    25.             pipeClient.Start();
    26.  
    27.             pipeServer.DisposeLocalCopyOfClientHandle();
    28.  
    29.             try
    30.             {
    31.                 // Read user input and send that to the client process.
    32.                 using (StreamWriter sw = new StreamWriter(pipeServer))
    33.                 {
    34.                     sw.AutoFlush = true;
    35.                     // Send a 'sync message' and wait for client to receive it.
    36.                     sw.WriteLine("SYNC");
    37.                     pipeServer.WaitForPipeDrain();
    38.                     // Send the console input to the client process.
    39.                     Console.Write("[SERVER] Enter text: ");
    40.                     sw.WriteLine(Console.ReadLine());
    41.                 }
    42.             }
    43.             // Catch the IOException that is raised if the pipe is broken
    44.             // or disconnected.
    45.             catch (IOException e)
    46.             {
    47.                 Console.WriteLine("[SERVER] Error: {0}", e.Message);
    48.             }
    49.         }
    50.  
    51.         pipeClient.WaitForExit();
    52.         pipeClient.Close();
    53.         Console.WriteLine("[SERVER] Client quit. Server terminating.");
    54.     }
    55. }

    1.2 示例 2

    下面的示例展示了客户端进程。 服务器进程启动客户端进程，并为此进程提供客户端句柄。 客户端代码生成的可执行文件应命名为 pipeClient.exe，并在运行服务器进程前复制到服务器可执行文件所在的相同目录中。

    1. using System;
    2. using System.IO;
    3. using System.IO.Pipes;
    4.  
    5. class PipeClient
    6. {
    7.     static void Main(string[] args)
    8.     {
    9.         if (args.Length > 0)
    10.         {
    11.             using (PipeStream pipeClient =
    12.                 new AnonymousPipeClientStream(PipeDirection.In, args[0]))
    13.             {
    14.                 Console.WriteLine("[CLIENT] Current TransmissionMode: {0}.",
    15.                    pipeClient.TransmissionMode);
    16.  
    17.                 using (StreamReader sr = new StreamReader(pipeClient))
    18.                 {
    19.                     // Display the read text to the console
    20.                     string temp;
    21.  
    22.                     // Wait for 'sync message' from the server.
    23.                     do
    24.                     {
    25.                         Console.WriteLine("[CLIENT] Wait for sync...");
    26.                         temp = sr.ReadLine();
    27.                     }
    28.                     while (!temp.StartsWith("SYNC"));
    29.  
    30.                     // Read the server data and echo to the console.
    31.                     while ((temp = sr.ReadLine()) != null)
    32.                     {
    33.                         Console.WriteLine("[CLIENT] Echo: " + temp);
    34.                     }
    35.                 }
    36.             }
    37.         }
    38.         Console.Write("[CLIENT] Press Enter to continue...");
    39.         Console.ReadLine();
    40.     }
    41. }

    2、如何：使用命名管道进行网络进程间通信

    命名管道在管道服务器和一个或多个管道客户端之间提供进程间通信。 它们比匿名管道（用于在本地计算机上提供进程间的通信）提供更多的功能。 命名管道支持跨网络和多个服务器实例的全双工通信、基于消息的通信以及客户端模拟，这样连接进程便可在远程服务器上使用自己的权限集。若要实现名称管道，请使用 NamedPipeServerStream 和 NamedPipeClientStream 类。

    2.1 示例 1

    下面的示例展示了如何使用 NamedPipeServerStream 类创建命名管道。 在此示例中，服务器进程创建四个线程。 每个线程都可以接受客户端连接。 然后，连接的客户端进程向服务器提供文件名。 如果客户端拥有足够的权限，服务器进程就会打开文件，并将它的内容发送回客户端。

    1. using System;
    2. using System.IO;
    3. using System.IO.Pipes;
    4. using System.Text;
    5. using System.Threading;
    6.  
    7. public class PipeServer
    8. {
    9.     private static int numThreads = 4;
    10.  
    11.     public static void Main()
    12.     {
    13.         int i;
    14.         Thread?[] servers = new Thread[numThreads];
    15.  
    16.         Console.WriteLine("\n*** Named pipe server stream with impersonation example ***\n");
    17.         Console.WriteLine("Waiting for client connect...\n");
    18.         for (i = 0; i < numThreads; i++)
    19.         {
    20.             servers[i] = new Thread(ServerThread);
    21.             servers[i]?.Start();
    22.         }
    23.         Thread.Sleep(250);
    24.         while (i > 0)
    25.         {
    26.             for (int j = 0; j < numThreads; j++)
    27.             {
    28.                 if (servers[j] != null)
    29.                 {
    30.                     if (servers[j]!.Join(250))
    31.                     {
    32.                         Console.WriteLine("Server thread[{0}] finished.", servers[j]!.ManagedThreadId);
    33.                         servers[j] = null;
    34.                         i--;    // decrement the thread watch count
    35.                     }
    36.                 }
    37.             }
    38.         }
    39.         Console.WriteLine("\nServer threads exhausted, exiting.");
    40.     }
    41.  
    42.     private static void ServerThread(object? data)
    43.     {
    44.         NamedPipeServerStream pipeServer =
    45.             new NamedPipeServerStream("testpipe", PipeDirection.InOut, numThreads);
    46.  
    47.         int threadId = Thread.CurrentThread.ManagedThreadId;
    48.  
    49.         // Wait for a client to connect
    50.         pipeServer.WaitForConnection();
    51.  
    52.         Console.WriteLine("Client connected on thread[{0}].", threadId);
    53.         try
    54.         {
    55.             // Read the request from the client. Once the client has
    56.             // written to the pipe its security token will be available.
    57.  
    58.             StreamString ss = new StreamString(pipeServer);
    59.  
    60.             // Verify our identity to the connected client using a
    61.             // string that the client anticipates.
    62.  
    63.             ss.WriteString("I am the one true server!");
    64.             string filename = ss.ReadString();
    65.  
    66.             // Read in the contents of the file while impersonating the client.
    67.             ReadFileToStream fileReader = new ReadFileToStream(ss, filename);
    68.  
    69.             // Display the name of the user we are impersonating.
    70.             Console.WriteLine("Reading file: {0} on thread[{1}] as user: {2}.",
    71.                 filename, threadId, pipeServer.GetImpersonationUserName());
    72.             pipeServer.RunAsClient(fileReader.Start);
    73.         }
    74.         // Catch the IOException that is raised if the pipe is broken
    75.         // or disconnected.
    76.         catch (IOException e)
    77.         {
    78.             Console.WriteLine("ERROR: {0}", e.Message);
    79.         }
    80.         pipeServer.Close();
    81.     }
    82. }
    83.  
    84. // Defines the data protocol for reading and writing strings on our stream
    85. public class StreamString
    86. {
    87.     private Stream ioStream;
    88.     private UnicodeEncoding streamEncoding;
    89.  
    90.     public StreamString(Stream ioStream)
    91.     {
    92.         this.ioStream = ioStream;
    93.         streamEncoding = new UnicodeEncoding();
    94.     }
    95.  
    96.     public string ReadString()
    97.     {
    98.         int len = 0;
    99.  
    100.         len = ioStream.ReadByte() * 256;
    101.         len += ioStream.ReadByte();
    102.         byte[] inBuffer = new byte[len];
    103.         ioStream.Read(inBuffer, 0, len);
    104.  
    105.         return streamEncoding.GetString(inBuffer);
    106.     }
    107.  
    108.     public int WriteString(string outString)
    109.     {
    110.         byte[] outBuffer = streamEncoding.GetBytes(outString);
    111.         int len = outBuffer.Length;
    112.         if (len > UInt16.MaxValue)
    113.         {
    114.             len = (int)UInt16.MaxValue;
    115.         }
    116.         ioStream.WriteByte((byte)(len / 256));
    117.         ioStream.WriteByte((byte)(len & 255));
    118.         ioStream.Write(outBuffer, 0, len);
    119.         ioStream.Flush();
    120.  
    121.         return outBuffer.Length + 2;
    122.     }
    123. }
    124.  
    125. // Contains the method executed in the context of the impersonated user
    126. public class ReadFileToStream
    127. {
    128.     private string fn;
    129.     private StreamString ss;
    130.  
    131.     public ReadFileToStream(StreamString str, string filename)
    132.     {
    133.         fn = filename;
    134.         ss = str;
    135.     }
    136.  
    137.     public void Start()
    138.     {
    139.         string contents = File.ReadAllText(fn);
    140.         ss.WriteString(contents);
    141.     }
    142. }

    2.2 示例 2

    下面的示例展示了使用 NamedPipeClientStream 类的客户端进程。 客户端连接到服务器进程，并将文件名发送到服务器。 因为此示例使用模拟，所以运行客户端应用的标识必须有权访问文件。 然后，服务器将文件内容发送回客户端。 接下来，文件内容在控制台中显示。

    1. using System;
    2. using System.Diagnostics;
    3. using System.IO;
    4. using System.IO.Pipes;
    5. using System.Security.Principal;
    6. using System.Text;
    7. using System.Threading;
    8.  
    9. public class PipeClient
    10. {
    11.     private static int numClients = 4;
    12.  
    13.     public static void Main(string[] args)
    14.     {
    15.         if (args.Length > 0)
    16.         {
    17.             if (args[0] == "spawnclient")
    18.             {
    19.                 var pipeClient =
    20.                     new NamedPipeClientStream(".", "testpipe",
    21.                         PipeDirection.InOut, PipeOptions.None,
    22.                         TokenImpersonationLevel.Impersonation);
    23.  
    24.                 Console.WriteLine("Connecting to server...\n");
    25.                 pipeClient.Connect();
    26.  
    27.                 var ss = new StreamString(pipeClient);
    28.                 // Validate the server's signature string.
    29.                 if (ss.ReadString() == "I am the one true server!")
    30.                 {
    31.                     // The client security token is sent with the first write.
    32.                     // Send the name of the file whose contents are returned
    33.                     // by the server.
    34.                     ss.WriteString("c:\\textfile.txt");
    35.  
    36.                     // Print the file to the screen.
    37.                     Console.Write(ss.ReadString());
    38.                 }
    39.                 else
    40.                 {
    41.                     Console.WriteLine("Server could not be verified.");
    42.                 }
    43.                 pipeClient.Close();
    44.                 // Give the client process some time to display results before exiting.
    45.                 Thread.Sleep(4000);
    46.             }
    47.         }
    48.         else
    49.         {
    50.             Console.WriteLine("\n*** Named pipe client stream with impersonation example ***\n");
    51.             StartClients();
    52.         }
    53.     }
    54.  
    55.     // Helper function to create pipe client processes
    56.     private static void StartClients()
    57.     {
    58.         string currentProcessName = Environment.CommandLine;
    59.  
    60.         // Remove extra characters when launched from Visual Studio
    61.         currentProcessName = currentProcessName.Trim('"', ' ');
    62.  
    63.         currentProcessName = Path.ChangeExtension(currentProcessName, ".exe");
    64.         Process?[] plist = new Process?[numClients];
    65.  
    66.         Console.WriteLine("Spawning client processes...\n");
    67.  
    68.         if (currentProcessName.Contains(Environment.CurrentDirectory))
    69.         {
    70.             currentProcessName = currentProcessName.Replace(Environment.CurrentDirectory, String.Empty);
    71.         }
    72.  
    73.         // Remove extra characters when launched from Visual Studio
    74.         currentProcessName = currentProcessName.Replace("\\", String.Empty);
    75.         currentProcessName = currentProcessName.Replace("\"", String.Empty);
    76.  
    77.         int i;
    78.         for (i = 0; i < numClients; i++)
    79.         {
    80.             // Start 'this' program but spawn a named pipe client.
    81.             plist[i] = Process.Start(currentProcessName, "spawnclient");
    82.         }
    83.         while (i > 0)
    84.         {
    85.             for (int j = 0; j < numClients; j++)
    86.             {
    87.                 if (plist[j] != null)
    88.                 {
    89.                     if (plist[j]!.HasExited)
    90.                     {
    91.                         Console.WriteLine($"Client process[{plist[j]?.Id}] has exited.");
    92.                         plist[j] = null;
    93.                         i--;    // decrement the process watch count
    94.                     }
    95.                     else
    96.                     {
    97.                         Thread.Sleep(250);
    98.                     }
    99.                 }
    100.             }
    101.         }
    102.         Console.WriteLine("\nClient processes finished, exiting.");
    103.     }
    104. }
    105.  
    106. // Defines the data protocol for reading and writing strings on our stream.
    107. public class StreamString
    108. {
    109.     private Stream ioStream;
    110.     private UnicodeEncoding streamEncoding;
    111.  
    112.     public StreamString(Stream ioStream)
    113.     {
    114.         this.ioStream = ioStream;
    115.         streamEncoding = new UnicodeEncoding();
    116.     }
    117.  
    118.     public string ReadString()
    119.     {
    120.         int len;
    121.         len = ioStream.ReadByte() * 256;
    122.         len += ioStream.ReadByte();
    123.         var inBuffer = new byte[len];
    124.         ioStream.Read(inBuffer, 0, len);
    125.  
    126.         return streamEncoding.GetString(inBuffer);
    127.     }
    128.  
    129.     public int WriteString(string outString)
    130.     {
    131.         byte[] outBuffer = streamEncoding.GetBytes(outString);
    132.         int len = outBuffer.Length;
    133.         if (len > UInt16.MaxValue)
    134.         {
    135.             len = (int)UInt16.MaxValue;
    136.         }
    137.         ioStream.WriteByte((byte)(len / 256));
    138.         ioStream.WriteByte((byte)(len & 255));
    139.         ioStream.Write(outBuffer, 0, len);
    140.         ioStream.Flush();
    141.  
    142.         return outBuffer.Length + 2;
    143.     }
    144. }

    2.3 可靠编程

    因为此示例中的客户端进程和服务器进程可以在同一台计算机上运行，所以提供给 NamedPipeClientStream 对象的服务器名称为 "."。 如果客户端进程和服务器进程在不同的计算机上运行，"." 会被替换为运行服务器进程的计算机的网络名称。

  • 相关阅读:
    springboot+校园交友平台小程序 毕业设计-附源码191733
    Grafana+Prometheus打造运维监控系统（一）-安装篇
    Java 19新特性：Structured Concurrency (结构化并发编程)
    trino on yarn
    牛客刷题＜17＞用3-8译码器实现全减器
    pdf文档内容提取pdfplumber、PyPDF2
    【数据结构与算法】五、树结构-从二叉树到B+Tree
    Python——使用asyncio包处理并发
    蓝桥杯 第 1 场算法双周赛 第三题 分组【算法赛】c++ 贪心+双指针
    hbuilder x配置 配置使用 vue-cli和微信开发者工具
  • 原文地址：https://blog.csdn.net/m0_51887793/article/details/134387818