DIE IRON SUITE VERWENDEN

Mastering Async/Await C# in .NET 10: Das grundlegende Handbuch für skalierbare Anwendungen

Veröffentlicht:

Async/Await C#

Die moderne Softwareentwicklung erfordert Schnelligkeit, Reaktionsfähigkeit und unvergleichliche Skalierbarkeit. In der Welt der Webanwendungen und Unternehmenslösungen ist es einfach inakzeptabel, den UI-Thread zu blockieren oder Serverressourcen zu beanspruchen. Hier wird die asynchrone Programmierung, die durch die leistungsstarken async- und await-Schlüsselwörter in C# unterstützt wird, nicht nur zu einer Funktion, sondern zu einer obligatorischen architektonischen Grundlage.

Für Entwickler, die Hochleistungsbibliotheken wie die Iron Software Suite für PDF-Erzeugung, Bildbearbeitung und OCR verwenden, ist das Verständnis für das Schreiben von asynchronem Code der Schlüssel zur Erstellung von effizientem Code, der die volle Leistungsfähigkeit der .NET Task Parallel Library nutzt.

Wir werden tief in die Mechanik von async/ await C# eintauchen und untersuchen, wie dieser Paradigmenwechsel langsame synchrone Programmierung in durchsatzstarke asynchrone Operationen umwandelt und wie Iron Software Unternehmen hilft, maximale Leistung zu erzielen.

Die Grundlagen der asynchronen Programmierung

Vor async und await wurden asynchrone Operationen durch umständliche Callbacks und manuelle Operationen der Task-Klasse verwaltet, was zu komplexem und fehleranfälligem Code führte. Asynchrone Programmierung in C# vereinfacht dies, indem es Entwicklern erlaubt, Code zu schreiben, der synchron aussieht, sich aber asynchron verhält.

Die beiden Kernkomponenten sind:

  1. Das async-Schlüsselwort: Der async-Modifikator kennzeichnet eine Methode als async-Methode, die await-Ausdrücke enthalten kann. Entscheidend ist, dass die Kennzeichnung einer Methode als asynchron nicht automatisch bedeutet, dass sie in einem Hintergrund-Thread ausgeführt wird. Sie ermöglicht lediglich, dass der Compiler einen ausgeklügelten Zustandsautomaten erzeugt, der die Fortführung des Codes verwaltet. Eine async-Methode gibt im Allgemeinen ein Task-Objekt (Task oder Task) zurück, um die laufende asynchrone Aufgabe darzustellen.

  2. Das Schlüsselwort await: Das Schlüsselwort await ist die magische Komponente. Wenn ein await-Ausdruck auftritt, prüft die Methode, ob die erwartete Aufgabe abgeschlossen ist. Wenn dies nicht der Fall ist, unterbricht die Methode sofort die Ausführung und gibt die Kontrolle an die aufrufende Methode (oder den Aufrufer) zurück. Dadurch wird der aktuelle Thread (oft der Hauptthread oder ein Thread-Pool-Thread) freigegeben, um andere Anfragen oder Aufgaben zu bearbeiten. Wenn die Aufgabe abgeschlossen ist, wird der Rest der Methode als Fortsetzung registriert und für die Ausführung neu geplant.

Hier ist ein grundlegendes Code-Beispiel:

public static async Task<string> DownloadDataAsync(string url)
{
    // The async keyword allows us to use await
    using var client = new HttpClient();

    // await task: Control returns to the caller while the HTTP call happens
    string data = await client.GetStringAsync(url); // I/O-bound 

    // The code after the await expression runs once the task finishes
    return $"Data length: {data.Length}";
}

// Modern entry point for console apps
public static async Task Main(string[] args) 
{
    // This is the static async task main entry point
    var result = await DownloadDataAsync("https://api.example.com/data");
    Console.WriteLine(result);
}
public static async Task<string> DownloadDataAsync(string url)
{
    // The async keyword allows us to use await
    using var client = new HttpClient();

    // await task: Control returns to the caller while the HTTP call happens
    string data = await client.GetStringAsync(url); // I/O-bound 

    // The code after the await expression runs once the task finishes
    return $"Data length: {data.Length}";
}

