Introducción

El tiempo real en Angular y .NET parece simple hasta el momento en que el equipo necesita elegir la tecnología correcta para salir del “funciona en mi máquina” y llegar a producción sin fragilidad. En general, la discusión empieza con un pedido vago del producto: “necesitamos que la pantalla se actualice sola”. A partir de ahí aparecen cuatro caminos muy diferentes: WebSockets, Server-Sent Events (SSE), SignalR y Long Polling. No son equivalentes, no resuelven el mismo escenario con el mismo costo y no deben tratarse como sinónimos.

Escribí este tutorial para responder la pregunta que realmente importa: cuándo usar cada enfoque sin sobreingeniería. En algunos casos, un stream unidireccional ya resuelve. En otros, la aplicación necesita un canal bidireccional, fallback automático y una abstracción que oculte la complejidad del protocolo. Y, en ciertos entornos corporativos, la solución más fea en teoría se vuelve la más confiable en la práctica porque atraviesa proxies, balanceadores y políticas de red con menos fricción.

El punto central aquí es pragmático. WebSockets ofrecen comunicación bidireccional persistente. SSE entrega actualizaciones del servidor al navegador sobre HTTP con una API simple. SignalR es una abstracción de alto nivel para ASP.NET Core que elige el mejor transporte disponible y además ofrece hubs, grupos y reconexión. Long Polling sigue existiendo porque la compatibilidad y la previsibilidad todavía le ganan a la elegancia en entornos donde WebSockets y SSE están bloqueados.

💡 Consejo: cuando el requisito es solo empujar eventos del servidor al cliente, empieza por SSE o SignalR antes de pasar a WebSockets. En muchos productos, la menor solución suficiente es la que mejor sobrevive con el tiempo.

En este artículo también uso el repositorio de ejemplos del blog como apoyo práctico. El sample en .NET y Angular fue preparado para mostrar el mismo flujo de procesamiento en cuatro transportes diferentes, sin ocultar lo que cambia en el frontend, en el backend y en la operación.

Requisitos previos

Para seguir el tutorial, necesitarás:

  • .NET 10 SDK para ejecutar el backend del sample
  • Node.js o Bun para ejecutar el frontend Angular de demostración
  • Conocimientos básicos de ASP.NET Core, Angular y HTTP
  • Familiaridad con los conceptos de endpoint, hub y solicitud asíncrona

Clona el repositorio de ejemplos:

1
2
git clone https://github.com/lzocateli/blog-zocateli-sample.git
cd blog-zocateli-sample

Si quieres reproducir el escenario localmente, el backend está en src/BlogSamples y el frontend de demostración en frontend/search-ui-bun/. El sample fue pensado para mostrar una tarea de procesamiento con evolución incremental, justamente para evidenciar la diferencia entre transporte, latencia y complejidad del cliente.

⚠️ Atención: SSE depende de una respuesta en streaming. En Nginx, Cloudflare y otros proxies, el buffering puede retrasar o romper la experiencia si el backend no escribe y hace flush de los eventos correctamente.

Cuándo tiene sentido cada tecnología

Antes de entrar en la implementación, me gusta reducir la discusión a un criterio simple: ¿qué dirección necesita seguir el flujo de datos? Si la aplicación solo necesita publicar estados, notificaciones o progreso, no hay motivo para pagar el costo cognitivo de una conexión bidireccional completa. Si el cliente también necesita enviar comandos frecuentes en tiempo real, entonces la conversación cambia.

El Long Polling es el punto de partida más conservador. Funciona con cualquier infraestructura HTTP tradicional, atraviesa proxies más restrictivos y es fácil de entender: el cliente hace una solicitud y el servidor la retiene hasta que haya un dato nuevo o hasta el timeout. A cambio, pagas con latencia y con el overhead de conexiones repetidas. Es un compromiso útil cuando la compatibilidad gana a la elegancia.

El SSE es un término medio muy interesante para dashboards, pistas de auditoría, estado de jobs y feeds de notificaciones. Usa una conexión HTTP abierta y el navegador recibe eventos continuamente mediante EventSource. El cliente no envía mensajes por el mismo canal, así que la solución es naturalmente unidireccional. Esto reduce la superficie del problema, simplifica la implementación y además es más compatible de lo que muchos equipos imaginan.

