Introducción
System.Threading.Channels es la biblioteca de .NET que ofrece canales para transportar datos entre productores y consumidores de forma concurrente, con APIs de lectura y escritura compatibles con async y await. La usaría cuando una etapa genera trabajo y otra necesita consumirlo a un ritmo distinto, sin obligar al productor a ejecutar toda la etapa siguiente ni crear una tarea independiente para cada elemento.
El canal es una cola en memoria dentro del proceso, no un broker de mensajes. Un canal limitado puede contener el crecimiento del búfer y aplicar backpressure: cuando la cola se llena, el productor espera espacio o la política elegida descarta elementos. Eso organiza la presión entre etapas, pero no ofrece persistencia, confirmación de procesamiento ni recuperación tras una caída de la aplicación. Si un pedido necesita sobrevivir a un reinicio, Channels por sí solo no resuelve el problema.
Imagina una importación que lee registros más rápido de lo que puede validarlos. Acumular todo en una lista aumenta el uso de memoria; crear miles de tasks traslada la cola al planificador y dificulta controlar la concurrencia. Un canal coloca una frontera explícita entre lectura y procesamiento. A partir de ella, puedo discutir capacidad, cantidad de consumidores, comportamiento ante la saturación y cierre con decisiones verificables.
En este artículo, voy a explicar Channel<T>, ChannelWriter<T> y ChannelReader<T>, comparar canales limitados e ilimitados y mostrar por qué aceptar una escritura no equivale a terminar el trabajo. También trataré la cancelación, la finalización y los fallos que pueden dejar a un productor bloqueado. El ejemplo es pequeño, usa .NET 10 y pruebas deterministas, sin base de datos ni mensajería externa.
El analizador de historial de Git (portugués) ya aplica Channels a un problema específico. Aquí, el objetivo es entender la biblioteca y su ciclo de vida sin repetir aquel analizador. Después, el mismo razonamiento puede ayudar a implementar Workers, importaciones y pipelines de procesamiento locales.
Requisitos previos
- .NET SDK 10.0.400 o un parche compatible, según el
global.jsondel repositorio de ejemplos. - Conocimiento de
Task,CancellationTokenyasync/await. No es necesario conocer un broker de mensajes. - Nociones básicas de inyección de dependencias si adaptas el ejemplo a un Worker o una API.
- Un clon de blog-zocateli-sample para ejecutar la demo y consultar las pruebas completas.
En un proyecto que usa el framework .NET 10, los tipos de System.Threading.Channels ya están disponibles mediante las referencias del framework. La demo de este artículo no necesita agregar un paquete NuGet de Channels. Si mantienes una biblioteca para otros frameworks, revisa los frameworks de destino y la necesidad de referenciar el paquete correspondiente.
Los datos del ejemplo son enteros generados en memoria. Eso evita confundir el comportamiento del canal con la latencia de una base de datos, la indisponibilidad de la red o las garantías de entrega de un sistema externo.
Channel, Writer y Reader separan las responsabilidades
Un Channel<T> representa la estructura que conecta escritura y lectura. Su propiedad Writer proporciona un ChannelWriter<T>, que el productor usa para agregar elementos y señalar que no habrá nuevas escrituras. La propiedad Reader proporciona un ChannelReader<T>, que el consumidor usa para retirar elementos o esperar su llegada. Esta separación permite entregar a cada componente solo la capacidad que necesita.
El productor no necesita saber qué consumidor recibirá el elemento. El consumidor no necesita acceder a la fuente original de los datos. Esto es útil cuando la etapa de lectura tiene una naturaleza distinta de la etapa de procesamiento: un parser puede producir registros de forma incremental mientras un grupo pequeño de consumidores aplica validaciones. El contrato común es el tipo transportado por el canal.
La estructura ya sincroniza sus propias operaciones. No pondría un lock externo alrededor de cada escritura y lectura por reflejo. Sin embargo, esa protección no se extiende al contenido del elemento: si el productor y el consumidor siguen modificando el mismo objeto mutable después de la escritura, todavía hay estado compartido. Prefiere datos inmutables o una transferencia de responsabilidad bien definida.
Crear un canal tampoco genera un hilo dedicado. Las operaciones asíncronas esperan disponibilidad; el trabajo real lo siguen ejecutando las tareas que tú inicias. Channels coordina el paso de datos, no decide por sí solo cuántos consumidores existirán ni cuál es el grado de paralelismo adecuado.
En el código, esa división aparece directamente: Writer.WriteAsync admite trabajo; Reader.ReadAllAsync entrega elementos para procesar. El servicio que consume sigue siendo responsable de validar el dato, ejecutar la operación y tratar sus efectos. Una lectura exitosa no es una confirmación de que la operación de negocio terminó.
El canal limitado aplica backpressure; el ilimitado no limita la memoria
Un canal ilimitado no tiene una capacidad máxima configurada para el búfer. Si el productor avanza continuamente y los consumidores no lo acompañan, los elementos pendientes pueden acumularse. “Ilimitado” describe la política de la estructura, no la cantidad de memoria disponible en el proceso. El límite real seguirá impuesto por los recursos del entorno.
Un canal limitado hace explícita la cantidad de elementos que pueden permanecer en el búfer. En el modo Wait, una escritura asíncrona espera espacio cuando se alcanza esa capacidad. En lugar de seguir leyendo una fuente y apilando objetos, el productor recibe presión de la etapa más lenta. Eso es backpressure: la velocidad de una parte del pipeline influye en la etapa que la alimenta.
| |
📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog:
BlogSamples/AsyncParallel/Channels/
La capacidad limita los elementos que esperan dentro del canal, no todo el trabajo en curso. Con cuatro posiciones y dos consumidores, todavía puedo tener cuatro elementos en el búfer y dos en procesamiento. Los objetos ya creados por la fuente, los búferes de red y las tasks iniciadas fuera de esa frontera también ocupan memoria. El canal no impone un techo global al proceso.
Por eso dimensionaría capacidad y concurrencia juntas. Una cola muy grande puede aumentar la espera y la memoria sin mejorar el throughput; una cola pequeña puede ser suficiente para suavizar pequeñas diferencias de ritmo. Antes de elegir cientos de posiciones, mide el tamaño de los elementos, la latencia del consumidor y los límites del recurso accedido. El número más grande no siempre produce el mejor flujo.

