Neu in .NET 10.0 [26]: LINQ-Operationen auf IAsyncEnumerable

IAsyncEnumerable ist die in .NET Core 3.0 eingeführte asynchrone Variante von IEnumerable. Sie ermöglicht asynchrone Streams: das schrittweise, nicht-blockierende Iterieren über Daten, die asynchron bereitgestellt werden.

LINQ-Operationen auf IAsyncEnumerable erforderten bisher das NuGet-Paket System.Linq.Async. Nun ist diese Funktionalität im Kern von .NET verfügbar.

Folgender Code nutzt Where() und OrderBy() mit IAsyncEnumerable:

namespace NET10_Console.FCL;

using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

public readonly record struct Kabinettsmitglied(string Name, string Amt);

/// 
public class FCL10_LINQAsyncEnumerable
{
 public async Task Run()
 {
  CUI.Demo(nameof(FCL10_LINQAsyncEnumerable));

  // Hole Personen im Bundeskabinett
  var datenquelle = new Bundeskabinett().GetAll();

  // Asynchrone Iteration mit LINQ (Filtern und optional Sortieren)
  // Achtung: .OrderBy(x=>x.Name) führt dazu, dass foreach auf das letzte Element warten muss --> Vorteil von async entfällt :-(
  await foreach (var person in datenquelle.Where(x => x.Amt.Contains("ministerin")))
  {
   Console.WriteLine(DateTime.Now.ToLongTimeString() + ": " + person);
  }
 }

 public class Bundeskabinett
 {
  /// 
  public async IAsyncEnumerable GetAll(
      [EnumeratorCancellation] CancellationToken cancellationToken = default)
  {
   // Quelle: 
   var daten = new List
        {
            new("Friedrich Merz", "Bundeskanzler"),
            new("Lars Klingbeil", "Bundesminister der Finanzen"),
            new("Alexander Dobrindt", "Bundesminister des Innern"),
            new("Dr. Johann Wadephul", "Bundesminister des Auswärtigen"),
            new("Boris Pistorius", "Bundesminister der Verteidigung"),
            new("Katherina Reiche", "Bundesministerin für Wirtschaft und Energie"),
            new("Dorothee Bär", "Bundesministerin für Forschung, Technologie und Raumfahrt"),
            new("Dr. Stefanie Hubig", "Bundesministerin der Justiz und für Verbraucherschutz"),
            new("Karin Prien", "Bundesministerin für Bildung, Familie, Senioren, Frauen und Jugend"),
            new("Bärbel Bas", "Bundesministerin für Arbeit und Soziales"),
            new("Dr. Karsten Wildberger", "Bundesminister für Digitales und Staatsmodernisierung"),
            new("Patrick Schnieder", "Bundesminister für Verkehr"),
            new("Carsten Schneider", "Bundesminister für Umwelt, Klimaschutz, Naturschutz und nukleare Sicherheit"),
            new("Nina Warken", "Bundesministerin für Gesundheit"),
            new("Alois Rainer", "Bundesminister für Landwirtschaft, Ernährung und Heimat"),
            new("Reem Alabali Radovan", "Bundesministerin für wirtschaftliche Zusammenarbeit und Entwicklung"),
            new("Verena Hubertz", "Bundesministerin für Wohnen, Stadtentwicklung und Bauwesen"),
            new("Thorsten Frei", "Bundesminister für besondere Aufgaben / Chef des Bundeskanzleramtes"),
        };

   foreach (var m in daten)
   {
    cancellationToken.ThrowIfCancellationRequested();
    yield return m;
    await Task.Delay(200); // Simuliere etwas Wartezeit
    await Task.Yield(); // sorgt für echte Asynchronität beim Streamen
   }
  }
 }
}

Ein Praxisbeispiel dazu: Folgender Code zeigt die Ausführung einer Reihe von HTTP-Aufrufen mit asynchroner Ausgabe der Ergebnisse via Task.WhenEach(). Hier ist nun ein Filtern mit Where() oder eine Sortierung mit OrderBy() möglich. Diese blockiert jedoch – wie üblich – die Weiterverarbeitung, bis das letzte Ergebnis vorliegt, und beeinträchtigt damit den Vorteil der asynchronen Ausführung.

public async Task Run()
{
 CUI.Demo(nameof(FCL10_LINQAsyncEnumerable));
 Console.WriteLine($"{DateTime.Now.ToLongTimeString()}: Starte Websiteabfragen...");
 using HttpClient http = new();
 Task t1 = http.GetAsync("
 Task t2 = http.GetAsync("
 Task t3 = http.GetAsync("
 Task t4 = http.GetAsync("
 Task t5 = http.GetAsync("
 Task t6 = http.GetAsync("
 Task t7 = http.GetAsync("
 // Liste aus Tasks
 List> taskList = new() { t1, t2, t3, t4, t5, t6, t7 };
 // WhenEach() gibt es seit .NET 9.0
 IAsyncEnumerable> taskList2 = Task.WhenEach(taskList);
 
 // NEU in .NET 10.0: LINQ auf IAsyncEnumerable
 taskList2 = taskList2.Where(x => x.Result.RequestMessage.RequestUri.ToString().Contains("dot"));
 taskList2 = taskList2.OrderBy(x => x.Result.RequestMessage.RequestUri.Host);

 await foreach (Task t in taskList2)
 {
  try
  {
   Console.WriteLine($"{DateTime.Now.ToLongTimeString()}: {t.Status} {t.Result?.RequestMessage?.RequestUri} = {t?.Result?.StatusCode}"); // Status des HTTP-Aufrufs
  }
  catch (Exception ex)
  {
   CUI.Warning(ex);
  }
 }
}

(rme)