C# - .NET 3.5 Adds Named Pipes Support [Beginner]

Leave it to Microsoft to make all my hard work worthless. It took a lot of hard work and a lot of Windows API calls to get named pipes integrated into a .NET 2.0 application. Now, thanks to .NET 3.5, named pipes are as easy as importing System.IO.Pipes.

If you want a named pipe server, all you have to do is create some instances of NamedPipeServerStream to handle each client connection. I stole the following code straight from the MSDN documentation.

using System;
using System.IO;
using System.IO.Pipes;

class PipeServer
{
  static void Main()
  {
    using (NamedPipeServerStream pipeServer =
        new NamedPipeServerStream("testpipe", PipeDirection.Out))
    {
      Console.WriteLine("NamedPipeServerStream object created.");

      // Wait for a client to connect
      Console.Write("Waiting for client connection...");
      pipeServer.WaitForConnection();

      Console.WriteLine("Client connected.");
      try
      {
        // Read user input and send that to the client process.
        using (StreamWriter sw = new StreamWriter(pipeServer))
        {
          sw.AutoFlush = true;
          Console.Write("Enter text: ");
          sw.WriteLine(Console.ReadLine());
        }
      }
      // Catch the IOException that is raised if the pipe is 
      // broken or disconnected.
      catch (IOException e)
      {
        Console.WriteLine("ERROR: {0}", e.Message);
      }
    }
  }
}

Just like most .NET streams, the NamedPipeServerStream supports both synchronous and asynchronous communication. The stream is also full duplex, meaning it can be read and written to at the same time. Getting the overlapped IO working was one of the biggest challenges to overcome for named pipes in previous versions of .NET.

Making a client is just as easy as the server. The Pipes namespace has another stream, called NamedPipeClientStream, which does all the work for you.

using System;
using System.IO;
using System.IO.Pipes;

class PipeClient
{
  static void Main(string[] args)
  {
    using (NamedPipeClientStream pipeClient =
        new NamedPipeClientStream(".", "testpipe", PipeDirection.In))
    {

      // Connect to the pipe or wait until the pipe is available.
      Console.Write("Attempting to connect to pipe...");
      pipeClient.Connect();

      Console.WriteLine("Connected to pipe.");
      Console.WriteLine("There are currently {0} pipe server instances open.",
         pipeClient.NumberOfServerInstances);
      using (StreamReader sr = new StreamReader(pipeClient))
      {
        // Display the read text to the console
        string temp;
        while ((temp = sr.ReadLine()) != null)
        {
          Console.WriteLine("Received from server: {0}", temp);
        }
      }
    }
    Console.Write("Press Enter to continue...");
    Console.ReadLine();
  }
}

When I get a chance to use these objects a little more, I'll post a more in-depth tutorial. Personally, I'd like to see a set of objects similar to the TcpClient and TcpServer classes for handling named pipes, but I guess I'll have to wait a little longer for that.