Создание каналов (pipe)

using System;
using System.IO;
using System.IO.Pipes;
using System.Threading;
 
class PipeServer
{
    static int numThreads = 4;
 
    static void Main()
    {
        for (int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ServerThread));
            newThread.Start();
        }
        Console.WriteLine("Press enter to exit.");
        Console.ReadLine();
    } // Main()
 
    private static void ServerThread()
    {
        using (NamedPipeServerStream pipeServer =
            new NamedPipeServerStream("testpipe", PipeDirection.InOut, numThreads))
        {
            Console.WriteLine("NamedPipeServerStream thread created.");
 
            // Wait for a client to connect
            pipeServer.WaitForConnection();
 
            Console.WriteLine("Client connected.");
            try
            {
                // Read the request from the client. Once the client has
                // written to the pipe its security token will be available.
                using (StreamReader sr = new StreamReader(pipeServer))
                using (StreamWriter sw = new StreamWriter(pipeServer))
                {
                    sw.AutoFlush = true;
 
                    // Verify our identity to the connected client using a
                    // string that the client anticipates.
                    sw.WriteLine("I am the true server!");
 
                    // Obtain the filename from the connected client.
                    string filename = sr.ReadLine();
 
                    // Read in the contents of the file while impersonating
                    // the client.
                    ReadFileToStream fileReader = new
                        ReadFileToStream(pipeServer, filename);
 
                    // Display the name of the user we are impersonating.
                    Console.WriteLine("Reading file: {0} as user {1}.",
                        pipeServer.GetImpersonationUserName(), filename);
 
                    pipeServer.RunAsClient(fileReader.Start);
 
                    pipeServer.Disconnect();
                }
           }
            // Catch the IOException that is raised if the pipe is broken
            // or disconnected.
            catch (IOException e)
            {
                Console.WriteLine("ERROR: {0}", e.Message);
            }
        }
    } // ServerThread()
} // PipeServer
 
class ReadFileToStream
{
    private string m_filename;
    private Stream m_stream;
 
    public ReadFileToStream(Stream stream, string filename)
    {
        m_filename = filename;
        m_stream = stream;
    } // ReadFileToStream(stream, filename)
 
    public void Start()
    {
        using (StreamWriter sw = new StreamWriter(m_stream))
        {
            string contents = File.ReadAllText(m_filename);
            sw.WriteLine(contents);
            sw.Flush();
        }
    } // Start()
} // ReadFileToStream

using System;
using System.IO;
using System.IO.Pipes;
using System.Text;
using System.Security.Principal;
using System.Diagnostics;
using System.Threading;
 
public class PipeClient
{
    private static int numClients = 4;
 
    public static void Main(string[] Args)
    {
        if (Args.Length > 0)
        {
            if (Args[0] == "spawnclient")
            {
                NamedPipeClientStream pipeClient =
                    new NamedPipeClientStream(".", "testpipe",
                        PipeDirection.InOut, PipeOptions.None,
                        TokenImpersonationLevel.Impersonation);
 
                Console.WriteLine("Connecting to server...\n");
                pipeClient.Connect();
 
                StreamString ss = new StreamString(pipeClient);
                // Validate the server's signature string
                if (ss.ReadString() == "I am the one true server!")
                {
                    // The client security token is sent with the first write.
                    // Send the name of the file whose contents are returned
                    // by the server.
                    ss.WriteString("c:\\textfile.txt");
 
                    // Print the file to the screen.
                    Console.Write(ss.ReadString());
                }
                else
                {
                    Console.WriteLine("Server could not be verified.");
                }
                pipeClient.Close();
                // Give the client process some time to display results before exiting.
                Thread.Sleep(4000);
            }
        }
        else
        {
            Console.WriteLine("\n*** Named pipe client stream with impersonation example ***\n");
            StartClients();
        }
    }
 
    // Helper function to create pipe client processes
    private static void StartClients()
    {
        int i;
        string currentProcessName = Environment.CommandLine;
        Process[] plist = new Process[numClients];
 
        Console.WriteLine("Spawning client processes...\n");
 
        if (currentProcessName.Contains(Environment.CurrentDirectory))
        {
            currentProcessName = currentProcessName.Replace(Environment.CurrentDirectory, String.Empty);
        }
 
        // Remove extra characters when launched from Visual Studio
        currentProcessName = currentProcessName.Replace("\\", String.Empty);
        currentProcessName = currentProcessName.Replace("\"", String.Empty);
 
        for (i = 0; i < numClients; i++)
        {
            // Start 'this' program but spawn a named pipe client.
            plist[i] = Process.Start(currentProcessName, "spawnclient");
        }
        while (i > 0)
        {
            for (int j = 0; j < numClients; j++)
            {
                if (plist[j] != null)
                {
                    if (plist[j].HasExited)
                    {
                        Console.WriteLine("Client process[{0}] has exited.",
                            plist[j].Id);
                        plist[j] = null;
                        i--;    // decrement the process watch count
                    }
                    else
                    {
                        Thread.Sleep(250);
                    }
                }
            }
        }
        Console.WriteLine("\nClient processes finished, exiting.");
    }
}
 
// Defines the data protocol for reading and writing strings on our stream
public class StreamString
{
    private Stream ioStream;
    private UnicodeEncoding streamEncoding;
 
    public StreamString(Stream ioStream)
    {
        this.ioStream = ioStream;
        streamEncoding = new UnicodeEncoding();
    }
 
    public string ReadString()
    {
        int len;
        len = ioStream.ReadByte() * 256;
        len += ioStream.ReadByte();
        byte[] inBuffer = new byte[len];
        ioStream.Read(inBuffer, 0, len);
 
        return streamEncoding.GetString(inBuffer);
    }
 
    public int WriteString(string outString)
    {
        byte[] outBuffer = streamEncoding.GetBytes(outString);
        int len = outBuffer.Length;
        if (len > UInt16.MaxValue)
        {
            len = (int)UInt16.MaxValue;
        }
        ioStream.WriteByte((byte)(len / 256));
        ioStream.WriteByte((byte)(len & 255));
        ioStream.Write(outBuffer, 0, len);
        ioStream.Flush();
 
        return outBuffer.Length + 2;
    }
}

sw.AutoFlush = true;