websocket 的 ReceiveAsync 方法不会等待整个消息

Question

我通过 websocket 接收 JSON。至少：我是部分的。使用在线 websocket 服务，我收到完整的 JSON 响应（所有 HTML 标记都被忽略）。当我查看在控制台中收到的 JSON 时，我可以看到 HTML 标记（在调试期间使用 HTML 查看器查看它会删除 HTML），但它会突然结束（数据不完整）。

我的缓冲区有足够的空间，我正在使用 async-await 来（据说）等待整个响应进入，然后再继续。

private async Task Receive()
{
  var buffer = new byte[4096 * 20];

  while (_socket.State == WebSocketState.Open)
  {
      var response = await _socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

      if (response.MessageType == WebSocketMessageType.Close)
      {
          await
              _socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close response received",
                  CancellationToken.None);
      }
      else
      {
          var result = Encoding.UTF8.GetString(buffer);
          var a = buffer[1000];
          var b = buffer[10000];
          var c = buffer[50000];
          var d = buffer[81000];
          Console.WriteLine(result);
          var responseObject = JsonConvert.DeserializeObject<Response>(result, _requestParameters.ResponseDataType);

          OnSocketReceive.Invoke(this, new SocketEventArgs {Response = responseObject });
          buffer = new byte[4096 * 20];
      }
  }
}   

注意事项：缓冲区足够大，b、c 和 d 永远不会被填满。我还应该注意，这只发生在 1-questions-newest-tag-java 请求中，155-questions-active 工作得很好。

在做了一些挖掘之后，我发现response.CloseStatus 和response.CloseStatusDescription 总是null，response.Count 总是1396（在 Word 中复制粘贴结果确实显示总是有 1396 个字符）和response.EndOfMessage 是 false。

挖掘some source code我发现DefaultReceiveBufferSize是16 * 1024（足够大），WebSocketGetDefaultKeepAliveInterval()指的是an external implementation（但调试器显示00:00:30）。

这不是超时问题，因为调试器在在线服务收到响应的同时停止。

为什么套接字还没有收到所有数据时我的方法继续执行？

Answer 1

试试这个：

try
{
    WebSocketReceiveResult result;
    string receivedMessage = "";
    var message = new ArraySegment<byte>(new byte[4096]);
    do
    {
        result = await WebSocket.ReceiveAsync(message, DisconectToken);
        if (result.MessageType != WebSocketMessageType.Text)
            break;
        var messageBytes = message.Skip(message.Offset).Take(result.Count).ToArray();
        receivedMessage += Encoding.UTF8.GetString(messageBytes);                    
    }
    while (!result.EndOfMessage);
    if (receivedMessage != "{}" && !string.IsNullOrEmpty(receivedMessage))
    {
        ResolveWebSocketResponse.Invoke(receivedMessage, Connection);
        Console.WriteLine("Received: {0}", receivedMessage);
    }
}
catch (Exception ex)
{
    var mes = ex.Message;
}

Answer 2

// Read the bytes from the web socket and accumulate all into a list.
var buffer = new ArraySegment<byte>(new byte[1024]);
WebSocketReceiveResult result = null;
var allBytes = new List<byte>();

do
{
    result = await webSocket.ReceiveAsync(buffer, CancellationToken.None);
    for (int i = 0; i < result.Count; i++)
    {
        allBytes.Add(buffer.Array[i]);
    }
}
while (!result.EndOfMessage);

// Optional step to convert to a string (UTF-8 encoding).
var text = Encoding.UTF8.GetString(allBytes.ToArray(), 0, allBytes.Count);

Answer 3

按照 Noseratio 的回答，我实现了一个临时缓冲区，它将构造整个消息的数据。

var temporaryBuffer = new byte[BufferSize];
var buffer = new byte[BufferSize * 20];
int offset = 0;
WebSocketReceiveResult response;

while (true)
{
    response = await _socket.ReceiveAsync(
                         new ArraySegment<byte>(temporaryBuffer), 
                         CancellationToken.None);
    temporaryBuffer.CopyTo(buffer, offset);
    offset += response.Count;
    temporaryBuffer = new byte[BufferSize];
    if (response.EndOfMessage)
    {
        break;
    }
}

完全实现here

Answer 4

只是为了完成@Noseratio 响应，代码应该是这样的：

ArraySegment<Byte> buffer = new ArraySegment<byte>(new Byte[8192]);

WebSocketReceiveResult result= null;

using (var ms = new MemoryStream())
{
     do
     {
         result = await socket.ReceiveAsync(buffer, CancellationToken.None);
         ms.Write(buffer.Array, buffer.Offset, result.Count);
     }
     while (!result.EndOfMessage);

     ms.Seek(0, SeekOrigin.Begin);

     if (result.MessageType == WebSocketMessageType.Text)
     {
          using (var reader = new StreamReader(ms, Encoding.UTF8))
          {
               // do stuff
          }
     }
}

干杯。

Answer 5

我可能是错的，但我认为您不应该总是立即收到完整的WebSocket 消息。服务器可能会以块的形式发送消息（这对应于使用endOfMessage: false 调用SendAsync）。

所以，循环执行await _socket.ReceiveAsync() 并累积接收到的块，直到WebSocketReceiveResult.EndOfMessage 为true 或发生错误。

顺便说一句，您可能应该使用WebSocket.CreateClientBuffer 而不是new ArraySegment<byte>(buffer)。