Los modos de descarte cambian el significado de la escritura
BoundedChannelFullMode define qué ocurre cuando una escritura encuentra el búfer lleno. El valor predeterminado, Wait, conserva la intención de admitir todos los elementos esperando espacio en las escrituras asíncronas. Los otros modos aceptan perder datos en puntos específicos. Elegir uno de ellos es una decisión funcional: ¿qué información está autorizado a abandonar el sistema?
Considera un canal con capacidad dos, que contiene [10, 20], y un intento de escribir 30 sin lecturas concurrentes:
| Modo | Resultado en el búfer | Elemento descartado |
|---|---|---|
Wait | [10, 20] hasta que haya espacio | Ninguno por la política; TryWrite(30) devuelve false |
DropWrite | [10, 20] | El nuevo elemento 30 |
DropNewest | [10, 30] | El más reciente que ya estaba en el búfer: 20 |
DropOldest | [20, 30] | El más antiguo que estaba en el búfer: 10 |
El nombre DropNewest merece atención: no significa descartar automáticamente la nueva escritura. El canal elimina el elemento más reciente ya almacenado y abre espacio para el que llega. Confundirlo con DropWrite puede invertir la política deseada.
En los modos de descarte, TryWrite puede devolver true aunque la política haya descartado un elemento. Ese retorno no demuestra que todos los datos permanecieron en la cola, y mucho menos que fueron procesados. La prueba del ejemplo verifica ese comportamiento de forma explícita. Para observar los descartes, la creación del canal puede recibir un callback itemDropped; mantén esa función pequeña, segura y adecuada a la concurrencia de los escritores.
Consideraría DropOldest para estados reemplazables de una visualización, si conservar todos los estados intermedios no es un requisito. No usaría esa política para pedidos o auditoría que exigen un registro completo. Tampoco supondría que descartar el más antiguo crea una regla de “último valor por entidad”: la política actúa sobre la cola y no entiende claves de negocio.
⚠️ Atención: Descartar es una pérdida deliberada de información. Documenta la política, cuenta los elementos descartados y verifica que el dominio admite esa pérdida antes de usar
DropWrite,DropNewestoDropOldest.
La escritura y la lectura asíncronas exigen un ciclo de vida explícito
WriteAsync es una buena opción cuando el productor debe esperar espacio en un canal limitado. TryWrite permite un intento inmediato; en el modo Wait, una cola llena hace que ese intento devuelva false. Ninguna de estas APIs debe interpretarse como confirmación de que el consumidor terminó su operación.
Existen APIs de espera separadas, como WaitToWriteAsync y WaitToReadAsync, pero una indicación de disponibilidad no reserva de forma permanente una posición o un elemento. Con concurrencia, otra tarea puede ocupar el espacio o retirar el dato antes de la operación siguiente. Usa los patrones documentados y evita construir un protocolo propio de reserva sobre una comprobación aislada.
Para una fuente finita, el productor debe señalar la finalización después de la última escritura. TryComplete intenta cerrar el writer sin lanzar la excepción que podría provocar una segunda llamada a Complete. No se acepta ninguna escritura nueva tras el cierre, pero los elementos que ya están en el búfer pueden seguir leyéndose.
En el camino normal, ReadAllAsync hace que ese consumo sea directo:
| |
📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog:
BlogSamples/AsyncParallel/Channels/
También esperaría las tareas consumidoras. Reader.Completion representa el estado de finalización de la lectura del canal; no garantiza que haya terminado una operación de negocio ya iniciada con el último elemento. Cuando el consumidor retira el elemento, este queda fuera del búfer. Solo esperar a los consumidores confirma que sus delegates terminaron, y eso todavía depende de la semántica de esos delegates.
Varios consumidores reparten el trabajo, pero no hacen broadcast
Un canal puede aceptar varios productores y varios consumidores. Cada lectura exitosa retira un elemento de la cola para ese lector; no entrega una copia a todos los consumidores. Si tres consumidores leen el mismo canal, comparten el trabajo. Si todos necesitan recibir cada evento, necesitas otra estrategia de distribución o canales propios para cada suscripción.
También hay una diferencia entre orden de retirada y orden de finalización. Los elementos disponibles en la cola se retiran según la estructura de lectura, pero los consumidores paralelos pueden tardar tiempos distintos en procesarlos. Un elemento posterior puede terminar antes que el anterior. Eso apareció en la demo: todos los enteros se procesaron, pero algunas líneas de la consola salieron fuera de la secuencia numérica.
Si el orden final importa, no prometas conservarlo solo porque los datos pasaron por una cola. Puedes optar por un único consumidor, ordenar los resultados por una secuencia explícita o particionar por una clave que defina la unidad de ordenación. Cada alternativa tiene costos y límites; Channels no elige esa política por ti.
SingleWriter y SingleReader son declaraciones sobre el uso real del canal y permiten optimizaciones. No son un mecanismo de autorización ni una forma de obligar al resto del programa a usar una sola tarea. Configura SingleReader = true solo si no hay lecturas concurrentes. En el ejemplo, ese valor depende de la cantidad de consumidores configurada.
Por último, limita el paralelismo antes de iniciar operaciones costosas. Leer de la cola y crear una task desacoplada para cada elemento puede vaciar el búfer rápidamente, pero dejar miles de operaciones en curso. En ese diseño, el backpressure se debilita: el cuello de botella se trasladó a una lista de tareas que el canal no controla.
Finalización, cancelación y fallo no son el mismo cierre
En la finalización normal, el productor termina sus escrituras, cierra el writer y los consumidores vacían los elementos restantes. Si la intención es procesar todo lo admitido, ese camino es distinto de cancelar de inmediato cada lectura y operación. En un Worker, el tiempo disponible para ese vaciado también depende del límite de cierre configurado por el host.
En la cancelación, la intención es interrumpir el trabajo de forma cooperativa. Propaga el token a la escritura, a la lectura, a la fuente y a la operación consumidora. ReadAllAsync todavía puede entregar datos listos aunque se haya solicitado la cancelación; el ejemplo hace una comprobación explícita antes de empezar a procesar el elemento. Eso no recupera automáticamente un elemento ya retirado de la cola.
En el fallo, es necesario impedir que las tareas que sobreviven queden esperando indefinidamente. Imagina que el único consumidor lanza una excepción mientras el productor está bloqueado en WriteAsync por falta de espacio. Esperar solo Task.WhenAll no cancela a ese productor. Si nadie más retira elementos, puede seguir esperando e impedir que el conjunto termine.
El ejemplo usa una fuente de cancelación vinculada. Se conserva el primer fallo registrado; el writer se finaliza con error, el token compartido se cancela y el código espera todas las tareas antes de propagar el fallo. La política es fail-fast: no promete vaciar el búfer después del error. En la finalización normal, en cambio, el búfer sí se vacía.
No existe una interrupción forzada segura de un delegate arbitrario que ignora la cancelación. Si la fuente o el procesamiento se quedan atascados en una operación que no respeta el token, el cierre puede seguir demorando. Define timeouts en las dependencias y verifica que cooperen. El canal administra su cola; no controla el comportamiento de todo el código externo que llama el pipeline.
Cuándo elegir Channels, Parallel.ForEachAsync o mensajería
Elegiría Channels cuando necesito separar etapas, controlar un búfer y hacer explícita la presión entre producción y consumo dentro del mismo proceso. Si el problema es solo recorrer una colección con un grado de paralelismo limitado, Parallel.ForEachAsync puede requerir menos código de coordinación. No agregaría un canal solo para que un bucle parezca más sofisticado.
El artículo sobre paralelismo en C# analiza herramientas para distribuir trabajo. Por su parte, Worker y Background Service trata la ejecución fuera del ciclo HTTP. Channels puede usarse dentro de esos escenarios, pero no sustituye al host del Worker ni determina la política de concurrencia de las dependencias.
Una operación admitida en un canal local puede perderse si el proceso cae antes de consumirla. El canal no mantiene un log persistente, no ofrece acknowledgement de negocio y no reenvía automáticamente el trabajo cuyo consumidor falló. Por lo tanto, responder a una solicitud con “aceptado” después de encolar en memoria no equivale a garantizar que el trabajo sobrevivirá a un reinicio.
Para la entrega entre procesos, la reanudación y la persistencia, evalúa un broker u otra estructura durable, con garantías adecuadas al dominio. Incluso en esos casos, la duplicidad y la consistencia siguen exigiendo idempotencia y un diseño de almacenamiento. El Transactional Outbox Pattern trata una de esas fronteras.
Channels puede servir como etapa interna de un consumidor de mensajería, pero la confirmación externa debe seguir la política de procesamiento correcta. Retirar un mensaje del canal no es motivo suficiente para confirmar su entrega al broker. El punto de confirmación debe reflejar los efectos durables que la aplicación realmente completó.
Ejemplo Práctico
El ejemplo completo tiene un pipeline reutilizable y una consola independiente en AsyncParallel/Channels/Demo. No es necesario iniciar la API agregadora. El productor genera veinte enteros, dos consumidores ejecutan una operación asíncrona corta y la cola admite cuatro elementos en el búfer. En el cierre normal, el total debe ser veinte.
| |
📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog:
BlogSamples/AsyncParallel/Channels/
Ejecútalo desde la raíz del repositorio de ejemplos:
| |
El orden de las líneas individuales puede cambiar entre ejecuciones. El resultado relevante del camino normal es la línea final (la demo imprime sus mensajes en portugués):
| |
Las pruebas verifican la finalización normal con uno y cuatro consumidores, el fallo del productor, el fallo del consumidor, la cancelación y los cuatro modos de búfer lleno. El caso de DropNewest confirma que el elemento eliminado es el más reciente ya almacenado. Otro caso verifica que un elemento que estaba en el búfer puede leerse incluso después de que TryComplete reciba una excepción, antes de observar la finalización con error.
Durante la preparación de este artículo, los diez casos pasaron ejecutando los mismos archivos de código fuente y de prueba en un proyecto xUnit temporal aislado. La suite agregadora estaba bloqueada en la restauración por alertas de seguridad preexistentes en dependencias criptográficas; no desactivé la auditoría ni consideré aprobada esa suite. La consola independiente compiló y produjo el total esperado.
No presento esta demo como benchmark. La espera de cinco milisegundos representa una operación asíncrona simulada y ayuda a visualizar la concurrencia; no demuestra una ventaja de rendimiento de Channels. Para medir un producto, usa tu carga, tu tamaño de elemento y tus dependencias reales, y compara throughput, latencia, memoria y pérdidas.
Consejos y Buenas Prácticas
- Empieza con capacidad y concurrencia pequeñas. Mide la espera en la escritura y el tiempo de procesamiento antes de aumentar el búfer. Más posiciones pueden aumentar la latencia del trabajo pendiente sin acelerar al consumidor.
- Registra la política de saturación como regla funcional. Explica si el sistema espera, rechaza o descarta, y qué elemento puede perderse. En los modos de descarte, monitorea el callback y no uses solo el retorno de la escritura como contador de procesamiento.
- Espera las tareas, no solo el canal. Cerrar el writer impide nuevas escrituras y permite vaciar el búfer. La finalización de las operaciones ya iniciadas pertenece a los consumidores y debe esperarse explícitamente.
- Propaga la cancelación y conserva el fallo original. Un consumidor que falla debe liberar al productor que espera espacio. Mantén la coordinación centralizada y verifica que la fuente y las operaciones externas respetan los tokens recibidos.
- No desacoples una task por elemento sin límite. La retirada rápida de la cola puede ocultar la acumulación de operaciones en curso. El límite tiene que alcanzar el recurso que realmente procesa el trabajo.
- No confundas concurrencia con broadcast u orden final. Varios lectores se reparten los elementos y pueden terminar fuera de orden. Si el dominio necesita copias para todos o secuencia por entidad, diseña eso por separado.
- Usa persistencia cuando el requisito lo exija. Un canal en memoria no sobrevive al proceso. Para comandos de negocio, define entrega durable e idempotencia en lugar de prometer una recuperación que la estructura no ofrece.
Resumen Objetivo
- System.Threading.Channels transporta datos entre productores y consumidores en el mismo proceso, con APIs concurrentes de lectura y escritura compatibles con operaciones asíncronas.
- Un canal limitado con
Waithace queWriteAsyncespere espacio cuando el búfer se llena; la capacidad no incluye los elementos ya retirados y en procesamiento. - Los modos de descarte tienen políticas distintas:
DropWritepierde la nueva escritura,DropNewestelimina el más reciente ya almacenado yDropOldestelimina el más antiguo del búfer. - Una escritura aceptada no confirma el procesamiento. En los modos de descarte,
TryWritepuede devolvertrueaunque la política haya perdido un elemento. - La finalización normal cierra las escrituras y permite vaciar el búfer; esperar las tareas consumidoras sigue siendo necesario para acompañar sus operaciones.
- El fallo y la cancelación deben coordinarse para no dejar al productor ni a los consumidores esperando indefinidamente. El ejemplo adopta fail-fast ante fallos y cancelación cooperativa.
- Varios consumidores se reparten el trabajo, no reciben copias de todos los elementos, y pueden completar operaciones fuera del orden de entrada.
- La persistencia y la entrega entre procesos no son garantías de Channels; los comandos que deben sobrevivir a reinicios exigen una estrategia durable.
Lee También
- Historial de Git para depuración y auditoría a escala (portugués) — aplicación de un Channel limitado en un pipeline de análisis, sin sustituir esta guía de la biblioteca.
- .NET Worker y Background Service: alto volumen — alojamiento y ciclo de vida del procesamiento en segundo plano.
- Programación Asíncrona en C#: async/await y Threads — fundamentos para entender la espera asíncrona y la cancelación.
- Paralelismo en C#: Parallel, PLINQ y Tasks en la Práctica — alternativas cuando el problema no necesita un pipeline con búfer propio.
- Transactional Outbox Pattern: resolviendo el dual write — la consistencia y la entrega durable son problemas distintos de la coordinación en memoria.
Referencias
- Channels en .NET — conceptos, creación de canales y patrones productor-consumidor.
- BoundedChannelFullMode — definición de los modos de espera y descarte.
- ChannelWriter.TryWrite — intento inmediato de escritura y contrato del retorno.
- ChannelReader.ReadAllAsync — consumo asíncrono y observaciones sobre la cancelación.
- ChannelWriter.TryComplete — finalización del writer, incluso con error.
- Cancelación en subprocesos administrados — modelo cooperativo de cancelación de .NET.
- Ejemplo completo y pruebas de Channels — pipeline y consola usados en el artículo; las pruebas están en el dominio correspondiente de
tests/BlogSamples.Tests/AsyncParallel/Channels/.

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