Los WebSockets entran cuando la conversación necesita ser bidireccional de verdad. Chat, colaboración, juegos, telemetría interactiva, edición simultánea y comandos en tiempo real son escenarios en los que el modelo full-duplex tiene sentido. El precio es conocido: una conexión persistente, atención extra a la escalabilidad, afinidad en los balanceadores y mayor sensibilidad a los intermediarios de red.

SignalR resuelve otra categoría de problema: quiero un contrato de tiempo real en ASP.NET Core sin verme obligado a elegir el transporte manualmente en cada caso. El framework negocia WebSockets, SSE y Long Polling según lo permita la plataforma. En proyectos .NET, esto reduce la fricción y además ofrece recursos de alto nivel como hubs, grupos y reconexión.

En resumen: Long Polling es la red de seguridad, SSE es el stream simple y eficiente, WebSockets es el canal persistente y bidireccional, y SignalR es la abstracción que delega la decisión al runtime.

WebSockets en la práctica con .NET y Angular

Los WebSockets empiezan como HTTP y después hacen upgrade a un canal persistente. Este detalle lo cambia todo: la conexión deja de ser un ciclo de solicitud y respuesta y pasa a ser un tubo abierto en ambos sentidos. Eso significa menos overhead por mensaje, baja latencia y un modelo mental muy útil para aplicaciones que necesitan reaccionar a interacciones del usuario y a eventos del servidor sin reabrir la conexión en cada acción.

En la práctica, la ganancia viene con responsabilidades extras. Los WebSockets exigen atención a la escalabilidad horizontal, porque la conexión permanece viva y puede depender de afinidad de sesión o de un backplane para la distribución de mensajes. También es común encontrar un proxy corporativo, gateway o CDN que no trata los WebSockets tan bien como el tráfico HTTP común. Eso no hace que la tecnología sea mala; solo obliga a un análisis más serio del entorno.

El escenario más fuerte para WebSockets en Angular y .NET es cuando el cliente también envía comandos frecuentes: iniciar una tarea, cancelar una operación, ajustar parámetros de ejecución o mantener una sesión interactiva. En lugar de abrir nuevas solicitudes para cada paso, el cliente y el servidor comparten un canal continuo.

📝 Ejemplo: en un panel de supervisión de jobs, el usuario puede disparar una tarea, recibir progreso incremental y cancelar la operación sin salir del mismo canal de comunicación.

SSE en la práctica con .NET y Angular

SSE, o Server-Sent Events, es lo opuesto al glamour tecnológico y precisamente por eso suele ser tan útil. El navegador abre una conexión HTTP con EventSource y queda escuchando eventos con nombre enviados por el servidor. No hay bidireccionalidad en el mismo canal; el servidor escribe, el cliente lee. Parece limitado, pero para actualizaciones de estado, notificaciones, progreso de procesamiento y feeds de eventos suele ser suficiente.

El punto fuerte de SSE es la simplicidad operativa. Como permanece muy cerca de HTTP, suele ser más fácil atravesar la infraestructura existente que con una conexión WebSocket. La API del navegador es reducida y la reconexión puede tratarse con el comportamiento nativo o con una pequeña capa de código. Para aplicaciones Angular, esto combina bien con una interfaz reactiva que solo necesita reflejar el estado más reciente.

El cuidado principal está en la entrega del stream. Si el backend escribe el evento pero el proxy retiene el buffer, el usuario no ve nada hasta el flush o hasta que se desactive el buffering. Es exactamente por eso que SSE necesita documentarse junto con la arquitectura de borde, y no solo como un detalle del controller.

SignalR como capa de abstracción

SignalR es donde muchas discusiones se vuelven confusas, así que vale la pena separar bien los papeles. SignalR no es “un protocolo competidor” de WebSockets. Es una abstracción de alto nivel para aplicaciones ASP.NET Core que elige el transporte disponible y ofrece una experiencia más simple al desarrollador. Si WebSockets está disponible, perfecto. Si no lo está, SignalR puede recurrir a SSE o Long Polling sin romper el contrato de la aplicación.

