Recipe 13.13 Using Named Pipes to Communicate
ProblemYou need a way to use named pipes to communicate with another application across the network. SolutionCreate a P/Invoke wrapper class for the named pipe APIs in Kernel32.dll to allow for managed access, and then create a managed client and managed server class to work with named pipes. Here are the named pipe interop wrappers in a class called NamedPipeInterop : namespace NamedPipes { /// <summary> /// Imported namedpipe entry points for p/invoke into native code. /// </summary> [SuppressUnmanagedCodeSecurity] public class NamedPipeInterop { // #defines related to named pipe processing public const uint PIPE_ACCESS_OUTBOUND = 0x00000002; public const uint PIPE_ACCESS_DUPLEX = 0x00000003; public const uint PIPE_ACCESS_INBOUND = 0x00000001; public const uint PIPE_WAIT = 0x00000000; public const uint PIPE_NOWAIT = 0x00000001; public const uint PIPE_READMODE_BYTE = 0x00000000; public const uint PIPE_READMODE_MESSAGE = 0x00000002; public const uint PIPE_TYPE_BYTE = 0x00000000; public const uint PIPE_TYPE_MESSAGE = 0x00000004; public const uint PIPE_CLIENT_END = 0x00000000; public const uint PIPE_SERVER_END = 0x00000001; public const uint PIPE_UNLIMITED_INSTANCES = 255; public const uint NMPWAIT_WAIT_FOREVER = 0xffffffff; public const uint NMPWAIT_NOWAIT = 0x00000001; public const uint NMPWAIT_USE_DEFAULT_WAIT = 0x00000000; public const uint GENERIC_READ = (0x80000000); public const uint GENERIC_WRITE = (0x40000000); public const uint GENERIC_EXECUTE = (0x20000000); public const uint GENERIC_ALL = (0x10000000); public const uint CREATE_NEW = 1; public const uint CREATE_ALWAYS = 2; public const uint OPEN_EXISTING = 3; public const uint OPEN_ALWAYS = 4; public const uint TRUNCATE_EXISTING = 5; public const int INVALID_HANDLE_VALUE = -1; public const uint ERROR_PIPE_BUSY = 231; public const uint ERROR_NO_DATA = 232; public const uint ERROR_PIPE_NOT_CONNECTED = 233; public const uint ERROR_MORE_DATA = 234; public const uint ERROR_PIPE_CONNECTED = 535; public const uint ERROR_PIPE_LISTENING = 536; public static int GetLastError( ) { return Marshal.GetLastWin32Error( ); } [DllImport("kernel32.dll", SetLastError=true)] public static extern bool CallNamedPipe( string lpNamedPipeName, byte[] lpInBuffer, uint nInBufferSize, byte[] lpOutBuffer, uint nOutBufferSize, byte[] lpBytesRead, uint nTimeOut); [DllImport("kernel32.dll", SetLastError=true)] public static extern bool CloseHandle(int hObject); [DllImport("kernel32.dll", SetLastError=true)] public static extern bool ConnectNamedPipe( int hNamedPipe, // handle to named pipe IntPtr lpOverlapped // overlapped structure ); [DllImport("kernel32.dll", SetLastError=true)] public static extern int CreateNamedPipe( String lpName, // pipe name uint dwOpenMode, // pipe open mode uint dwPipeMode, // pipe-specific modes uint nMaxInstances, // maximum number of instances uint nOutBufferSize, // output buffer size uint nInBufferSize, // input buffer size uint nDefaultTimeOut, // time-out interval //SecurityAttributes attr IntPtr pipeSecurityDescriptor // security descriptor ); [DllImport("kernel32.dll", SetLastError=true)] public static extern int CreatePipe( int hReadPipe, int hWritePipe, IntPtr lpPipeAttributes, uint nSize); [DllImport("kernel32.dll", SetLastError=true)] public static extern int CreateFile( String lpFileName, // filename uint dwDesiredAccess, // access mode uint dwShareMode, // share mode IntPtr attr, // security descriptor uint dwCreationDisposition, // how to create uint dwFlagsAndAttributes, // file attributes uint hTemplateFile); // handle to template file [DllImport("kernel32.dll", SetLastError=true)] public static extern bool DisconnectNamedPipe(int hNamedPipe); [DllImport("kernel32.dll", SetLastError=true)] public static extern bool FlushFileBuffers(int hFile); [DllImport("kernel32.dll", SetLastError=true)] public static extern bool GetNamedPipeHandleState( int hNamedPipe, IntPtr lpState, IntPtr lpCurInstances, IntPtr lpMaxCollectionCount, IntPtr lpCollectDataTimeout, string lpUserName, uint nMaxUserNameSize); [DllImport("KERNEL32.DLL", SetLastError=true)] public static extern bool GetNamedPipeInfo( int hNamedPipe, out uint lpFlags, out uint lpOutBufferSize, out uint lpInBufferSize, out uint lpMaxInstances); [DllImport("KERNEL32.DLL", SetLastError=true)] public static extern bool PeekNamedPipe( int hNamedPipe, byte[] lpBuffer, uint nBufferSize, byte[] lpBytesRead, out uint lpTotalBytesAvail, out uint lpBytesLeftThisMessage); [DllImport("KERNEL32.DLL", SetLastError=true)] public static extern bool SetNamedPipeHandleState( int hNamedPipe, ref int lpMode, IntPtr lpMaxCollectionCount, IntPtr lpCollectDataTimeout); [DllImport("KERNEL32.DLL", SetLastError=true)] public static extern bool TransactNamedPipe( int hNamedPipe, byte [] lpInBuffer, uint nInBufferSize, [Out] byte [] lpOutBuffer, uint nOutBufferSize, IntPtr lpBytesRead, IntPtr lpOverlapped); [DllImport("kernel32.dll", SetLastError=true)] public static extern bool WaitNamedPipe( string name, uint timeout); [DllImport("kernel32.dll", SetLastError=true)] public static extern bool ReadFile( int hFile, // handle to file byte[] lpBuffer, // data buffer uint nNumberOfBytesToRead, // number of bytes to read byte[] lpNumberOfBytesRead, // number of bytes read uint lpOverlapped // overlapped buffer ); [DllImport("kernel32.dll", SetLastError=true)] public static extern bool WriteFile( int hFile, // handle to file byte[] lpBuffer, // data buffer uint nNumberOfBytesToWrite, // number of bytes to write byte[] lpNumberOfBytesWritten, // number of bytes written uint lpOverlapped // overlapped buffer ); } } // end namespace NamedPipes Now, using the interop wrappers, we can create a named pipe client class named NamedPipeClient : namespace NamedPipes { /// <summary> /// NamedPipeClient - An implementation of a synchronous, /// message-based, named pipe client /// ///</summary> public class NamedPipeClient : IDisposable { /// <summary> /// the full name of the pipe being connected to /// </summary> string _pipeName = ""; /// <summary> /// the pipe handle once connected /// </summary> int _handle = NamedPipeInterop.INVALID_HANDLE_VALUE; /// <summary> /// default response buffer size (1K) /// </summary> uint _responseBufferSize = 1024; /// <summary> /// indicates if this has been closed once which calls /// for us to re-register for finalization on subsequent /// connect calls /// </summary> bool disposedOnce = false; /// <summary> /// WriteMessageResponseDelegate - callback for when a response /// to when a WriteMessage returns from the server /// /// </summary> public delegate void WriteMessageResponseDelegate(MemoryStream responseStream); /// <summary> /// CTOR /// </summary> /// <param name="pipeName">name of the pipe</param> public NamedPipeClient(string pipeName) { _pipeName = pipeName; } /// <summary> /// Finalizer /// </summary> ~NamedPipeClient( ) { Dispose( ); } /// <summary> /// Dispose /// </summary> public void Dispose( ) { if(_handle != NamedPipeInterop.INVALID_HANDLE_VALUE) { NamedPipeInterop.CloseHandle(_handle); _handle = NamedPipeInterop.INVALID_HANDLE_VALUE; } // Suppress Finalization since we have now cleaned up our // handle System.GC.SuppressFinalize(this); // indicate we have disposed at least once if(disposedOnce == false) disposedOnce = true; } /// <summary> /// Close - because it is more intuitive than Dispose... :) /// </summary> public void Close( ) { Dispose( ); } /// <summary> /// ResponseBufferSize Property - the size used to create response buffers /// for messages written using WriteMessage /// </summary> public uint ResponseBufferSize { get { return _responseBufferSize; } set { _responseBufferSize = value; } } /// <summary> /// Connect - connect to an existing pipe /// </summary> /// <returns>true if connected</returns> public bool Connect( ) { if(disposedOnce == true) System.GC.ReRegisterForFinalize(this); if(_handle != NamedPipeInterop.INVALID_HANDLE_VALUE) throw new InvalidOperationException("Pipe is already connected!"); // keep trying to connect while (true) { // connect to existing pipe _handle = NamedPipeInterop.CreateFile(_pipeName, NamedPipeInterop.GENERIC_READ NamedPipeInterop.GENERIC_WRITE, 0, IntPtr.Zero, NamedPipeInterop.OPEN_EXISTING, 0, 0); // check to see if we connected if(_handle != NamedPipeInterop.INVALID_HANDLE_VALUE) break; // the pipe could not be opened as all instances are busy // any other error we bail for if(NamedPipeInterop.GetLastError( ) != NamedPipeInterop.ERROR_PIPE_BUSY) { Debug.WriteLine("Could not open pipe: " + _pipeName); return false; } // if it was busy, see if we can wait it out for 20 seconds if(!NamedPipeInterop.WaitNamedPipe(_pipeName, 20000)) { Debug.WriteLine("Specified pipe was over-burdened: " + _pipeName); return false; } } // indicate connection in debug Debug.WriteLine("Connected to pipe: " + _pipeName); // The pipe connected; change to message-read mode. bool success = false; int mode = (int) NamedPipeInterop.PIPE_READMODE_MESSAGE; // set to message mode success = NamedPipeInterop.SetNamedPipeHandleState( _handle, // pipe handle ref mode, // new pipe mode IntPtr.Zero, // don't set maximum bytes IntPtr.Zero); // don't set maximum time // currently implemented for just synchronous, message-based pipes, // so bail if we couldn't set the client up properly if(false == success) { Debug.WriteLine("Could not change pipe mode to message," + " shutting client down."); Dispose( ); return false; } return true; } /// <summary> /// WriteMessage - write an array of bytes and return the response from the /// server /// </summary> /// <param name="buffer">bytes to write</param> /// <param name="bytesToWrite">number of bytes to write</param> /// <param name="ResponseDelegate">callback with the message response</param> /// <returns>true if written successfully</returns> public bool WriteMessage(byte [] buffer, // the write buffer uint bytesToWrite, // number of bytes in the write buffer WriteMessageResponseDelegate ResponseDelegate) // callback for // message responses { // buffer to get the number of bytes read/written back byte[] _numReadWritten = new byte[4]; bool success = false; // Write the byte buffer to the pipe success = NamedPipeInterop.WriteFile(_handle, buffer, bytesToWrite, _numReadWritten, 0); if(true == success) { byte[] responseBuffer = new byte[_responseBufferSize]; int size = Convert.ToInt32(_responseBufferSize); MemoryStream fullBuffer = new MemoryStream(size); do { // Read the response from the pipe. success = NamedPipeInterop.ReadFile( _handle, // pipe handle responseBuffer, // buffer to receive reply _responseBufferSize, // size of buffer _numReadWritten, // number of bytes read 0); // not overlapped // failed, not just more data to come if (! success && NamedPipeInterop.GetLastError( ) != NamedPipeInterop.ERROR_MORE_DATA) break; // concat response to stream fullBuffer.Write(responseBuffer, 0, responseBuffer.Length); } while (! success); // repeat loop if ERROR_MORE_DATA // Callback the caller with this response buffer if(ResponseDelegate != null) ResponseDelegate(fullBuffer); } return success; } } } // end namespace NamedPipes Then we need to create a server class for testing, which we will call NamedPipeServer : namespace NamedPipes { /// <summary> /// NamedPipeServer - An implementation of a synchronous, message-based, /// named pipe server /// /// </summary> public class NamedPipeServer : IDisposable { /// <summary> /// the pipe handle /// </summary> int _handle = NamedPipeInterop.INVALID_HANDLE_VALUE; /// <summary> /// the name of the pipe /// </summary> string _pipeName = ""; /// <summary> /// the name of the machine the server pipe is on /// </summary> string _machineName = ""; /// <summary> /// default size of message buffer to read /// </summary> uint _receiveBufferSize = 1024; /// <summary> /// indicates if this has been closed once, which calls /// for us to re-register for finalization on subsequent /// connect calls /// </summary> bool disposedOnce = false; /// <summary> /// the internal delegate holder for the callback on message receipt /// from clients /// </summary> MessageReceivedDelegate _messageReceivedDelegate; /// <summary> /// PIPE_SERVER_BUFFER_SIZE set to 8192 by default /// </summary> const int PIPE_SERVER_BUFFER_SIZE = 8192; /// <summary> /// MessageReceivedDelegate - callback for message received from /// client /// /// </summary> public delegate void MessageReceivedDelegate(MemoryStream message, out MemoryStream response); /// <summary> /// CTOR /// </summary> /// <param name="machineName">name of the machine the pipe is on, /// use null for local machine</param> /// <param name="pipeBaseName">the base name of the pipe</param> /// <param name="msgReceivedDelegate">delegate to be notified when /// a message is received</param> public NamedPipeServer(string machineName, string pipeBaseName, MessageReceivedDelegate msgReceivedDelegate) { // hook up the delegate _messageReceivedDelegate = msgReceivedDelegate; if(machineName == null) _machineName = "."; else _machineName = machineName; // assemble the pipe name _pipeName = "\\" + _machineName + "\PIPE\" + pipeBaseName; } /// <summary> /// Finalizer /// </summary> ~NamedPipeServer( ) { Dispose( ); } /// <summary> /// Dispose - clean up handle /// </summary> public void Dispose( ) { // if we have a pipe handle, disconnect and clean up if(_handle > 0) { NamedPipeInterop.DisconnectNamedPipe(_handle); NamedPipeInterop.CloseHandle(_handle); _handle = 0; } // Suppress Finalization since we have now cleaned up our // handle System.GC.SuppressFinalize(this); // indicate we have disposed at least once if(disposedOnce == false) disposedOnce = true; } /// <summary> /// Close - because it is more intuitive than Dispose... /// </summary> public void Close( ) { Dispose( ); } /// <summary> /// PipeName /// </summary> /// <returns>the composed pipe name</returns> public string PipeName { get { return _pipeName; } } /// <summary> /// CreatePipe - create the named pipe /// </summary> /// <returns>true is pipe created</returns> public bool CreatePipe( ) { if(disposedOnce == true) System.GC.ReRegisterForFinalize(this); // make a named pipe in message mode _handle = NamedPipeInterop.CreateNamedPipe(_pipeName, NamedPipeInterop.PIPE_ACCESS_DUPLEX, NamedPipeInterop.PIPE_TYPE_MESSAGE NamedPipeInterop.PIPE_READMODE_MESSAGE NamedPipeInterop.PIPE_WAIT, NamedPipeInterop.PIPE_UNLIMITED_INSTANCES, PIPE_SERVER_BUFFER_SIZE, PIPE_SERVER_BUFFER_SIZE, NamedPipeInterop.NMPWAIT_WAIT_FOREVER, IntPtr.Zero); // make sure we got a good one if (_handle == NamedPipeInterop.INVALID_HANDLE_VALUE) { Debug.WriteLine("Could not create the pipe (" + _pipeName + ") - os returned " + NamedPipeInterop.GetLastError( )); return false; } return true; } /// <summary> /// WaitForClientConnect - wait for a client to connect to this pipe /// </summary> /// <returns>true if connected, false if timed out</returns> public bool WaitForClientConnect( ) { bool success = false; // wait for someone to talk to us success = NamedPipeInterop.ConnectNamedPipe(_handle,IntPtr.Zero); if(true == success) { // process the first message while ( WaitForMessage( ) ); } return success; } /// <summary> /// WaitForMessage - have the server wait for a message /// </summary> /// <returns>true if got a message, false if timed out</returns> public bool WaitForMessage( ) { bool success = false; // they want to talk to us, read their messages and write // replies int size = Convert.ToInt32(_receiveBufferSize); MemoryStream fullMessageStream = new MemoryStream(size); byte [] buffer = new byte[_receiveBufferSize]; byte [] _numReadWritten = new byte[4]; // need to read the whole message and put it in one message // byte buffer do { // Read the response from the pipe. success = NamedPipeInterop.ReadFile( _handle, // pipe handle buffer, // buffer to receive reply _receiveBufferSize, // size of buffer _numReadWritten, // number of bytes read 0); // not overlapped // failed, not just more data to come if (! success && (NamedPipeInterop.GetLastError( ) != NamedPipeInterop.ERROR_MORE_DATA)) break; // concat the message bytes to the stream fullMessageStream.Write(buffer,0,buffer.Length); } while (! success); // repeat loop if ERROR_MORE_DATA // we read a message from a client if(true == success) { // call delegate if connected for message processing MemoryStream responseStream; if(_messageReceivedDelegate != null) { // call delegate _messageReceivedDelegate(fullMessageStream, out responseStream); if(responseStream != null) { // get raw byte array from stream byte [] responseBytes = responseStream.ToArray( ); uint len = Convert.ToUInt32(responseBytes.Length); // write the response message provided // by the delegate NamedPipeInterop.WriteFile(_handle, responseBytes, len, _numReadWritten, 0); } } } return success; } } } // end namespace NamedPipes In order to use the NamedPipeClient class, we need some code like the following: using System; using System.Diagnostics; using System.Text; using System.IO; namespace NamedPipes { class NamedPipesClientTest { static void Main(string[] args) { // create our pipe client NamedPipeClient _pc = new NamedPipeClient("\\.\PIPE\mypipe"); if(_pc != null) { // connect to the server if(true == _pc.Connect( )) { // set up a dummy message string testString = "This is my message!"; UnicodeEncoding UEncoder = new UnicodeEncoding( ); // turn it into a byte array byte[] writebuffer = UEncoder.GetBytes(testString); uint len = Convert.ToUInt32(writebuffer.Length); // write the message ten times for(int i=0;i<10;i++) { if(false == _pc.WriteMessage(writebuffer, len, new NamedPipeClient.WriteMessageResponseDelegate(WriteMessageResponse))) { Debug.Assert(false, "Failed to write message!"); } } // close up shop _pc.Close( ); } } Console.WriteLine("Press Enter to exit..."); Console.ReadLine( ); } static void WriteMessageResponse(MemoryStream responseStream) { UnicodeEncoding UEncoder = new UnicodeEncoding( ); string response = UEncoder.GetString(responseStream.ToArray( )); Console.WriteLine("Received response: {0}",response); } } } Then, to set up a server for the client to talk to, we would use the NamedPipeServer class, like this: namespace NamedPipes { class NamedPipesServerTest { // // MessageReceived - This is the method used in the delegate for the server // that gets called after every message is received and before it is replied to // static void MessageReceived(MemoryStream message,out MemoryStream response) { // get the bytes of the message from the stream byte [] msgBytes = message.ToArray( ); string messageText; // I know in the client I used Unicode encoding for the string to // turn it into a series of bytes for transmission so just reverse that UnicodeEncoding UEncoder = new UnicodeEncoding( ); messageText = UEncoder.GetString(msgBytes); // write out our string message from the client Console.WriteLine(messageText); // now set up response with a polite response using the same // Unicode string protocol string reply = "Thanks for the message!"; msgBytes = UEncoder.GetBytes(reply); response = new MemoryStream(msgBytes,0,msgBytes.Length); } // // Main - nuff said // static void Main(string[] args) { // create pipe server NamedPipeServer _ps = new NamedPipeServer(null, "mypipe", new NamedPipeServer.MessageReceivedDelegate(MessageReceived) ); // create pipe if(true == _ps.CreatePipe( )) { // I get the name of the pipe here just to show you can. // Normally we would then have to get this name to the client // so it knows the name of the pipe to open but hey, I wrote // the client too so for now I'm just hard-coding it in the // client so we can ignore it :) string pipeName = _ps.PipeName( ); // wait for clients to connect and process the first message if(true == _ps.WaitForClientConnect( )) { // process messages until the read fails // (client goes away...) bool success = true; while(success) { success = _ps.WaitForMessage( ); } } // done; bail and clean up the server _ps.Close( ); } // make our server hang around so you can see the messages sent Console.WriteLine("Press Enter to exit..."); Console.ReadLine( ); } } } DiscussionNamed pipes are a mechanism to allow interprocess or intermachine communications in Windows. As of v1.1, the .NET Framework has not provided managed access to named pipes, so the first thing we need to do is to wrap the functions in Kernel32.dll for direct access from managed code in our NamedPipesInterop class. Once we have this foundation, we can then build a client for using named pipes to talk to a server, exposing a pipe that we did in the NamedPipeClient class. The methods on the NamedPipeClient are listed here with a description:
We then create the NamedPipeServer class to be able to have something for the NamedPipeClient to connect to. The methods on the NamedPipeServer are listed here with a description as well:
Finally we created some code to use NamedPipeClient and NamedPipeServer . The interaction between these two goes like this:
See AlsoSee the "Named Pipes," "DllImport Attribute," "IDisposable Interface," and "GC.SuppressFinalize Method" topics in the MSDN documentation . |
C# 3.0 Cookbook
ISBN: 059651610X
EAN: 2147483647
EAN: 2147483647
Year: 2003
Pages: 315
Pages: 315
Authors: Jay Hilyard, Stephen Teilhet