WebSocket em C#: criação de aplicações em tempo real no .NET

WebSocket em C#: criando aplicações real-time no .NET

As aplicações web modernas exigem cada vez mais a transmissão instantânea de dados entre cliente e servidor. O protocolo HTTP tradicional, que opera no esquema "request-response", nem sempre é eficiente para tarefas onde a frequência e a velocidade das atualizações são importantes — chats, jogos online, cotações de bolsa, sistemas de monitoramento. É aqui que o protocolo WebSocket entra em ação, estabelecendo uma conexão bidirecional permanente. Neste artigo, vamos detalhar como implementar WebSocket em C# (.NET), criar um servidor e cliente completos, e também abordar as melhores práticas.

O que é WebSocket e por que ele é necessário no .NET?

WebSocket é um protocolo que opera sobre TCP, proporcionando comunicação full-duplex. Após o estabelecimento da conexão através de um handshake HTTP, os dados podem ser transmitidos em ambas as direções sem custos adicionais. Diferentemente de Long Polling ou Server-Sent Events, o WebSocket oferece latência mínima e baixo tráfego.

No ecossistema .NET, existem duas abordagens principais para trabalhar com real-time:

• WebSocket nativo (System.Net.WebSockets) — API de baixo nível, disponível no ASP.NET Core. Oferece controle total sobre a conexão, adequado para protocolos personalizados.
• SignalR — biblioteca de alto nível da Microsoft, que abstrai o WebSocket e seleciona automaticamente o transporte (WebSocket, SSE, Long Polling). Ideal para tarefas típicas (chats, notificações).

A escolha depende da tarefa: se você precisa de máximo controle e desempenho — use WebSocket nativo; se a velocidade de desenvolvimento e simplicidade são prioridade — use SignalR.

Criando um servidor WebSocket em C# (ASP.NET Core)

Vamos analisar a implementação passo a passo de um servidor. Primeiro, crie um projeto ASP.NET Core (template vazio ou Web API).

Passo 1: Configuração do Middleware

Adicione suporte a WebSocket no método Configure do arquivo Program.cs:

var builder = WebApplication.CreateBuilder(args);var app = builder.Build();

app.UseWebSockets(); // Habilita suporte a WebSocket

app.Map("/ws", async (HttpContext context) =>{    if (context.WebSockets.IsWebSocketRequest)    {        using var webSocket = await context.WebSockets.AcceptWebSocketAsync();        await HandleWebSocketConnection(webSocket);    }    else    {        context.Response.StatusCode = 400;    }});

app.Run();

async Task HandleWebSocketConnection(WebSocket webSocket){    var buffer = new byte[1024 * 4];    while (webSocket.State == WebSocketState.Open)    {        var result = await webSocket.ReceiveAsync(            new ArraySegment<byte>(buffer), CancellationToken.None);

        if (result.MessageType == WebSocketMessageType.Close)        {            await webSocket.CloseAsync(                WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);        }        else if (result.MessageType == WebSocketMessageType.Text)        {            var message = Encoding.UTF8.GetString(buffer, 0, result.Count);            Console.WriteLine($"Recebido: {message}");

            // Resposta de eco            var response = Encoding.UTF8.GetBytes($"Eco: {message}");            await webSocket.SendAsync(                new ArraySegment<byte>(response),                 WebSocketMessageType.Text,                 true,                 CancellationToken.None);        }    }}

Este código cria um servidor de eco: ele recebe mensagens de texto e as envia de volta com o prefixo "Eco:". Observe o gerenciamento do estado da conexão e o tratamento do fechamento.

Passo 2: Gerenciamento de múltiplas conexões

Em uma aplicação real, é necessário armazenar uma lista de conexões ativas. Use ConcurrentDictionary ou ConcurrentBag:

public class WebSoc