将AS3转换为C＃异步套接字不接收所有数据

Question

我正在将一个AS3客户端移植到C＃，并且在完成登录过程到服务器时遇到很大问题。

我没有访问服务器，只有协议，并且不知道服务器是否期待有关套接字的任何特定行为。

我设法连接到服务器并完成登录过程。然后，我可以发送一条请求数据的消息，从而将一系列消息发送给我的客户。

在客户端的AS3版本中，我在三个不同的缓冲区中接收消息。

在我的C＃中，我只获得前两个缓冲区，然后短时间重新连接。

该协议是二进制的。前2个字节告诉我消息的长度，第2个2字节的消息类型。其余是数据。

在第一次读取时，我得到了一个91字节的策略文件，我放弃了。之后，我收到了我能够处理的数据，并且前20条消息都很好。虽然第三个缓冲区永远不会到达。

任何想法？是我的错误AsyncSocket的实现，还是有一些我应该在我的套接字上使用的标志？

任何指针将不胜感激。

public abstract class AsyncSocket 
{ 
    public class StateObject 
    {    
     public Socket workSocket = null; 
     public const int BufferSize = 4096; 
     public byte[] buffer = new byte[BufferSize]; 
     public byte[] messageBuffer = new byte[0]; 
    } 

    public delegate void MessageReceivedHandler(object sender, MessageReceivedEventArgs e); 

    public delegate void ConnectedHandler(object sender, EventArgs e); 

    public event MessageReceivedHandler MessageReceived; 

    public event ConnectedHandler Connected; 

    private IPAddress[] addresses; 
    private int port; 
    private WaitHandle addressesSet; 
    private Socket socket; 
    private int failedConnectionCount; 
    private StateObject state; 

    public AsyncSocket(IPAddress address, int port) : this(new[] { address }, port) { } 

    public AsyncSocket(IPAddress[] addresses, int port) : this(port) 
    { 
     this.addresses = addresses; 
    } 

    public AsyncSocket(string hostNameOrAddress, int port) : this(port) 
    { 
     addressesSet = new AutoResetEvent(false); 
     Dns.BeginGetHostAddresses(hostNameOrAddress, GetHostAddressesCallback, null); 
    } 

    private void GetHostAddressesCallback(IAsyncResult result) 
    { 
     addresses = Dns.EndGetHostAddresses(result);   
     ((AutoResetEvent)addressesSet).Set(); 
    } 

    private AsyncSocket(int port) 
    { 
     this.port = port; 
     this.socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);    
     this.Encoding = Encoding.Default; 
     this.state = new StateObject(); 
     state.workSocket = socket; 
    } 

    public Encoding Encoding { get; set; } 

    public Account Account { get; set; } 

    public void Connect() 
    { 
     if (addressesSet != null) 
      addressesSet.WaitOne();    
     Interlocked.Exchange(ref failedConnectionCount, 0); 
     socket.BeginConnect(addresses, port, ConnectCallback, socket); 
    } 

    private void ConnectCallback(IAsyncResult result) 
    { 
     try 
     { 
      Socket client = (Socket)result.AsyncState; 
      client.EndConnect(result); 
      if (Connected != null) 
      { 
       Connected(this, new EventArgs()); 
      } 
      Receive(client); 
     } 
     catch 
     { 
      Interlocked.Increment(ref failedConnectionCount); 
      if (failedConnectionCount >= addresses.Length) 
      { 
       return; 
      } 
     } 
    } 

    public void Send(string data) 
    { 
     byte[] bytes = Encoding.GetBytes(data); 
     Send(bytes); 
    } 

    public void Send(MsgHead msg) 
    { 
     byte[] bytes = msg.write(); 
     Send(bytes); 
    } 

    public void Send(byte[] bytes) 
    { 
     int messageLength = BitConverter.ToUInt16(bytes, 0); 
     int messageType = BitConverter.ToUInt16(bytes, 2); 

     Console.Out.WriteLine("Sending:len:{0} msg:{1}", messageLength, messageType); 

     socket.BeginSend(bytes, 0, bytes.Length, 0, new AsyncCallback(WriteCallback), socket); 
    } 

    private void WriteCallback(IAsyncResult result) 
    { 
     Socket client = (Socket)result.AsyncState; 
     int bytesSent = client.EndSend(result); 
     Console.WriteLine("Sent {0} bytes to server.", bytesSent); 
    } 

    private void Receive(Socket client) 
    { 
     try 
     {    
      client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, 
       new AsyncCallback(ReceiveCallback), state); 
     } 
     catch (Exception e) 
     { 
      Account.Window.Exit(string.Format("Error on receive: {0}",e.Message)); 
     } 
    } 

    private void ReceiveCallback(IAsyncResult result) 
    { 
     StateObject state = (StateObject)result.AsyncState; 
     Socket client = state.workSocket; 

     SocketError errorCode; 
     int bytesRead = client.EndReceive(result, out errorCode); 
     if (errorCode != SocketError.Success) 
     { 
      Account.Window.Exit(string.Format("Disconnected, {0}", errorCode.ToString())); 
      return; 
     }    

     if (bytesRead == 0) 
     { 
      Account.Window.Exit("Disconnected, zero bytes"); 
      return; 
     } 

     state.messageBuffer = state.messageBuffer.Concat(state.buffer.Take(bytesRead).ToArray()).ToArray(); 

     int messageLength = BitConverter.ToUInt16(state.messageBuffer, 0); 

     if (messageLength > 4096) 
     { 
      state.messageBuffer = state.messageBuffer.Skip(91).ToArray(); 
      messageLength = state.messageBuffer.Length == 0 ? 0 : BitConverter.ToUInt16(state.messageBuffer, 0); 
     } 

     while (messageLength > 0 && state.messageBuffer.Length >= messageLength) 
     { 
      int messageType = BitConverter.ToUInt16(state.messageBuffer, 2); 

      Console.Out.WriteLine("Received:len:{0} msg:{1}", messageLength, messageType); 

      if (MessageReceived != null) 
      { 
       MessageReceived(this, new MessageReceivedEventArgs(state.messageBuffer.Take(messageLength).ToArray())); 
      } 

      state.messageBuffer = state.messageBuffer.Skip(messageLength).ToArray(); 

      messageLength = state.messageBuffer.Length == 0 ? 0 : BitConverter.ToUInt16(state.messageBuffer, 0); 
     } 

     Receive(client); 
    } 
} 

Answer 1

有时候TCP帧会有些棘手。你永远不知道你可能会得到多少次接收电话，这些电话是你期待的三种缓冲器。这里有几件事要检查：

ReceiveCallback（）方法中可能出现的一个问题，如果您只接收1个字节，您尝试将messageLength解码为2个字节的Int16将失败。

确保MessageBuffer方法都正常工作。

MessageLength的值是否包含在MessageLength的值中？如果没有，请确保在解码消息字节之前跳过这2个字节。

更安全的是丢弃全部的消息字节，以防万一它不总是91字节长。

我会将所有“完整”消息缓冲区分派到另一个方法中，并放弃或处理那里，以保持ReceiveCallback（）方法的简洁。