How Can Named Pipes Facilitate Inter-Process Communication in a Simple C# Console Application?

A Simple C# Console Application Demonstrating Named Pipes

Named pipes offer a robust method for inter-process communication (IPC) within a single system. This example showcases a basic C# console application where two processes exchange messages using named pipes.

Application Structure

The application comprises two programs: one initiates communication by sending a message to the second, which then responds. Both run concurrently for continuous message exchange.

Code Implementation

The following C# code demonstrates the implementation:

using System;
using System.IO;
using System.IO.Pipes;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleAppIPC
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initiate the server process
            StartServer();
            Task.Delay(1000).Wait(); // Brief delay to ensure server is ready

            // Client-side connection and communication
            using (var client = new NamedPipeClientStream("PipesOfPiece"))
            {
                client.Connect();
                using (var reader = new StreamReader(client))
                using (var writer = new StreamWriter(client))
                {
                    while (true)
                    {
                        string input = Console.ReadLine();
                        if (string.IsNullOrEmpty(input)) break;
                        writer.WriteLine(input);
                        writer.Flush();
                        Console.WriteLine(reader.ReadLine());
                    }
                }
            }
        }

        static void StartServer()
        {
            Task.Factory.StartNew(() =>
            {
                using (var server = new NamedPipeServerStream("PipesOfPiece"))
                {
                    server.WaitForConnection();
                    using (var reader = new StreamReader(server))
                    using (var writer = new StreamWriter(server))
                    {
                        while (true)
                        {
                            string line = reader.ReadLine();
                            writer.WriteLine(string.Join("", line.Reverse()));
                            writer.Flush();
                        }
                    }
                }
            });
        }
    }
}

Operational Flow

The client connects to the named pipe "PipesOfPiece," establishing a connection with the server. Messages are sent via a StreamWriter and received using a StreamReader. In this example, the server reverses the received message before sending it back to the client, illustrating a simple communication pattern. The client then displays the reversed message.

The above is the detailed content of How Can Named Pipes Facilitate Inter-Process Communication in a Simple C# Console Application?. For more information, please follow other related articles on the PHP Chinese website!