मुझे लगता है कि एक नामित पाइप 101 अंक है। मेरे पास सी ++ अप्रबंधित ऐप से सी # प्रबंधित ऐप में प्रेषित एक सरल नामित पाइप कनेक्ट करने के लिए एक बहुत ही सरल सेट अप है। पाइप जोड़ता है, लेकिन मैं पाइप के माध्यम से एक "संदेश" नहीं भेज सकता जब तक कि मैं बफर को फ्लश करने के लिए दिखाई देने वाले हैंडल को बंद करता हूं और संदेश को पास करता हूं। ऐसा लगता है कि संदेश अवरुद्ध है। मैंने क्लाइंट/सर्वर की भूमिकाओं को उलटाने और बिना किसी भाग्य के विभिन्न ध्वज संयोजनों के साथ उन्हें आमंत्रित करने का प्रयास किया है। मैं आसानी से सी # से प्रबंधित सी ++ अप्रबंधित से दूसरी दिशा में संदेश भेज सकता हूं। क्या किसी के पास कोई अंतर्दृष्टि है। क्या आप में से कोई भी सफलतापूर्वक C++ से संदेशों को सफलतापूर्वक सी # प्रबंधित करने के लिए संदेश भेज सकता है? मुझे अंतरंग या अप्रबंधित पाइप के बहुत सारे उदाहरण मिल सकते हैं लेकिन असंगत से/से प्रबंधित नहीं किया गया - केवल दावा करने में सक्षम होने का दावा है।आप नामांकित पाइप स्ट्रिंग को umnanaged से प्रबंधित कोड स्थान से कैसे भेजते हैं?
लिस्टिंग में, मैंने स्पष्टता के लिए अधिकांश रैपर सामग्री छोड़ी है। मुख्य बिट्स जो मुझे विश्वास है कि वे प्रासंगिक हैं पाइप कनेक्शन/निर्माण/पढ़ना और लिखने के तरीके हैं। यहां अवरुद्ध/थ्रेडिंग के बारे में ज्यादा चिंता न करें।
सी # सर्वर साइड
// This runs in its own thread and so it is OK to block
private void ConnectToClient()
{
// This server will listen to the sending client
if (m_InPipeStream == null)
{
m_InPipeStream =
new NamedPipeServerStream("TestPipe", PipeDirection.In, 1);
}
// Wait for client to connect to our server
m_InPipeStream.WaitForConnection();
// Verify client is running
if (!m_InPipeStream.IsConnected)
{
return;
}
// Start listening for messages on the client stream
if (m_InPipeStream != null && m_InPipeStream.CanRead)
{
ReadThread = new Thread(new ParameterizedThreadStart(Read));
ReadThread.Start(m_InPipeStream);
}
}
// This runs in its own thread and so it is OK to block
private void Read(object serverObj)
{
NamedPipeServerStream pipeStream = (NamedPipeServerStream)serverObj;
using (StreamReader sr = new StreamReader(pipeStream))
{
while (true)
{
string buffer = "" ;
try
{
// Blocks here until the handle is closed by the client-side!!
buffer = sr.ReadLine(); // <<<<<<<<<<<<<< Sticks here
}
catch
{
// Read error
break;
}
// Client has disconnected?
if (buffer == null || buffer.Length == 0)
break;
// Fire message received event if message is non-empty
if (MessageReceived != null && buffer != "")
{
MessageReceived(buffer);
}
}
}
}
सी ++ ग्राहक के पक्ष
// Static - running in its own thread.
DWORD CNamedPipe::ListenForServer(LPVOID arg)
{
// The calling app (this) is passed as the parameter
CNamedPipe* app = (CNamedPipe*)arg;
// Out-Pipe: connect as a client to a waiting server
app->m_hOutPipeHandle =
CreateFile("\\\\.\\pipe\\TestPipe",
GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
// Could not create handle
if (app->m_hInPipeHandle == NULL ||
app->m_hInPipeHandle == INVALID_HANDLE_VALUE)
{
return 1;
}
return 0;
}
// Sends a message to the server
BOOL CNamedPipe::SendMessage(CString message)
{
DWORD dwSent;
if (m_hOutPipeHandle == NULL ||
m_hOutPipeHandle == INVALID_HANDLE_VALUE)
{
return FALSE;
}
else
{
BOOL bOK =
WriteFile(m_hOutPipeHandle,
message, message.GetLength()+1, &dwSent, NULL);
//FlushFileBuffers(m_hOutPipeHandle); // <<<<<<< Tried this
return (!bOK || (message.GetLength()+1) != dwSent) ? FALSE : TRUE;
}
}
// Somewhere in the Windows C++/MFC code...
...
// This write is non-blocking. It just passes through having loaded the pipe.
m_pNamedPipe->SendMessage("Hi de hi");
...
यही वह है! यह सब अब काम करता है, बहुत धन्यवाद। मैं पूरी तरह से नई लाइन की आवश्यकता को भूल गया, मैं पाइप (परत -1) के मैकेनिक्स पर भी ध्यान केंद्रित कर रहा था, मैं संदेश प्रारूप (परत -2) के बारे में भूल गया था। – user320240