C＃TCP客户端发送但不接收消息

Question

I inherited some code for a TCP client. It sends a message, then when complete waits for a confirmation message. Currently it sends the message, but when it waits for the reply message it never receives it. The SendMessage() method is what is called externally.

I set breakpoints and can see it hits the Receive() method, but never the ReceiveCallback()

Any help or nudge in the right direction is appreciated.

public class SocketService
{
    private ManualResetEvent connectDone = new ManualResetEvent(false);
    private ManualResetEvent sendDone = new ManualResetEvent(false);
    private ManualResetEvent receiveDone = new ManualResetEvent(false);

    string ipAddress;
    private int portNum;
    string returnMessage;
    // private string hostName = Dns.GetHostName ();

    public SocketService(string ipAddress, int portNum)
    {
        this.ipAddress = ipAddress;
        this.portNum = portNum;
    }

    public event Logging OnLogging;

    private void WriteLogMessage(string message)
    {
        if (this.OnLogging != null)
            this.OnLogging(message);
    }

    //char endOfLineSeparator = (char) 0x1C;
    //char cr = (char) 0x0D;
    //char vt = (char) 0x0B;

    public string SendMessage(string message)
    {
        IPAddress ip = IPAddress.Parse(this.ipAddress);
        IPEndPoint remoteEP = new IPEndPoint(ip, portNum);

        connectDone.Reset();

        Socket client = new Socket(AddressFamily.InterNetwork,
                                    SocketType.Stream,
                                    ProtocolType.Tcp);

        client.BeginConnect(remoteEP,
                            new AsyncCallback(ConnectCallback),
                            client);

        connectDone.WaitOne();

        //sendDone.Reset();

        WriteLogMessage("send message");

        Send(client, message);
        sendDone.WaitOne();

        //receiveDone.Reset();

        WriteLogMessage("receive message");

        Receive(client);
        receiveDone.WaitOne();

        client.Shutdown(SocketShutdown.Both);
        client.Close();

        return this.returnMessage;
    }

    private void Send(Socket client, String data)
    {
        byte[] byteData = Encoding.ASCII.GetBytes(data);

        client.BeginSend(byteData,
                        0,
                        byteData.Length,
                        0,
                        new AsyncCallback(SendCallback),
                        client);
    }

    private void SendCallback(IAsyncResult ar)
    {
        Socket client = (Socket)ar.AsyncState;

        int bytesSent = client.EndSend(ar);

        sendDone.Set();
    }

    private void ConnectCallback(IAsyncResult ar)
    {
        Socket client = (Socket)ar.AsyncState;

        client.EndConnect(ar);

        connectDone.Set();
    }

    private void Receive(Socket client)
    {
        StateObject state = new StateObject(client);

        client.BeginReceive(state.Buffer,
                            0,
                            StateObject.BufferSize,
                            0,
                            new AsyncCallback(ReceiveCallback),
                            state);
    }

    private void ReceiveCallback(IAsyncResult ar)
    {
        StateObject state = (StateObject)ar.AsyncState;
        Socket client = state.WorkSocket;

        int bytesRead = client.EndReceive(ar);

        if (bytesRead > 0)
        {
            state.StoredContent.Append(Encoding.ASCII.GetString(state.Buffer, 0, bytesRead));

            client.BeginReceive(state.Buffer,
                                0,
                                StateObject.BufferSize,
                                0,
                                new AsyncCallback(ReceiveCallback),
                                state);

            WriteLogMessage(state.StoredContent.ToString());
        }
        else
        {
            this.returnMessage = state.StoredContent.ToString();

            receiveDone.Set();
        }
    }
}

Answer 1

Your SendMessage and Receive functions don't actually to anything. They just send and receive bytes. They have no notion of a "message", do not mark the end of messages when sending them, nor recognize the ends of messages when receiving them. Simply put, you forgot to implement a network protocol and are assuming that TCP is a message service when it is actually a byte stream service.

If you need to send and receive messages, you have to precisely define what a "message" is and write code to send and receive them. It won't work by magic.

Answer 2

As David Schwartz pointed out, you need a way of delimiting messages.

Take a look how WebSocket data is framed .

0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len |    Extended payload length    |
|I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
|N|V|V|V|       |S|             |   (if payload len==126/127)   |
| |1|2|3|       |K|             |                               |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
|     Extended payload length continued, if payload len == 127  |
+ - - - - - - - - - - - - - - - +-------------------------------+
|                               |Masking-key, if MASK set to 1  |
+-------------------------------+-------------------------------+
| Masking-key (continued)       |          Payload Data         |
+-------------------------------- - - - - - - - - - - - - - - - +
:                     Payload Data continued ...                :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
|                     Payload Data continued ...                |
+---------------------------------------------------------------+

Answer 3

In the end it was something no one could have known. These were HL7 messages, and there was a missing hidden character on the end of the message that was missing. The receiving party was waiting for the message to finish sending, but without this character it never saw a complete message, thus never sent back the confirmation.