Para equipos .NET, esto suele ser valioso porque reduce decisiones repetitivas. En lugar de que cada pantalla decida por su cuenta cómo hablar con el backend, centralizo la conversación en hubs, métodos y eventos. El frontend llama a un método, el hub responde con un evento y el framework negocia el transporte en medio. Esto también ayuda cuando quieres grupos, broadcast selectivo, reconexión automática y un modelo de dominio más claro.

El trade-off es que esta capa puede ocultar detalles que el equipo debería entender. SignalR ayuda, pero no elimina la necesidad de saber cuándo WebSockets, SSE o Long Polling están detrás de la abstracción. Si la aplicación necesita una previsibilidad extrema en un entorno específico, es mejor medir el comportamiento real que asumir que el framework lo resolverá todo solo.

Long Polling como fallback y compatibilidad máxima

El Long Polling se trata con frecuencia como una técnica antigua, pero es un error de lectura. Sigue siendo importante porque existe una enorme cantidad de entornos en los que el mejor protocolo es simplemente el que pasa por el firewall, el proxy y la política de seguridad sin discusión. En lugar de abrir un canal persistente, el cliente hace una solicitud y el servidor retiene la respuesta hasta que haya una actualización o un timeout.

El efecto práctico es la previsibilidad. Puedes pagar con mayor latencia y más overhead de solicitudes, pero ganas una compatibilidad casi universal. Para usuarios detrás de proxies muy restrictivos, entornos corporativos con reglas conservadoras y stacks legados, Long Polling sigue siendo una solución válida. Es mejor tener un fallback más lento que no tener ninguna actualización.

El problema real es intentar usar Long Polling como primera opción cuando la aplicación claramente pide un canal más eficiente. Si el producto depende de muchos eventos por segundo o de interacción instantánea, el costo de repetir solicitudes aparece rápidamente en CPU, red y observabilidad. En esa situación, Long Polling debe quedarse en la reserva, no al volante.

Matriz de decisión para elegir el enfoque

Cuando necesito decidir rápido, uso una matriz simple:

Matriz de decisión entre WebSockets, SSE, SignalR y Long Polling

EscenarioMejor punto de partidaMotivo
Solo servidor → clienteSSEMenor complejidad, stream HTTP simple
El cliente también envía comandos frecuentesWebSocketsCanal bidireccional real
Quiero abstracción en ASP.NET Core y fallback automáticoSignalRNegociación de transporte y hubs
Infraestructura restrictiva o legadaLong PollingMayor compatibilidad
UI de dashboard con progreso de jobsSSE o SignalRBaja complejidad y buena UX
Chat o colaboración en tiempo realWebSockets o SignalRBidireccionalidad y baja latencia

Esta matriz no sustituye las mediciones, pero evita la trampa más común: usar la tecnología más poderosa solo porque es más emocionante. En producción, el menor mecanismo que cumple el requisito suele ser el que da menos trabajo para operar.

Ejemplo Práctico

El sample del blog fue montado para mostrar el mismo flujo de tarea con cuatro transportes. En el backend, expongo un endpoint de creación, un endpoint de consulta y un stream para SSE y WebSocket. En el frontend Angular, alterno la conexión según el transporte elegido y actualizo la misma interfaz con el mismo modelo de evento.

Backend .NET

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
var grupo = app.MapGroup("/api/tempo-real")
    .WithTags("Tempo real")
    .RequireCors("TempoReal");

grupo.MapPost("/tarefas", (TempoRealProcessamentoService processamentoService, TempoRealCriacaoRequest request) =>
{
    if (string.IsNullOrWhiteSpace(request.Descricao))
    {
        return Results.BadRequest(new { erro = "A descrição da tarefa é obrigatória." });
    }

    var resposta = processamentoService.CriarTarefa(request.Descricao.Trim());
    return Results.Created($"/api/tempo-real/tarefas/{resposta.TarefaId}", resposta);
});

