È possibile leggere e scrivere con un singolo client Named Pipe?

Question

Ho scritto una piccola applicazione che crea un server pipe con nome e un client che si connette ad esso. È possibile inviare dati al server e il server lo legge correttamente.

La prossima cosa che devo fare è ricevere messaggi dal server, quindi ho un altro thread che si genera e si siede e attende i dati in entrata.

Il problema è che, mentre il filo è seduto in attesa dei dati in arrivo, non è più possibile inviare messaggi al server come si blocca sulla chiamata WriteLine come presumo il tubo viene ora legato il controllo per i dati.

Quindi è solo che non mi sto avvicinando correttamente? O le named pipe non sono pensate per essere usate in questo modo? Gli esempi che ho visto sui pipe denominati sembrano andare solo in un modo, un client invia e un server riceve, sebbene sia possibile specificare la direzione di una pipe come In, Out o entrambi.

Qualsiasi aiuto, suggerimento o suggerimento sarebbe apprezzato!

Heres' il codice finora:

// Variable declarations 
NamedPipeClientStream pipeClient; 
StreamWriter swClient; 
Thread messageReadThread; 
bool listeningStopRequested = false; 

// Client connect 
public void Connect(string pipeName, string serverName = ".") 
{ 
    if (pipeClient == null) 
    { 
     pipeClient = new NamedPipeClientStream(serverName, pipeName, PipeDirection.InOut); 
     pipeClient.Connect(); 
     swClient = new StreamWriter(pipeClient); 
     swClient.AutoFlush = true; 
    } 

    StartServerThread(); 
} 

// Client send message 
public void SendMessage(string msg) 
{ 
    if (swClient != null && pipeClient != null && pipeClient.IsConnected) 
    { 
     swClient.WriteLine(msg); 
     BeginListening(); 
    } 
} 


// Client wait for incoming data 
public void StartServerThread() 
{ 
    listeningStopRequested = false; 
    messageReadThread = new Thread(new ThreadStart(BeginListening)); 
    messageReadThread.IsBackground = true; 
    messageReadThread.Start(); 
} 

public void BeginListening() 
{ 
    string currentAction = "waiting for incoming messages"; 

    try 
    { 
     using (StreamReader sr = new StreamReader(pipeClient)) 
     { 
      while (!listeningStopRequested && pipeClient.IsConnected) 
      { 
       string line; 
       while ((line = sr.ReadLine()) != null) 
       { 
        RaiseNewMessageEvent(line); 
        LogInfo("Message received: {0}", line); 
       } 
      } 
     } 

     LogInfo("Client disconnected"); 

     RaiseDisconnectedEvent("Manual disconnection"); 
    } 
    // Catch the IOException that is raised if the pipe is 
    // broken or disconnected. 
    catch (IOException e) 
    { 
     string error = "Connection terminated unexpectedly: " + e.Message; 
     LogError(currentAction, error); 
     RaiseDisconnectedEvent(error); 
    } 
} 

Answer 1

non può leggere da un filo e scrivere su un altro thread all'oggetto stesso tubo. Pertanto, mentre è possibile creare un protocollo in cui la posizione di ascolto cambia in base ai dati inviati, non è possibile eseguirli entrambi contemporaneamente. Per fare ciò è necessario un tubo client e server su entrambi i lati.