Comunicazione bidirezionale asincrona con Windows Named Pipes (.Net)

Question

Ho un servizio Windows e una GUI che devono comunicare tra loro. Entrambi possono inviare messaggi in qualsiasi momento.

Sto cercando di usare NamedPipes, ma sembra che non si possa leggere nello stream lo & (o almeno non riesco a trovare esempi che riguardino questo caso).

È possibile eseguire questo tipo di comunicazione a due vie tramite un singolo NamedPipe? O devo aprire due tubi (uno dal servizio GUI-> e uno dal servizio-> GUI)?

Answer 1

Utilizzando WCF è possibile utilizzare duplex named pipe

// Create a contract that can be used as a callback 
public interface IMyCallbackService 
{ 
    [OperationContract(IsOneWay = true)] 
    void NotifyClient(); 
} 

// Define your service contract and specify the callback contract 
[ServiceContract(CallbackContract = typeof(IMyCallbackService))] 
public interface ISimpleService 
{ 
    [OperationContract] 
    string ProcessData(); 
} 

implementare il servizio

[ServiceBehavior(InstanceContextMode=InstanceContextMode.PerCall)] 
public class SimpleService : ISimpleService 
{ 
    public string ProcessData() 
    { 
     // Get a handle to the call back channel 
     var callback = OperationContext.Current.GetCallbackChannel<IMyCallbackService>(); 

     callback.NotifyClient(); 
     return DateTime.Now.ToString(); 
    } 
} 

ospitare il servizio

class Server 
{ 
    static void Main(string[] args) 
    { 
     // Create a service host with an named pipe endpoint 
     using (var host = new ServiceHost(typeof(SimpleService), new Uri("net.pipe://localhost"))) 
     { 
      host.AddServiceEndpoint(typeof(ISimpleService), new NetNamedPipeBinding(), "SimpleService"); 
      host.Open(); 

      Console.WriteLine("Simple Service Running..."); 
      Console.ReadLine(); 

      host.Close(); 
     } 
    } 
} 

Creare l'applicazione client, in questo esempio la classe Client implementa il contratto di richiamata.

class Client : IMyCallbackService 
{ 
    static void Main(string[] args) 
    { 
     new Client().Run(); 
    } 

    public void Run() 
    { 
     // Consume the service 
     var factory = new DuplexChannelFactory<ISimpleService>(new InstanceContext(this), new NetNamedPipeBinding(), new EndpointAddress("net.pipe://localhost/SimpleService")); 
     var proxy = factory.CreateChannel(); 

     Console.WriteLine(proxy.ProcessData()); 
    } 

    public void NotifyClient() 
    { 
     Console.WriteLine("Notification from Server"); 
    } 
} 

Answer 2

Le classi di flusso di pipe denominate (server o client) devono essere create con PipeDirection di InOut. È necessario un NamedPipeServerStream, probabilmente nel tuo servizio, che può essere condiviso da un numero arbitrario di oggetti NamedPipeClientStream. Costruisci NamedPipeServerStream con il nome della pipe e la direzione, e NamedPipeClientStream con il nome della pipe, il nome del server e la PipeDirection, e dovresti essere a posto.

Answer 3

L'utilizzo di un singolo punto per accumulare messaggi (un singolo tubo in questo caso) obbliga anche a gestire la direzione del messaggio (oltre a ciò è necessario utilizzare un blocco a livello di sistema per il tubo).

Quindi utilizzare 2 tubi con direzioni opposte.

(Un'altra opzione potrebbe utilizzare 2 code MSMQ).