Introducción
En aplicaciones corporativas con alto volumen de procesamiento, no todo puede — ni debe — ocurrir dentro de una solicitud HTTP. Importaciones masivas, consumo de colas de mensajería, sincronizaciones periódicas, envío de notificaciones en lote, procesamiento de eventos de dominio — estos escenarios exigen procesos en segundo plano que se ejecuten de forma continua, independientes de las solicitudes, y que sobrevivan a reinicios de forma controlada.
.NET 8+ ofrece una infraestructura robusta para esto: los Worker Services y la clase BackgroundService. Construidos sobre el Generic Host (IHost), comparten el mismo pipeline de inyección de dependencias, configuración y logging de las Web APIs — pero sin el overhead de Kestrel y del middleware HTTP. Esto significa que todo lo que ya sabes sobre IOptions<T>, ILogger<T>, IServiceProvider y ciclos de vida de DI se aplica directamente a los Workers.
En este artículo, voy a explorar los tipos de Workers, cómo se comportan los ciclos de vida Singleton, Scoped y Transient en este contexto (con trampas que sorprenden a muchos desarrolladores) y cómo los Workers se integran de forma nativa con paginación de grandes volúmenes, mensajería para desacoplamiento, paralelismo con Parallel y Tasks y programación asíncrona con async/await.
💡 Consejo: Si tu aplicación usa hoy un
Task.Run()dentro de un controller para “procesar en segundo plano”, este artículo te mostrará el enfoque correcto y listo para producción para ese escenario.
📦 Código fuente: La implementación completa de este artículo está en el repositorio blog-zocateli-sample en GitHub. Clónalo, explóralo y adáptalo a tu contexto.
Qué Es un .NET Worker Service
Un Worker Service es una aplicación .NET sin interfaz web, diseñada para ejecutar tareas en segundo plano de forma continua o periódica. Usa el Generic Host — la misma infraestructura que una Web API usa internamente — pero sin el servidor HTTP (Kestrel).
Creando un Worker Service
| |
| |
| |
Generic Host vs WebApplication
| Aspecto | Host.CreateApplicationBuilder | WebApplication.CreateBuilder |
|---|---|---|
| Pipeline de configuración | ✅ Idéntico | ✅ Idéntico |
| Inyección de dependencias | ✅ Idéntica | ✅ Idéntica |
| Logging | ✅ Idéntico | ✅ Idéntico |
| IOptions | ✅ Idéntico | ✅ Idéntico |
| Servidor HTTP (Kestrel) | ❌ No incluido | ✅ Incluido |
| Pipeline de middleware | ❌ No aplicable | ✅ Incluido |
| Endpoints / Controllers | ❌ No aplicable | ✅ Incluido |
| Uso típico | Procesamiento en segundo plano, colas | APIs HTTP, apps web |
ℹ️ Información: Como el pipeline de configuración es idéntico, todo lo explicado en Pipeline de Configuración en .NET 8+ — orden de los providers,
IOptions<T>, Docker secrets,AddKeyPerFile— se aplica directamente a los Workers.
IHostedService vs BackgroundService
.NET ofrece dos abstracciones para servicios en segundo plano. Entender la diferencia es fundamental:
IHostedService — Control Total
| |
BackgroundService — Abstracción Simplificada
| |
| Aspecto | IHostedService | BackgroundService |
|---|---|---|
| Control | StartAsync + StopAsync manual | ExecuteAsync con bucle automático |
| Timer/Polling | Implementar manualmente con Timer | Usar Task.Delay dentro del bucle |
| Escenario ideal | Inicialización/limpieza compleja | Bucles de procesamiento continuo |
| CancellationToken | Recibido en StartAsync/StopAsync | Recibido en ExecuteAsync |
| Hereda de | Interfaz (IHostedService) | Clase abstracta (BackgroundService) |
⚠️ Atención: El
ExecuteAsyncdelBackgroundServicese ejecuta en segundo plano. Si lanzaba una excepción no tratada antes de .NET 8, el host seguía ejecutándose silenciosamente con el worker muerto. A partir de .NET 8, las excepciones no tratadas enExecuteAsyncdetienen todo el host de forma predeterminada (comportamiento configurable víaHostOptions.BackgroundServiceExceptionBehavior).
Tipos de Workers y Sus Casos de Uso
En la práctica corporativa, los Workers se dividen en patrones recurrentes. Elegir el tipo correcto para cada escenario evita complejidad innecesaria:
1. Timer Worker (Polling)
Ejecuta una tarea a intervalos regulares. Ideal para sincronizaciones periódicas, limpieza de datos expirados y health checks:
| |
2. Queue Worker (Mensajería)
Consume mensajes de una cola (RabbitMQ, Azure Service Bus, Amazon SQS) en un bucle continuo. Este es el patrón más común para desacoplar servicios — exactamente el escenario descrito en Cuello de Botella en Bases de Datos: Mensajería y Paginación:
| |
3. Batch Processing Worker
Procesa grandes volúmenes de datos en lotes paginados, evitando cargar todo en memoria. Se combina naturalmente con paginación Keyset para procesar millones de registros de forma eficiente:
| |
4. Worker con Paralelismo
Para escenarios donde el procesamiento individual es lento (llamadas HTTP, cálculos pesados), el Worker puede usar paralelismo controlado. Esto se conecta directamente con los conceptos de Paralelismo en C#: Parallel, PLINQ y Tasks en la Práctica:
| |
💡 Consejo: Observa el patrón
SemaphoreSlim+Task.WhenAll— permite paralelismo controlado sin sobrecargar recursos. Cada elemento usa su propio scope de DI (CreateScope), garantizando queDbContexty otros servicios Scoped sean independientes entre las tareas. Para más detalles sobre paralelismo controlado, consulta Paralelismo en C#.
Ciclos de Vida en un Worker Service
Esta es la sección más importante del artículo — y la que más bugs causa en producción. Los ciclos de vida de DI (Singleton, Scoped, Transient) se comportan de forma diferente en Workers en comparación con las Web APIs, porque no existe el concepto de “solicitud HTTP” para crear scopes automáticamente.
El Problema: Los Workers Son Singleton
El BackgroundService se registra como Singleton mediante AddHostedService<T>(). Esto significa que todas sus dependencias inyectadas por el constructor también deben ser Singleton — o tendrás problemas:
| |
La Solución: IServiceScopeFactory
El patrón correcto es inyectar IServiceScopeFactory (que es Singleton) y crear scopes manualmente:
| |
Comportamiento de los Ciclos de Vida en Workers
| Ciclo de vida | ¿Inyectar en el constructor del Worker? | ¿Vía CreateScope? | Comportamiento |
|---|---|---|---|
| Singleton | ✅ Sí | ✅ Sí | Misma instancia durante toda la vida del host |
| Scoped | ❌ InvalidOperationException | ✅ Sí (obligatorio) | Nueva instancia por scope creado manualmente |
| Transient | ⚠️ Funciona, pero es peligroso | ✅ Sí (recomendado) | Nueva instancia en cada resolución — sin scope, fuga de memoria |
Por Qué Transient en el Constructor Es Peligroso
| |
⚠️ Atención: En las Web APIs, ASP.NET Core crea scopes automáticamente para cada solicitud HTTP. En los Workers, tú eres responsable de crear scopes manualmente siempre que necesites servicios Scoped o Transient. Olvidar crear el scope es la causa n.º 1 de fugas de memoria y de agotamiento del connection pool en Workers.
Diagrama: Scope de DI en Web API vs Worker
En una Web API, cada solicitud HTTP crea automáticamente un scope de DI. En el Worker, ExecuteAsync se ejecuta en un único scope Singleton — por eso necesitas crear scopes manualmente con IServiceScopeFactory.CreateScope() para simular el mismo aislamiento.
Workers en la Práctica Corporativa
Worker como Consumidor de Mensajería
El patrón más potente de Workers en entornos corporativos es el consumo de colas de mensajería. En lugar de procesar todo de forma síncrona dentro de la API, la API publica un evento en la cola y el Worker lo consume y procesa en segundo plano — exactamente el patrón descrito en Cuello de Botella en Bases de Datos: Mensajería y Paginación:
| |
Worker para Procesamiento de Grandes Volúmenes con Paginación
Cuando necesitas procesar millones de registros (migración de datos, recálculo de saldos, reindexación), el Worker se combina con la paginación Keyset para procesar en bloques sin sobrecargar la memoria:
| |
Worker con Async/Await y CancellationToken
El CancellationToken es el contrato de graceful shutdown del Worker. Cuando el host recibe una señal de parada (SIGTERM en Linux, Ctrl+C, docker stop), dispara el token — y el Worker tiene un tiempo limitado para terminar lo que está haciendo. Este mecanismo se conecta directamente con los conceptos de Programación Asíncrona con async/await:
| |
| |
ℹ️ Información: En contenedores Docker/Podman,
docker stopenvíaSIGTERMy espera 10 segundos de forma predeterminada antes de enviarSIGKILL. Si tu Worker necesita más tiempo para un graceful shutdown, configuraShutdownTimeouten el código y--stop-timeouten el contenedor.
Múltiples Workers en el Mismo Host
Una aplicación puede registrar varios Workers en el mismo host — cada uno se ejecuta en su propia Task:
| |
⚠️ Atención: Los Workers se inician en el orden en que fueron registrados, pero se ejecutan en paralelo. El
StartAsyncde cada uno se llama secuencialmente (en el orden de registro), pero elExecuteAsyncdelBackgroundServicese ejecuta en segundo plano inmediatamente. Si un Worker depende de que otro ya esté en ejecución, usaIHostApplicationLifetimepara coordinarlos.
Cuándo Separar en Procesos Distintos vs el Mismo Host
| Escenario | Mismo Host | Procesos Separados |
|---|---|---|
| Workers ligeros (timers, health checks) | ✅ Recomendado | Overhead innecesario |
| Workers con requisitos de escalado diferentes | ❌ | ✅ Escalar de forma independiente |
| Workers con dependencias conflictivas | ❌ | ✅ Aislamiento de dependencias |
| Workers consumiendo colas diferentes | Depende del volumen | ✅ Escalar por cola |
| Deploy en Kubernetes | ❌ | ✅ Un Deployment por Worker |
| Deploy en VPS/VM | ✅ (servicios systemd) | Gestión compleja |
Ejecutando Workers como Servicio del Sistema Operativo
En producción, los Workers se ejecutan como servicios gestionados por el sistema operativo:
Linux — systemd
| |
Docker / Podman
| |
| |
Consejos y Buenas Prácticas
Usa siempre
IServiceScopeFactorypara servicios Scoped — nunca inyectesDbContext, repositorios o servicios Scoped directamente en el constructor del Worker. Crea scopes manualmente dentro del bucle.Propaga el
CancellationTokena todas las operaciones async — desdeExecuteAsynchasta la llamada a la base de datos, a la cola de mensajería y alHttpClient. Un Worker que ignora el token tarda en detenerse y puede perder datos en el shutdown.Trata las excepciones dentro del bucle — en .NET 8, las excepciones no tratadas en
ExecuteAsyncdetienen el host. Usa try/catch con retry y logging para evitar que un error transitorio mate al Worker.Configura
HostOptions.ShutdownTimeoutadecuadamente — el valor predeterminado de 30 segundos puede ser insuficiente para Workers que procesan lotes grandes. Alinéalo con el--stop-timeoutde Docker/Podman.Usa
IHttpClientFactoryen lugar denew HttpClient()— en servicios Singleton como los Workers, instanciarHttpClientdirectamente causa fuga de sockets y DNS stale.IHttpClientFactorygestiona el pool de handlers.Prefiere la paginación Keyset para procesamiento por lotes — evita
Skip/Takecon OFFSET para grandes datasets. Keyset (WHERE Id > ultimoId) mantiene el rendimiento constante independientemente del volumen.Separa los Workers por responsabilidad — un Worker debe hacer una sola cosa bien. Los Workers “navaja suiza” con múltiples responsabilidades son difíciles de escalar, monitorear y depurar.
Añade health checks al Worker — usa
IHealthChecky expón un endpoint HTTP mínimo (conMapHealthChecks) para que los orquestadores (Kubernetes, Docker) puedan verificar si el Worker está sano.
Conclusión
Los .NET Workers y Background Services son la solución nativa de .NET para el procesamiento en segundo plano — sin chapuzas con Task.Run() dentro de controllers, sin bibliotecas de terceros para escenarios que el framework ya resuelve. El Generic Host proporciona la misma infraestructura de configuración, DI y logging de las Web APIs, permitiendo que los equipos compartan patrones y conocimiento entre proyectos HTTP y Workers.
El punto más crítico — y el que genera más bugs en producción — es entender que los Workers son Singleton. Esto cambia fundamentalmente cómo tratas DbContext, repositorios y cualquier servicio Scoped. El patrón IServiceScopeFactory.CreateScope() no es opcional: es la base de todo Worker que accede a una base de datos o a servicios con estado.
Para aplicaciones corporativas de alto volumen, la combinación de Workers con mensajería para desacoplamiento, paginación Keyset para procesamiento por lotes, paralelismo controlado con SemaphoreSlim y async/await con CancellationToken forma un arsenal completo para construir sistemas que procesan millones de registros de forma confiable, sin bloquear la API y sin perder datos en el shutdown.
Lee También
- Cuello de Botella en Bases de Datos: Mensajería y Paginación — cómo los Workers consumen colas de mensajería para aliviar la base de datos en escenarios de alto volumen.
- Paginación en APIs REST con C# y EF Core 8 — paginación Keyset y Offset para procesamiento por lotes dentro de Workers.
- Paralelismo en C#: Parallel, PLINQ y Tasks en la Práctica — cómo combinar
Task.WhenAll,SemaphoreSlimyParallel.ForEachAsyncdentro de Workers para un paralelismo controlado. - Programación Asíncrona en C#: async/await y Threads — fundamentos de async/await y CancellationToken que son la base de todo Worker Service.
- Pipeline de Configuración en .NET 8+: IOptions, Secrets y Docker — el pipeline de configuración compartido entre Workers y Web APIs, incluyendo Docker secrets con
AddKeyPerFile. - EF Core Migrations: Multiproyecto, Secrets y Scaffolding — gestión de migrations y secrets en proyectos multicapa con Workers.
Referencias
- Worker Services in .NET — Microsoft Learn — documentación oficial de Workers y Background Services en .NET, incluyendo ejemplos y buenas prácticas.
- BackgroundService Class — Microsoft Learn — referencia de la API de
BackgroundService, incluyendoExecuteAsyncyStopAsync. - IHostedService Interface — Microsoft Learn — referencia de la interfaz base para hosted services con
StartAsyncyStopAsync. - .NET Generic Host — Microsoft Learn — cómo el Generic Host configura DI, configuración y logging para Workers y Web APIs.
- Dependency Injection Lifetimes — Microsoft Learn — documentación oficial de los ciclos de vida Singleton, Scoped y Transient en .NET.
- Use scoped services within a BackgroundService — Microsoft Learn — guía oficial para usar
IServiceScopeFactoryen Background Services. - RabbitMQ .NET Client — RabbitMQ Docs — documentación oficial del cliente RabbitMQ para .NET, incluyendo
AsyncEventingBasicConsumer. - Create Windows Services using BackgroundService — Microsoft Learn — cómo ejecutar Workers como Windows Services con
UseWindowsService(). - BackgroundServiceExceptionBehavior — Microsoft Learn — configuración del comportamiento ante excepciones no tratadas en
ExecuteAsynca partir de .NET 8. - Repositorio blog-zocateli-sample — Workers — Código fuente completo de los ejemplos de este artículo

Al comentar, aceptas nuestra Política de Privacidad, Términos de Uso, Política de Eliminación de Datos.