Comment les tuyaux anonymes peuvent-ils améliorer la communication inter-processus efficace en C #?

Utiliser des canaux anonymes en C# pour obtenir une communication inter-processus efficace

Lors de l'établissement d'une communication entre les processus parent et enfant en C#, l'efficacité est cruciale. Les canaux anonymes offrent une solution de communication asynchrone simple mais efficace, basée sur les événements.

Les canaux anonymes sont des canaux de communication à sens unique entre les processus. Ils permettent aux données d'être transférées de manière asynchrone tout en éliminant le besoin de threads dédiés pour gérer les communications peu fréquentes.

Pour implémenter des canaux anonymes en C#, vous pouvez utiliser l'espace de noms System.IO.Pipes. Il fournit les classes NamedPipeClientStream et NamedPipeServerStream pour créer respectivement des points de terminaison client et serveur.

Implémentation client

<code class="language-csharp">using System.IO.Pipes;
using System.Threading;

namespace ChildProcess
{
    class Program
    {
        static void Main(string[] args)
        {
            // 连接到服务器管道
            using (NamedPipeClientStream pipeClient = new NamedPipeClientStream(".", "MyPipe", PipeDirection.In))
            {
                pipeClient.Connect();

                // 启动一个线程来异步读取消息
                Thread readThread = new Thread(() => ReadMessages(pipeClient));
                readThread.Start();

                // 持续读取消息
                while (true)
                {
                    // 执行其他任务
                }
            }
        }

        static void ReadMessages(NamedPipeClientStream pipeClient)
        {
            while (true)
            {
                byte[] buffer = new byte[1024];
                int bytesRead = pipeClient.Read(buffer, 0, buffer.Length);
                if (bytesRead > 0)
                {
                    // 处理接收到的消息
                }
            }
        }
    }
}</code>

Implémentation côté serveur

<code class="language-csharp">using System.IO.Pipes;
using System.Threading.Tasks;

namespace ParentProcess
{
    class Program
    {
        static void Main(string[] args)
        {
            // 创建服务器管道
            using (NamedPipeServerStream pipeServer = new NamedPipeServerStream("MyPipe", PipeDirection.Out))
            {
                // 等待客户端连接
                pipeServer.WaitForConnection();

                // 异步发送消息
                Task.Run(() => WriteMessages(pipeServer));
            }
        }

        static async void WriteMessages(NamedPipeServerStream pipeServer)
        {
            while (true)
            {
                // 执行其他任务

                // 向管道写入消息
                string message = "来自父进程的问候！";
                byte[] buffer = System.Text.Encoding.UTF8.GetBytes(message);
                await pipeServer.WriteAsync(buffer, 0, buffer.Length);
            }
        }
    }
}</code>

Ce schéma fournit une méthode efficace et légère de communication inter-processus sans la surcharge des threads dédiés. Utilisez des canaux anonymes et des opérations asynchrones pour garantir une communication en temps réel basée sur les événements.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!