क्या आप एक नामांकित पाइप क्लाइंट के साथ पढ़ और लिख सकते हैं?

Question

मैंने एक छोटा सा ऐप्लिकेशन लिखा है जो एक नामित पाइप सर्वर और एक क्लाइंट बनाता है जो उससे जुड़ता है। आप सर्वर पर डेटा भेज सकते हैं, और सर्वर इसे सफलतापूर्वक पढ़ता है।

अगली चीज़ जो मुझे करने की ज़रूरत है उसे सर्वर से संदेश प्राप्त होते हैं, इसलिए मेरे पास एक और धागा है जो आने वाले डेटा के लिए स्पॉन्स और बैठता है और इंतजार करता है।

समस्या यह है कि जब थ्रेड आने वाले डेटा की प्रतीक्षा कर रहा है, तो आप सर्वर पर संदेश नहीं भेज सकते क्योंकि यह WriteLine कॉल पर लटका हुआ है क्योंकि मुझे लगता है कि पाइप अब डेटा की जांच कर रहा है।

तो क्या यह ठीक है कि मैं इसे ठीक से नहीं देख रहा हूं? या नामित पाइप नामक इस तरह इस्तेमाल नहीं किया जा रहा है? नामित पाइप पर मैंने जो उदाहरण देखे हैं, वे केवल एक ही तरीके से जाते हैं, एक क्लाइंट भेजता है और एक सर्वर प्राप्त करता है, हालांकि आप In, Out या दोनों के रूप में पाइप की दिशा निर्दिष्ट कर सकते हैं।

कोई भी मदद, पॉइंटर्स या सुझावों की सराहना की जाएगी!

यहाँ 'कोड अब तक:

// 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

आप एक धागे से नहीं पढ़ सकते हैं और एक ही पाइप वस्तु के लिए एक और धागा पर लिखें। इसलिए जब आप एक प्रोटोकॉल बना सकते हैं जहां आप जो डेटा भेज रहे हैं उसके आधार पर सुनने की स्थिति बदलती है, तो आप एक ही समय में दोनों नहीं कर सकते हैं। ऐसा करने के लिए आपको दोनों तरफ एक ग्राहक और सर्वर पाइप की आवश्यकता होगी।