Aufgabenwarteschlangen in C# (.NET): Überblick über Bibliotheken und Implementierungen

Aufgabenwarteschlangen für C# (.NET): Von grundlegenden Primitiven bis zu industriellen Lösungen

Die Organisation der asynchronen Aufgabenverarbeitung ist eine der zentralen Aufgaben bei der Entwicklung hochlastiger Anwendungen in C#. Im .NET-Ökosystem gibt es mehrere Ansätze: von integrierten Synchronisationsprimitiven bis hin zu leistungsstarken externen Bibliotheken. In diesem Artikel betrachten wir die wichtigsten Werkzeuge für die Arbeit mit Aufgabenwarteschlangen, ihre Stärken und Anwendungsbeispiele.

1. System.Threading.Channels — integriertes .NET-Werkzeug

Seit .NET Core 2.1 ist die Klasse System.Threading.Channels.Channel<T> in der Standardbibliothek enthalten. Es handelt sich um eine threadsichere Warteschlange, die für Producer-Consumer-Szenarien optimiert ist.

Hauptfunktionen:

• Asynchrones Lesen und Schreiben (WriteAsync, ReadAsync)
• Unterstützung für begrenzte und unbegrenzte Warteschlangen
• Möglichkeit, die Warteschlange zu schließen, um Verbraucher zu signalisieren
• Hohe Leistung ohne Sperren

Anwendungsbeispiel:

using System.Threading.Channels;

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

// Producervar producer = Task.Run(async () =>{    for (int i = 0; i < 10; i++)    {        await channel.Writer.WriteAsync($"Task {i}");        await Task.Delay(100);    }    channel.Writer.Complete();});

// Consumervar consumer = Task.Run(async () =>{    await foreach (var item in channel.Reader.ReadAllAsync())    {        Console.WriteLine($"Processing: {item}");        await Task.Delay(200);    }});

await Task.WhenAll(producer, consumer);

Wann verwenden: Für interne Warteschlangen innerhalb eines Prozesses, wenn keine Persistenz oder verteilte Verarbeitung erforderlich ist.

2. Hangfire — Fortschrittliche Bibliothek für Hintergrundaufgaben

Hangfire ist eine der beliebtesten Bibliotheken zur Verwaltung von Hintergrundaufgaben in .NET. Sie unterstützt Warteschlangen, Planung, Wiederholungsversuche und Überwachung.

Hauptmerkmale:

• Persistenz (SQL Server, Redis, PostgreSQL u.a.)
• Weboberfläche zur Überwachung
• Unterstützung für verzögerte und wiederkehrende Aufgaben
• Automatische Wiederholungsversuche bei Fehlern

Beispiel für Einrichtung und Verwendung:

// Installation: Install-Package Hangfire// In Startup.cspublic void ConfigureServices(IServiceCollection services){    services.AddHangfire(config =>        config.UseSqlServerStorage(connectionString));    services.AddHangfireServer();}

// Verwendungpublic class EmailService{    public void SendWelcomeEmail(int userId)    {        // Logik zum Senden der E-Mail        Console.WriteLine($"Sending email to user {userId}");    }}

// Aufgabe in die Warteschlange stellenBackgroundJob.Enqueue<EmailService>(x => x.SendWelcomeEmail(42));

// Verzögerte AufgabeBackgroundJob.Schedule<EmailService>(    x => x.SendWelcomeEmail(43),     TimeSpan.FromMinutes(5));

Wann verwenden: Für Webanwendungen, bei denen die Aufgabenspeicherung zwischen Neustarts, Überwachung und flexible Planung erforderlich sind.

3. RabbitMQ.Client — Verteilte Nachrichtenwarteschlange

Für verteilte Systeme, in denen mehrere Dienste Aufgaben austauschen müssen, wird RabbitMQ verwendet. Die Bibliothek RabbitMQ.Client bietet vollständigen Zugriff auf das AMQP-Protokoll.

Basisbeispiel Producer-Consumer:

using RabbitMQ.Client;using System.Text;

// Producervar factory = new ConnectionFactory() { HostName = "localhost" };using var connection = factory.CreateConnection();using var channel = connection.CreateModel();

channel.QueueDeclare(queue: "task_queue",                     durable: true,                     exclusive