WebSocket

@implements IAsyncDisposable
@inject Bit.Butil.WebSocket webSocket

@code {
    private WebSocketHandle? _socket;
    private readonly List<string> _messages = [];

    private async Task Open()
    {
        _socket = await webSocket.Open(
            "wss://example.com/ws/echo",
            onMessage: m => InvokeAsync(() =>
            {
                // m.IsBinary says which payload carries this frame
                _messages.Insert(0, m.IsBinary ? $"{m.Data!.Length} bytes" : m.Text!);
                StateHasChanged();
            }),
            protocols: ["butil-echo"],
            onOpen: (protocol, extensions) => InvokeAsync(StateHasChanged),
            onClose: c => InvokeAsync(StateHasChanged),
            onError: () => InvokeAsync(StateHasChanged));
    }

    // False until onOpen has run: sending before the connection is established fails rather than
    // queueing.
    private async Task Send() => await _socket!.SendText("hello");

    public async ValueTask DisposeAsync()
    {
        if (_socket is not null) await _socket.DisposeAsync();
    }
}

// A browser will not open a socket against an endpoint that does not answer the upgrade, so this is
// the other half of the sample rather than an aside.
app.UseWebSockets();

app.MapGet("/ws/echo", async (HttpContext context, CancellationToken cancellationToken) =>
{
    if (context.WebSockets.IsWebSocketRequest is false)
    {
        context.Response.StatusCode = StatusCodes.Status400BadRequest;
        return;
    }

    // Accept the client's protocol only when it actually offered it; accepting one that was not
    // offered fails the handshake in the browser rather than degrading to none.
    var requested = context.WebSockets.WebSocketRequestedProtocols;
    var protocol = requested.Contains("butil-echo") ? "butil-echo" : null;

    using var socket = protocol is null
        ? await context.WebSockets.AcceptWebSocketAsync()
        : await context.WebSockets.AcceptWebSocketAsync(protocol);

    var buffer = new byte[8 * 1024];

    while (socket.State == System.Net.WebSockets.WebSocketState.Open)
    {
        var result = await socket.ReceiveAsync(buffer, cancellationToken);
        if (result.MessageType == System.Net.WebSockets.WebSocketMessageType.Close) break;

        await socket.SendAsync(buffer.AsMemory(0, result.Count),
            result.MessageType, result.EndOfMessage, cancellationToken);
    }
});