C# Socket TCP 发送，消息获取 "stuck"

Question

这有点奇怪，如果我没有很好地解释它，我们深表歉意。

我正在使用以下简单代码发送我从队列中弹出的消息，使用简单的 TCP 套接字，消息通过本地主机发送到同一台机器上的另一个端口 -

try
{
    Socket.Select(null, writeList, null, 120000000/*120 seconds*/);
}
catch (SocketException e)
{
    log.Error("Select returned an error waiting to send... " + e.Message + " Errorcode: " + e.ErrorCode);
    connected = false;
    socket.Close();
}

bool readyToWrite = false;
for (int i = 0; i < writeList.Count; i++)
{
    readyToWrite = true;
}

if (readyToWrite)
{
    try
    {
        //log.Debug("Sending message type: " + message.header.msgType);
        socket.Send(message, message.header.dataLength, SocketFlags.None);                        
        //log.Debug("Message sent");
    }
    catch (SocketException e)
    {
        log.Error(e.Message + " Error code: " + e.ErrorCode);
        connected = false;
        socket.Close();                        
    }

}
else
{
    log.Error("Not able to write - stopping sender thread and closing socket");
    connected = false;
    socket.Close();
}

这通常工作正常，事实上我的应用程序最初向另一端发送多条消息没有问题。

但是，我随后将 10 条左右的消息快速连续地添加到队列中，这些消息被弹出并发送正常，看起来 - 日志语句显示 Send() 返回正常，当我查看网络跟踪时，它似乎是另一个end 已经承认了他们。

但事实并非如此。另一端在一个循环中调用 select() ，超时一秒，这一直没有数据可读，直到大约 30 秒后(每次都相同)，所有消息同时到达另一端.

来自连接另一端的 C++ 代码 -

while (m_bRunning && bOK && !bReadyToRead)
{
    m_bIsAlive = true;

    switch(pSocket->Select(1, true))
    {
    case 1:     // Ready to read
        //TRACE("Data ready to be read from RAM\n");
        bReadyToRead = true;
        break;

    case 0:     // Select timed out
        if (GetTickCount() > dwTimeout)
        {
            bOK = false;
        }
        // else No action needed
        break;

        default:    // Error detected
            TRACE("Select returned error...\n");
            bOK = false;
            break;
    }
}

// Try and read a message header
iBytesExpected = sizeof(RAM_HEADER);    

while ((m_bRunning && bOK) && (iBytesSoFar < iBytesExpected))
{
    m_bIsAlive = true;

    iBytesRead = pSocket->Read(pWritePos, iBytesExpected-iBytesSoFar);

C++ 选择包装器看起来像这样 -

int CRawSocket::Select(ULONG ulTimeoutSeconds, bool bCheckRead)
{
    int iResult = -1;           // Error by default
    int iSelectReturn = 0;
    fd_set readSet;
    fd_set writeSet;
    struct timeval timeout;

    timeout.tv_sec = ulTimeoutSeconds;
    timeout.tv_usec = 0;

    FD_ZERO(&readSet);
    FD_ZERO(&writeSet);

    if (bCheckRead)
    {
        FD_SET(m_hSocket, &readSet);
        iSelectReturn = select(1, &readSet, NULL, NULL, &timeout);
    }
    else
    {
        FD_SET(m_hSocket, &writeSet);
        iSelectReturn = select(1, NULL, &writeSet, NULL, &timeout);
    }

    if(iSelectReturn != SOCKET_ERROR)
    {
        if (FD_ISSET(m_hSocket, &readSet))
        {
            iResult = 1;        // Ready to READ
        }
        else if (FD_ISSET(m_hSocket, &writeSet))
        {
            iResult = 2;        // Ready to WRITE
        }
        else
        {
            iResult = 0;        // Select TIMED OUT
        }
    }
    else 
    {
        const int e = WSAGetLastError();
        ERRORLOG("Select socket error %lu\n", e);
        iResult = -1;           // Some error occurred
    }

    return iResult;
}

还有读取方法-

int CReadWriteSocket::Read(void *pData, int nLen) 
{
    char* pcData = (char* )pData;
    int n = nLen;
    // if data size is bigger then network buffer
    // handle it nice
    do
    {
        int r1 = ::recv (m_hSocket, pcData, n, 0);
        if (r1 == SOCKET_ERROR)
        {
            int e = WSAGetLastError();
            if (e == WSAEWOULDBLOCK)
            {
                return nLen - n;
            }
            else
            {
                TRACE("Socket Read error %d\n", e);
                return -1;      // error other than would block detected
            }
        }
        else if (r1 == 0)       // Connection has closed
        {
            TRACE("Socket appears to have closed (zero bytes read)\n");
            return -1;          // Show this as an "error"
        }
        else if (r1 < 0)
        {
            ASSERT(0);
            return nLen - n;
        }

        pcData += r1;
        n -= r1;
    } while (n > 0);

    ASSERT(n == 0);
    return nLen;
}

我完全糊涂了，因为这似乎是我到处都在使用的标准代码，而且我从未见过这样的问题。

有人建议尝试 NoDelay 套接字选项，但这没有效果 - 事实上，据我所知，这永远不会导致这种长度的延迟。

如有任何建议，我们将不胜感激!谢谢。

Answer 1

TCP 是一种流协议(protocol)。您不能假设您 Send() 的“数据包”将完好无损地交付和接收。在传输端，Nagle 算法尝试组合在单独的 Send() 调用中写入的数据，以优化数据的传递。在接收端，您将读取()存储在 TCP 缓冲区中的内容。如果有任何延迟，它将是传输数据包的组合。发送器和接收器之间的路由器使这变得更加复杂，它们允许对 IP 数据包进行分段，将一个大数据包变成多个小数据包，以适应传输 channel 的最大数据包大小 (MTU)。

换句话说，没有可靠的方法来确保数据包按照它们发送的方式进行传递。一个简单的解决方法是首先传输数据包的大小。在接收端，您首先读取该大小，然后知道如何计算接收到的字节以重建数据包。