grupo.MapGet("/tarefas/{tarefaId:guid}/stream", async (
    Guid tarefaId,
    HttpContext context,
    TempoRealProcessamentoService processamentoService,
    CancellationToken cancellationToken) =>
{
    context.Response.ContentType = "text/event-stream";
    await foreach (var proximoEstado in processamentoService.ObterFluxoAsync(tarefaId, cancellationToken))
    {
        await context.Response.WriteAsync($"data: {JsonSerializer.Serialize(proximoEstado)}\n\n", cancellationToken);
        await context.Response.Body.FlushAsync(cancellationToken);
    }
});

📂 Código Fuente: El ejemplo completo del backend está disponible en el repositorio de ejemplos del blog en BlogSamples/Messaging/TempoReal/.

Angular con SignalR

1
2
3
4
5
6
7
8
9
const connection = new signalR.HubConnectionBuilder()
  .withUrl('/hubs/tempo-real', { withCredentials: true })
  .withAutomaticReconnect()
  .build();

connection.on('estado', (estado: TempoRealEstadoResponse) => onEstado(estado));

await connection.start();
await connection.invoke('AcompanharTarefa', tarefaId);

📂 Código Fuente: El frontend de demostración está en el repositorio de ejemplos del blog en frontend/search-ui-bun/, donde adapté la interfaz para alternar entre los cuatro transportes.

El detalle importante aquí no es la cantidad de líneas, sino el modelo mental. El mismo backend produce el mismo estado de tarea; lo que cambia es cómo ese estado cruza la red y cómo la interfaz decide escuchar las actualizaciones.

Consejos y Buenas Prácticas

  • Empieza por el requisito de dirección de los datos. Si el flujo es solo servidor → cliente, prefiero SSE o SignalR antes de pensar en WebSockets. Esto reduce la complejidad, facilita la operación y evita abrir un canal más caro de lo necesario.

  • Desactiva el buffering cuando uses SSE. Un streaming sin flush de la respuesta se convierte en “casi streaming”. En producción, siempre valido la cadena completa de proxy, CDN y servidor para garantizar que los eventos lleguen al navegador en el tiempo esperado.

  • Trata SignalR como contrato, no como magia. Resuelve muchas cosas, pero sigue dependiendo del transporte, la reconexión y la política de red. Entender lo que ocurre por debajo evita sorpresas cuando el entorno cambia de WebSocket a Long Polling.

  • Usa Long Polling como fallback consciente. Es útil cuando la infraestructura es restrictiva, pero no es la opción ideal para alto volumen. Si la aplicación crece, la diferencia de costo en solicitudes y latencia aparece rápido.

  • Modela el estado del evento de forma estable. El cliente no debería tener que adivinar el significado de cada payload. Un modelo único de evento simplifica los logs, el debug, la reconexión y el renderizado en la UI.

  • Observa el entorno de borde desde el inicio. Proxies, balanceadores, políticas de seguridad y timeouts son parte de la arquitectura de tiempo real, no detalles operativos. Ignorarlo genera un sistema que funciona en dev y falla fuera de él.

Resumen Objetivo

  • WebSockets — ofrecen comunicación bidireccional persistente sobre una única conexión, lo que reduce el overhead por mensaje y favorece escenarios interactivos como chat y colaboración.
  • SSE — entrega eventos del servidor al navegador mediante text/event-stream, con API nativa en el navegador y simplicidad operativa para dashboards y notificaciones.
  • SignalR — es una abstracción de alto nivel de ASP.NET Core que negocia WebSockets, SSE o Long Polling y expone hubs, grupos y reconexión.
  • Long Polling — mantiene la compatibilidad máxima con la infraestructura HTTP tradicional, pero paga con más latencia y más solicitudes al servidor.
  • Angular + .NET — funcionan muy bien para aplicaciones de tiempo real cuando el modelo de evento es estable y el transporte se elige por el requisito, no por la moda.
  • Infraestructura de borde — puede ser el factor decisivo entre una solución elegante y una solución operativamente confiable; el buffering y los proxies influyen directamente en SSE y WebSockets.

Lee También

Referencias