Optimize WebSocket receive path on pre-netstandard2.1 targets

[Copilot]

This change improves WebSocketMessageHandler.ReadCoreAsync for pre-netstandard2.1 TFMs by avoiding an unnecessary copy when the sequence memory can be exposed as an ArraySegment<byte>. It keeps existing behavior while reducing allocations/copy work on the hot read path used by both client and server WebSocket transports.

• Read-path optimization (netfx / pre-2.1 branch)

  • Switched from always renting a temporary buffer and writing into the sequence, to first obtaining destination memory from contentSequenceBuilder.
  • If MemoryMarshal.TryGetArray(memory, out segment) succeeds, ReceiveAsync now reads directly into destination storage.

• Fallback correctness when direct array access is unavailable

  • Retained pooled-array fallback for non-array-backed memory.
  • Receives into a bounded segment (new ArraySegment<byte>(rented, 0, memory.Length)), then copies only result.Count bytes into destination memory.

• Buffer advancement alignment

  • Replaced Write(...) usage in the legacy branch with Advance(result.Count) after receive/copy, aligning mechanics with the modern branch.

Memory<byte> memory = this.contentSequenceBuilder.GetMemory(this.sizeHint);
if (MemoryMarshal.TryGetArray(memory, out ArraySegment<byte> segment))
{
    result = await this.WebSocket.ReceiveAsync(segment, cancellationToken).ConfigureAwait(false);
}
else
{
    byte[] rented = ArrayPool<byte>.Shared.Rent(memory.Length);
    try
    {
        result = await this.WebSocket.ReceiveAsync(
            new ArraySegment<byte>(rented, 0, memory.Length), cancellationToken).ConfigureAwait(false);
        rented.AsSpan(0, result.Count).CopyTo(memory.Span);
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(rented);
    }
}
this.contentSequenceBuilder.Advance(result.Count);

[AArnott]

/azp run

[azure-pipelines]

Azure Pipelines successfully started running 1 pipeline(s).

[Copilot]

Pull request overview

This PR optimizes the WebSocket receive hot path for pre-netstandard2.1 targets in WebSocketMessageHandler.ReadCoreAsync by avoiding an intermediate pooled-buffer copy when the destination Memory<byte> can be exposed as an ArraySegment<byte>.

Changes:

• For legacy TFMs, obtains destination storage via contentSequenceBuilder.GetMemory(sizeHint) and attempts direct ReceiveAsync into it via MemoryMarshal.TryGetArray.
• Preserves correctness with an ArrayPool<byte> fallback when direct array access isn’t available, copying only result.Count bytes.
• Aligns legacy path with modern path mechanics by using contentSequenceBuilder.Advance(result.Count) instead of Write(...).