C# Academy · Leçon

System.Threading.Channels

Créez des chaînes de traitement producteur-consommateur avec Channel, ChannelWriter et ChannelReader pour contrôler la contre-pression.

System.Threading.Channels est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Que sont les canaux ?

System.Threading.Channels (introduit avec .NET Core 3) fournit une file d’attente producteur-consommateur thread-safe et hautes performances. Contrairement à BlockingCollection, les canaux sont entièrement asynchrones et optimisés en matière d’allocations : ils sont idéaux pour les chaînes de traitement en processus.

Créer un canal

Les canaux sont créés à l’aide d’une fabrique. Choisissez unbounded (sans limite) ou bounded (capacité limitée avec régulation de la pression). La fabrique renvoie un Channel<T> doté d’un Writer et d’un Reader.

using System.Threading.Channels;

// Unbounded: unlimited capacity, no backpressure
var unbounded = Channel.CreateUnbounded<string>();

// Bounded: max 100 items; writer waits when full
var bounded = Channel.CreateBounded<string>(100);

// Bounded with drop-oldest strategy:
var dropping = Channel.CreateBounded<string>(new BoundedChannelOptions(50)
{
    FullMode = BoundedChannelFullMode.DropOldest
});

Écrire dans un canal

Les producteurs écrivent les éléments à l’aide de WriteAsync (attend si le canal borné est plein) ou de TryWrite (renvoie immédiatement false s’il est plein). Signalez la fin avec Writer.Complete().

var channel = Channel.CreateUnbounded<int>();

// Producer task
var producer = Task.Run(async () =>
{
    for (int i = 0; i < 100; i++)
    {
        await channel.Writer.WriteAsync(i);
        await Task.Delay(10);
    }
    channel.Writer.Complete(); // signal no more items
});

Lire depuis un canal

Les consommateurs lisent avec ReadAllAsync() (l’approche la plus simple) ou avec ReadAsync/TryRead pour davantage de contrôle. ReadAllAsync se termine lorsque le rédacteur appelle Complete().

// Consumer task
var consumer = Task.Run(async () =>
{
    await foreach (var item in channel.Reader.ReadAllAsync())
    {
        Console.WriteLine($"Processed: {item}");
        // Naturally paced — waits for next item
    }
    Console.WriteLine("Channel completed");
});

await Task.WhenAll(producer, consumer);

Plusieurs producteurs

Les canaux sont thread-safe. Plusieurs producteurs peuvent écrire simultanément, sans verrouillage nécessaire. Appelez Writer.Complete() uniquement après la fin de tous les producteurs.

var channel = Channel.CreateUnbounded<WorkItem>();

var producers = Enumerable.Range(0, 4).Select(id =>
    Task.Run(async () =>
    {
        for (int i = 0; i < 25; i++)
            await channel.Writer.WriteAsync(new WorkItem(id, i));
    }));

// Wait for all producers before completing the writer
await Task.WhenAll(producers);
channel.Writer.Complete();

Plusieurs consommateurs (répartition)

Exécutez plusieurs tâches de consommateur sur le même lecteur de canal afin de paralléliser le traitement. Chaque élément est transmis à un seul consommateur exactement : les éléments sont répartis, et non diffusés à tous.

var channel = Channel.CreateBounded<WorkItem>(100);

// 4 parallel consumers
var consumers = Enumerable.Range(0, 4).Select(id =>
    Task.Run(async () =>
    {
        await foreach (var item in channel.Reader.ReadAllAsync())
        {
            await ProcessItemAsync(item);
            Console.WriteLine($"Consumer {id} processed {item.Id}");
        }
    }));

await Task.WhenAll(consumers);

Motif de chaîne de traitement

Reliez les canaux pour former une chaîne de traitement : chaque étape lit depuis un canal, traite les éléments, puis écrit dans le suivant. Les étapes s’exécutent simultanément avec une régulation naturelle de la pression.

// Stage 1: raw data
var stage1 = Channel.CreateBounded<string>(50);
// Stage 2: parsed
var stage2 = Channel.CreateBounded<ParsedRecord>(50);
// Stage 3: enriched
var stage3 = Channel.CreateBounded<EnrichedRecord>(50);

