PipeClient Constructor

Summary

Initializes a new instance of PipeClient.

Syntax

C++/CLI

public PipeClient( 
   string pipeName 
)

public:  
   PipeClient(String^ pipeName)

Parameters

pipeName

The name for the named pipe that will be used for inter-process communication.

Remarks

The pipeName must be the same for both the PipeServer and PipeClient constructors.

Example

using Leadtools.Dicom.AddIn; 
using Leadtools.Dicom.AddIn.Common; 
using Leadtools.Dicom.Common.Extensions; 
 
///  
// This example shows how a client and server can communicate using a named pipe 
public static class PipeServerExample 
{ 
 
   static AutoResetEvent clientFinishedEvent = new AutoResetEvent(false); 
   static AutoResetEvent serverFinishedEvent = new AutoResetEvent(false); 
   private static void Client_ReceivedMessage(object sender, ReceivedMessageEventArgs e) 
   { 
      if (e.Message != null && e.Message.Length > 0) 
      { 
         ServiceMessage serviceMessage = AddInUtils.BinaryDeSerialize<ServiceMessage>(e.Message); 
         string msg = $"Client received message: Service[{serviceMessage.Service}]: {serviceMessage.Message}"; 
         Console.WriteLine(msg); 
      } 
      clientFinishedEvent.Set(); 
   } 
 
   private static void Server_ReceivedMessage(object sender, Leadtools.Dicom.AddIn.Common.ReceivedMessageEventArgs e) 
   { 
      if (e.Message != null && e.Message.Length > 0) 
      { 
         ServiceMessage serviceMessage = AddInUtils.BinaryDeSerialize<ServiceMessage>(e.Message); 
         string msg = $"Server received message: Service[{serviceMessage.Service}]: {serviceMessage.Message}"; 
         Console.WriteLine(msg); 
 
         PipeServer pipeServer = sender as PipeServer; 
         if (pipeServer != null) 
         { 
            ServiceMessage serverServiceMessage = new ServiceMessage(); 
            serverServiceMessage.Service = "MyServiceName"; 
            serverServiceMessage.Message = "MyServerMessage"; 
            Console.WriteLine($"Server sending message: {serverServiceMessage.Message}"); 
            pipeServer.SendMessage(serverServiceMessage); 
         } 
      } 
      serverFinishedEvent.Set(); 
   } 
 
   private static void Server_ReadFromPipeExceptionEvent(object sender, ReadFromPipeExceptionEventArgs e) 
   { 
      Console.WriteLine(e.ReadPipeException.Message); 
   } 
 
   public static void RunClient(string pipeName) 
   { 
      PipeClient client = new PipeClient(pipeName); 
      client.ReceivedMessage += Client_ReceivedMessage; 
      client.Start(); 
      string clientMessage = "MyClientMessage"; 
      Console.WriteLine($"Client sending message: {clientMessage}"); 
      client.SendMessage(clientMessage); 
      clientFinishedEvent.WaitOne(); 
   } 
 
   public static void RunServer(string pipeName) 
   { 
      PipeServer server = new PipeServer(pipeName, 10); 
      server.ReadFromPipeExceptionEvent += Server_ReadFromPipeExceptionEvent; 
      server.ReceivedMessage += Server_ReceivedMessage; 
      server.Start(); 
      serverFinishedEvent.WaitOne(); 
   } 
 
   public static void PipeServerSample() 
   { 
      // For simplicity, this example runs two threads that communicate using a named pipe. 
      // However, the client and server can also communicate when running in different processes. 
      string pipeName = "MyPipeName"; 
 
      Task taskServer = Task.Run(() => RunServer(pipeName)); 
      Task taskClient = Task.Run(() => RunClient(pipeName)); 
 
      Task[] tasks = { taskServer, taskClient }; 
 
      Task.WaitAll(tasks); 
   }

Requirements

Target Platforms