// Modern entry point for console apps
public static async Task Main(string[] args) 
{
    // This is the static async task main entry point
    var result = await DownloadDataAsync("https://api.example.com/data");
    Console.WriteLine(result);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Die Verwendung der statischen asynchronen Aufgabe main ist der moderne Standard, der es überflüssig macht, den Haupt-Thread mit Legacy-Methoden wie .Wait() oder .Result zu blockieren.

Performance und Iron Software Integration

Während Task der Standard-Rückgabetyp für asynchronen Code ist, wird bei der fortgeschrittenen asynchronen Programmierung in .NET 10 häufig ValueTask verwendet, um bei "heißen Pfaden", bei denen eine synchrone Ausführung wahrscheinlich ist (z. B. beim Abrufen eines zwischengespeicherten Wertes), erhebliche Leistungssteigerungen zu erzielen. ValueTask vermeidet Speicherzuweisungen und ist daher für Anwendungen mit hohem Durchsatz von entscheidender Bedeutung.

Anwendung asynchroner Operationen auf Iron Software

Iron Software Produkte, wie IronOCR (Optical Character Recognition) und IronPDF (PDF Generation), sind perfekte Kandidaten für die Nutzung von asynchronen Aufrufen. Vorgänge wie die Konvertierung eines großen HTML-Dokuments in ein PDF oder das Scannen hunderter Seiten von Bildern nach Text sind oft CPU-gebundene Aufgaben oder beinhalten Dateisystem-E/A, die in hohem Maße von asynchronen Methoden profitieren.

Wenn Sie die von Iron Software bereitgestellten synchronen und asynchronen Methoden verwenden, stellen Sie sicher, dass Ihre Anwendung in hohem Maße reaktionsfähig bleibt.

Erwägen Sie die Verwendung von IronPDF zum Erstellen eines Dokuments von einer bestimmten URL:

public static async Task GeneratePdfFromUrlAsync(string url, string outputFileName)
{
    // 1. Initialize the renderer
    var renderer = new IronPdf.ChromePdfRenderer();

    // Optional: Set rendering options if needed (e.g., margins, headers)
    renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;

    // 2. The core asynchronous operation: Fetch and render the URL content
    // This is an I/O-bound task that releases the calling thread.
    var pdf = await renderer.RenderUrlAsPdfAsync(url);

    // 3. Save the PDF file asynchronously
    await Task.Run(() =>
    {
        // This is the synchronous method you confirmed exists
        pdf.SaveAs(outputFileName);
    });
}
public static async Task GeneratePdfFromUrlAsync(string url, string outputFileName)
{
    // 1. Initialize the renderer
    var renderer = new IronPdf.ChromePdfRenderer();

    // Optional: Set rendering options if needed (e.g., margins, headers)
    renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;

    // 2. The core asynchronous operation: Fetch and render the URL content
    // This is an I/O-bound task that releases the calling thread.
    var pdf = await renderer.RenderUrlAsPdfAsync(url);

    // 3. Save the PDF file asynchronously
    await Task.Run(() =>
    {
        // This is the synchronous method you confirmed exists
        pdf.SaveAs(outputFileName);
    });
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

PDF mit Async-Methoden generiert

PDF asynchron gerendert

Durch die Verwendung der asynchronen Methode RenderHtmlAsPdfAsync() verhindern wir, dass die Anwendung bei der Verarbeitung großer Dokumente einfriert oder blockiert. Es wird gezeigt, wie man asynchronen Code für komplexe Verarbeitungen effizient schreibt.

Beste Praktiken und Grenzfälle

1. die Handhabung mehrerer Tasks und E/A

Um die Effizienz zu maximieren, sollten Sie mehrere Aufgaben gleichzeitig starten, wenn Sie auf unabhängige E/A-gebundene Arbeiten warten, wie z. B. das Abrufen von Daten von einem Remote-Server oder die Durchführung von Datenbankabfragen.

public async Task<string[]> FetchAllDataAsync(string url1, string url2)
{
    // Creating tasks starts the async operation immediately
    Task<string> taskA = DownloadDataAsync(url1); 
    Task<string> taskB = DownloadDataAsync(url2);

    // Wait for all the tasks to complete simultaneously
    string[] results = await Task.WhenAll(taskA, taskB);
    return results;
}
public async Task<string[]> FetchAllDataAsync(string url1, string url2)
{
    // Creating tasks starts the async operation immediately
    Task<string> taskA = DownloadDataAsync(url1); 
    Task<string> taskB = DownloadDataAsync(url2);

    // Wait for all the tasks to complete simultaneously
    string[] results = await Task.WhenAll(taskA, taskB);
    return results;
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dies ist ein Standardmuster für die Erstellung von Aufgaben, die gleichzeitig ausgeführt werden und die Reaktionszeiten von Anwendungen durch die Verwendung von nicht blockierenden asynchronen Operationen drastisch beschleunigen.

2. der Synchronisationskontext und ConfigureAwait(false)

Wenn eine erwartete Aufgabe abgeschlossen wird, besteht das Standardverhalten darin, den Synchronisierungskontext zu erfassen und sicherzustellen, dass die Fortsetzung auf demselben Thread (wie dem UI-Thread) ausgeführt wird. Dies ist für UI-Anwendungen von entscheidender Bedeutung, verursacht aber unnötigen Overhead in serverseitigem oder Bibliothekscode.

Die Verwendung von ConfigureAwait(false) teilt der Laufzeitumgebung mit, dass der Code nach dem await-Aufruf auf allen verfügbaren Threadpool-Hintergrundthreads fortgesetzt werden kann. Dies ist ein wichtiges Verfahren für Bibliotheksentwickler, um maximale Leistung für asynchrone Operationen zu gewährleisten:

// Critical for shared libraries to avoid deadlocks and improve throughput
var data = await GetVarDataFromRemoteServer().ConfigureAwait(false); 
// This code continues on any thread, improving resource usage.
// Critical for shared libraries to avoid deadlocks and improve throughput
var data = await GetVarDataFromRemoteServer().ConfigureAwait(false); 
// This code continues on any thread, improving resource usage.
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

3. die Gefahr von async void

Eine der wichtigsten Regeln bei der asynchronen Programmierung ist es, async void nur für asynchrone Event-Handler zu verwenden. Zum Beispiel wird eine Methode zur Behandlung von Schaltflächenklicks typischerweise async void verwenden:

private async void Button_Click(object sender, EventArgs e) // event handler
{
    // This is one of the few places async void is acceptable
    await GenerateReportAsync(html);
}
private async void Button_Click(object sender, EventArgs e) // event handler
{
    // This is one of the few places async void is acceptable
    await GenerateReportAsync(html);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Von jeder anderen Verwendung von asynchronen ungültigen Methoden wird dringend abgeraten. Da eine async void-Methode keine awaited task sein kann, kann der aufrufende Thread ihren Abschluss nicht verfolgen oder Ausnahmen zuverlässig behandeln, was die Fehlerbehandlung problematisch macht. Geben Sie bei allen anderen asynchronen Methoden immer Task oder Task zurück.

4. die Behandlung von Ausnahmen

Eine solide Ausnahmebehandlung ist unerlässlich. Wenn ein asynchroner Vorgang fehlschlägt (z. B. wenn ein Webdienstaufruf auf einen Fehler stößt), wird die Ausnahme im Task-Objekt gespeichert. Wenn Sie die Aufgabe abwarten, wirft der await-Ausdruck die Ausnahme auf den aktuellen Thread (denjenigen, der die Fortsetzung fortsetzt), so dass standardmäßige try...catch-Blöcke effektiv für die Ausnahmebehandlung eingesetzt werden können.

Abschluss

Das async- und await-Muster in C# ist ein Paradigmenwechsel, der Entwickler weg von der spröden synchronen Programmierung hin zu belastbaren, skalierbaren asynchronen Methoden bringt. Durch das Verständnis des zugrunde liegenden Zustandsautomaten und die Einhaltung von Best Practices - wie die Bevorzugung von Task gegenüber async void, die Verwendung von ConfigureAwait(false) in Bibliotheken und die korrekte Implementierung der Ausnahmebehandlung - können Entwickler Anwendungen erstellen, die komplexe Verarbeitungsaufgaben (wie die in der Suite von Iron Software) mit außergewöhnlicher Leistung bewältigen.

Iron Software hat sich der Entwicklung von Produkten verschrieben, deren Kernstück die asynchrone Hochleistungsprogrammierung ist, um sicherzustellen, dass Sie beim Schreiben von Code einen maximalen Durchsatz erzielen. Entdecken Sie die Welt von Iron Software und erfahren Sie, wie die asynchrone Task-Verarbeitung die Geschwindigkeit und Reaktionsfähigkeit Ihrer Anwendung drastisch verbessern kann