var parse   = ParseStageAsync(stage1.Reader, stage2.Writer);
var enrich  = EnrichStageAsync(stage2.Reader, stage3.Writer);
var persist = PersistStageAsync(stage3.Reader);

await Task.WhenAll(parse, enrich, persist);

Régulation de la pression avec les canaux bornés

Un canal borné applique automatiquement une régulation de la pression : lorsque le canal est plein, WriteAsync suspend le producteur jusqu’à ce que le consommateur retire des éléments. Aucun code manuel de limitation n’est nécessaire.

// Bounded channel: max 10 items
var channel = Channel.CreateBounded<string>(10);

// Fast producer
var producer = Task.Run(async () =>
{
    for (int i = 0; i < 1000; i++)
    {
        // WriteAsync waits when channel has 10 items
        await channel.Writer.WriteAsync($"item-{i}");
        // Producer is naturally slowed to consumer speed
    }
    channel.Writer.Complete();
});

// Slow consumer
var consumer = Task.Run(async () =>
{
    await foreach (var item in channel.Reader.ReadAllAsync())
    {
        await Task.Delay(50); // simulate slow processing
        Console.WriteLine(item);
    }
});

Gestion des erreurs dans les canaux

Transmettez une exception à Writer.Complete(exception) pour propager les erreurs à tous les lecteurs en attente. Les lecteurs voient l’exception lors de la prochaine lecture du canal.

var channel = Channel.CreateUnbounded<int>();

var producer = Task.Run(async () =>
{
    try
    {
        for (int i = 0; i < 100; i++)
        {
            if (i == 50) throw new Exception("Producer failed at 50");
            await channel.Writer.WriteAsync(i);
        }
        channel.Writer.Complete();
    }
    catch (Exception ex)
    {
        channel.Writer.Complete(ex); // propagate to reader
    }
});

try
{
    await foreach (var item in channel.Reader.ReadAllAsync())
        Console.WriteLine(item);
}
catch (Exception ex)
{
    Console.Error.WriteLine($"Channel error: {ex.Message}");
}

Cas réel : file d’attente de travaux en arrière-plan

Une file d’attente de travaux en arrière-plan utilisant un service hébergé et un canal : les requêtes HTTP mettent les travaux en file d’attente ; un processus d’arrière-plan les traite un par un.

public class JobQueue
{
    private readonly Channel<Func<CancellationToken, Task>> _queue
        = Channel.CreateBounded<Func<CancellationToken, Task>>(100);

    public ChannelWriter<Func<CancellationToken, Task>> Writer => _queue.Writer;
    public ChannelReader<Func<CancellationToken, Task>> Reader => _queue.Reader;
}

public class JobProcessor : BackgroundService
{
    private readonly JobQueue _queue;
    public JobProcessor(JobQueue q) => _queue = q;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        await foreach (var job in _queue.Reader.ReadAllAsync(ct))
            await job(ct);
    }
}

Vérification rapide

Que se passe-t-il lorsqu’un producteur appelle WriteAsync sur un canal borné plein ?

Récapitulatif : System.Threading.Channels

Points clés à retenir :

Les canaux fournissent une file d’attente producteur-consommateur hautes performances et native de l’asynchronisme
Sans limite : aucune limite ; borné : capacité finie avec régulation de la pression ou stratégies d’abandon
Plusieurs producteurs et consommateurs peuvent être utilisés en toute sécurité sans verrouillage
ReadAllAsync() + await foreach = le mode de consommation le plus simple
Reliez les canaux pour former des chaînes de traitement concurrentes organisées par étapes
Appelez Writer.Complete() (ou Complete(exception)) pour signaler la fin du flux

Questions Fréquemment Posées

La leçon « System.Threading.Channels » est-elle gratuite ?

Oui — le texte complet de « System.Threading.Channels » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « System.Threading.Channels » ?

Créez des chaînes de traitement producteur-consommateur avec Channel, ChannelWriter et ChannelReader pour contrôler la contre-pression. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « System.Threading.Channels » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

IAsyncEnumerable et await foreach
System.Threading.Channels
ValueTask et réduction des allocations
ConfigureAwait et contexte de synchronisation

← Retour à C# Academy