KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C#

Channel — asynchrone gegevensoverdracht tussen producent en consument

System.Threading.Channels.Channel maakt kanalen die producenten en consumenten met elkaar verbinden. Een begrensd kanaal kan asynchroon wachten tot er ruimte beschikbaar is; een onbegrensd kanaal stelt geen limiet aan het aantal items. Opties beschrijven ook garanties voor gelijktijdige lees- en schrijfopdrachten.

Versie: .NET 10; repository net10.0 and LangVersion=preview; feature versions require per-entry verification

Syntax

Channel<T> channel = Channel.CreateBounded<T>(new BoundedChannelOptions(capacity) { FullMode = BoundedChannelFullMode.Wait, SingleReader = true, SingleWriter = true });
Channel<T> unbounded = Channel.CreateUnbounded<T>(new UnboundedChannelOptions());

System.Threading.Channels.Channel is een statische factoryklasse, terwijl Channel<T> Writer en Reader beschikbaar maakt. Channel.CreateBounded<T> en Channel.CreateUnbounded<T> maken FIFO-wachtrijen voor asynchrone gegevensoverdracht. Meerdere consumenten verdelen de items onderling: een kanaal stuurt niet elk item naar iedereen. De hier besproken API's zijn beschikbaar in .NET 10; het voorbeeld vereist geen previewtaalfuncties.

BoundedChannelOptions stelt de capaciteit van het kanaal in en bepaalt wat er gebeurt als het kanaal geen volgend item kan aannemen. In .NET 10 kan de capaciteit positief of 0 zijn. Bij een capaciteit van 0 heeft het kanaal geen buffer: een schrijfactie moet aan een leesactie worden gekoppeld om het item rechtstreeks over te dragen. Als een schrijfactie niet meteen kan doorgaan, wacht WriteAsync in de standaardmodus BoundedChannelFullMode.Wait asynchroon op ruimte in de buffer of, bij een kanaal zonder buffer, op een bijbehorende leesactie. Daarbij wordt geen thread geblokkeerd; TryWrite retourneert in dezelfde situatie false. Dit zorgt voor backpressure, waardoor de producent wordt afgeremd. De andere modi voor een vol kanaal kunnen items weggooien.

UnboundedChannelOptions configureert een kanaal zonder vaste capaciteitslimiet, gemaakt met Channel.CreateUnbounded<T>. Schrijfacties wachten niet op ruimte, maar als de producent de consument voortdurend voorblijft, kan de buffer steeds meer geheugen gebruiken. Beide optietypen erven ChannelOptions.SingleReader en ChannelOptions.SingleWriter. De waarde true belooft hoogstens één lees- of schrijfactie tegelijk en maakt optimalisaties mogelijk; het is geen vergrendeling die deze regel afdwingt. Laat de waarde op false staan als je die garantie niet kunt geven.

Roep na afloop van het schrijven Writer.Complete() aan: ReadAllAsync() leegt de buffer en beëindigt de iteratie. Zijn er meerdere producenten, voltooi het kanaal dan pas nadat alle schrijvers klaar zijn. Een fout kan via TryComplete(error) worden doorgegeven en een annuleringstoken kan het wachten onderbreken. Voer producent en consument gelijktijdig uit; wachten tot de producent klaar is voordat je begint te lezen kan een deadlock veroorzaken als een kanaal in de modus Wait vol raakt.

Voorbeelden

using System;
using System.Threading.Channels;
using System.Threading.Tasks;

Channel<int> channel = Channel.CreateBounded<int>(
    new BoundedChannelOptions(1)
    {
        FullMode = BoundedChannelFullMode.Wait,
        SingleReader = true,
        SingleWriter = true
    });

Task producer = ProduceAsync(channel.Writer);

await foreach (int value in channel.Reader.ReadAllAsync())
{
    Console.WriteLine(value);
}

await producer;

static async Task ProduceAsync(ChannelWriter<int> writer)
{
    try
    {
        for (int value = 1; value <= 3; value++)
        {
            await writer.WriteAsync(value);
        }
        writer.Complete();
    }
    catch (Exception error)
    {
        writer.TryComplete(error);
        throw;
    }
}

Resultaat

1
2
3

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen