双工命名管道挂起在某个写

我有一个c++管道服务器应用程序和一个c#管道客户端应用程序通过Windows命名的管道通信(双工，消息模式，等待/阻塞在单独的读线程)。

这一切都工作得很好(通过管道发送和接收数据)，直到我尝试从客户端写入管道以响应表单的'textchanged'事件。当我这样做时，客户端挂起管道写调用(如果自动刷新关闭，则挂起管道刷新调用)。闯入服务器应用程序，发现它也在等待管道ReadFile调用，并且没有返回。我尝试在另一个线程上运行客户端写入，结果相同。

怀疑某种死锁或竞争条件，但无法看到在哪里…我不认为我在同时向管道写东西。

Update1:在字节模式而不是消息模式下尝试管道-相同的锁定。

Update2:奇怪的是，如果(且仅当)我从服务器泵送大量数据到客户端，它治愈锁定!?

服务器代码:

DWORD ReadMsg(char* aBuff, int aBuffLen, int& aBytesRead)
{
    DWORD byteCount;
    if (ReadFile(mPipe, aBuff, aBuffLen, &byteCount, NULL))
    {
        aBytesRead = (int)byteCount;
        aBuff[byteCount] = 0;
        return ERROR_SUCCESS;
    }
    return GetLastError();  
}
DWORD SendMsg(const char* aBuff, unsigned int aBuffLen)
{
    DWORD byteCount;
    if (WriteFile(mPipe, aBuff, aBuffLen, &byteCount, NULL))
    {
        return ERROR_SUCCESS;
    }
    mClientConnected = false;
    return GetLastError();  
}
DWORD CommsThread()
{
    while (1)
    {
        std::string fullPipeName = std::string("\\.\pipe\") + mPipeName;
        mPipe = CreateNamedPipeA(fullPipeName.c_str(),
                                PIPE_ACCESS_DUPLEX,
                                PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
                                PIPE_UNLIMITED_INSTANCES,
                                KTxBuffSize, // output buffer size
                                KRxBuffSize, // input buffer size
                                5000, // client time-out ms
                                NULL); // no security attribute 
        if (mPipe == INVALID_HANDLE_VALUE)
            return 1;
        mClientConnected = ConnectNamedPipe(mPipe, NULL) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);
        if (!mClientConnected)
            return 1;
        char rxBuff[KRxBuffSize+1];
        DWORD error=0;
        while (mClientConnected)
        {
            Sleep(1);
            int bytesRead = 0;
            error = ReadMsg(rxBuff, KRxBuffSize, bytesRead);
            if (error == ERROR_SUCCESS)
            {
                rxBuff[bytesRead] = 0;  // terminate string.
                if (mMsgCallback && bytesRead>0)
                    mMsgCallback(rxBuff, bytesRead, mCallbackContext);
            }
            else
            {
                mClientConnected = false;
            }
        }
        Close();
        Sleep(1000);
    }
    return 0;
}

客户机代码:

public void Start(string aPipeName)
{
    mPipeName = aPipeName;
    mPipeStream = new NamedPipeClientStream(".", mPipeName, PipeDirection.InOut, PipeOptions.None);
    Console.Write("Attempting to connect to pipe...");
    mPipeStream.Connect();
    Console.WriteLine("Connected to pipe '{0}' ({1} server instances open)", mPipeName, mPipeStream.NumberOfServerInstances);
    mPipeStream.ReadMode = PipeTransmissionMode.Message;
    mPipeWriter = new StreamWriter(mPipeStream);
    mPipeWriter.AutoFlush = true;
    mReadThread = new Thread(new ThreadStart(ReadThread));
    mReadThread.IsBackground = true;
    mReadThread.Start();
    if (mConnectionEventCallback != null)
    {
        mConnectionEventCallback(true);
    }
}
private void ReadThread()
{
    byte[] buffer = new byte[1024 * 400];
    while (true)
    {
        int len = 0;
        do
        {
            len += mPipeStream.Read(buffer, len, buffer.Length);
        } while (len>0 && !mPipeStream.IsMessageComplete);
        if (len==0)
        {
            OnPipeBroken();
            return;
        }
        if (mMessageCallback != null)
        {
            mMessageCallback(buffer, len);
        }
        Thread.Sleep(1);
    }
}
public void Write(string aMsg)
{
    try
    {
        mPipeWriter.Write(aMsg);
        mPipeWriter.Flush();
    }
    catch (Exception)
    {
        OnPipeBroken();
    }
}

do
{
    len += mPipeStream.Read(buffer, len, buffer.Length);
} while (len>0 && !mPipeStream.IsMessageComplete);