Comment les canaux nommés peuvent-ils faciliter la communication interprocessus en Python et C# ?

Une application de test IPC simple utilisant des canaux nommés

Les canaux nommés fournissent une méthode robuste de communication inter-processus (IPC), permettant un échange de données efficace entre différents programmes. Cet exemple montre une application de test de base dans laquelle un processus envoie un message et reçoit une réponse.

Implémentation Python

Le code Python utilise le module multiprocessing pour créer un processus émetteur et récepteur.

Processus de l'expéditeur :

<code class="language-python">import multiprocessing

def sender():
    pipe_in, pipe_out = multiprocessing.Pipe()
    p = multiprocessing.Process(target=receiver, args=(pipe_in,))
    p.start()
    pipe_out.send("Hello from Python")
    p.join()
</code>

Processus de réception :

<code class="language-python">def receiver(pipe_in):
    message = pipe_in.recv()
    print(message)  # Output: Hello from Python
    pipe_in.send("Acknowledged from Python")</code>

Implémentation C#

Le code C# utilise des flux client et serveur de canal nommé pour le mécanisme IPC.

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

class Program
{
    static void Main()
    {
        StartServer();
        Task.Delay(1000).Wait(); // Allow server to start

        // Client
        using (var client = new NamedPipeClientStream("PipesOfPeace"))
        {
            client.Connect();
            using (StreamWriter writer = new StreamWriter(client))
            {
                writer.WriteLine("Hello from C#");
                writer.Flush();
            }

            using (StreamReader reader = new StreamReader(client))
            {
                string response = reader.ReadLine(); // Reads "Acknowledged from C#"
                Console.WriteLine(response);
            }
        }
    }

    static void StartServer()
    {
        Task.Factory.StartNew(() =>
        {
            using (var server = new NamedPipeServerStream("PipesOfPeace"))
            {
                server.WaitForConnection();
                using (StreamReader reader = new StreamReader(server))
                {
                    string message = reader.ReadLine(); // Reads "Hello from C#"
                    Console.WriteLine(message);
                }

                using (StreamWriter writer = new StreamWriter(server))
                {
                    writer.WriteLine("Acknowledged from C#");
                    writer.Flush();
                }
            }
        });
    }
}</code>

Les deux exemples démontrent les principes de base de l'utilisation de canaux nommés pour la communication inter-processus. Un message est envoyé, reçu et une réponse est renvoyée, illustrant une solution IPC simple mais efficace.

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!