UTILISATION DE LA SUITE IRON

Mastering Async/Await C# in .NET 10 : The Essential Guide for Scalable Applications (en anglais)

Mis à jour:

Async/Await C#

Le développement de logiciels modernes exige rapidité, réactivité et évolutivité inégalée. Dans le monde des applications web et des solutions d'entreprise, il est tout simplement inacceptable de bloquer le fil de l'interface utilisateur ou d'accaparer les ressources du serveur. C'est ici que la programmation asynchrone, alimentée par les puissants mots-clés async et await dans C#, devient non seulement une fonctionnalité, mais une base architecturale obligatoire.

Pour les développeurs qui utilisent des bibliothèques hautes performances, telles que la Suite IronPDF pour la génération de PDF, la manipulation d'images et OCR, il est essentiel de comprendre comment écrire du code asynchrone pour construire un code efficace qui exploite toute la puissance de la bibliothèque .NET Task Parallel Library.

Nous nous plongerons dans les mécanismes de l'asynchronisme et de l'attente en C#, en explorant comment ce changement de paradigme transforme la programmation synchrone lente en opérations asynchrones à haut débit, et en reliant ces concepts critiques à la façon dont Iron Software aide les entreprises à atteindre des performances maximales.

Les fondamentaux de la programmation asynchrone

Avant async et await, les opérations asynchrones étaient gérées par des rappels encombrants et des opérations manuelles de la classe Task, ce qui conduisait à un code complexe et sujet aux erreurs. La programmation asynchrone en C# a simplifié cela en permettant aux développeurs d'écrire du code qui looks code synchrone mais se comporte de manière asynchrone.

Les deux composantes principales sont les suivantes :

  1. Le mot-clé async: Le modificateur async indique qu'une méthode est une méthode async qui peut contenir des expressions await. Il est important de noter que le fait de marquer une méthode comme asynchrone ne l'exécute pas automatiquement sur un fil d'exécution en arrière-plan. Il permet simplement au compilateur de générer une machine à états sophistiquée qui gère la suite du code. Une méthode asynchrone renvoie généralement un objet Task (Task ou Task) pour représenter la tâche asynchrone en cours.

  2. Le mot-clé await: Le mot-clé await est le composant magique. Lorsqu'une expression await est rencontrée, la méthode vérifie si la tâche attendue est terminée. Si ce n'est pas le cas, la méthode interrompt immédiatement l'exécution et renvoie le contrôle à la méthode appelante (ou à l'appelant). La traduction doit rester professionnelle, en préservant la précision technique tout en expliquant les caractéristiques et les avantages de ces outils de développement. Lorsque la tâche est terminée, le reste de la méthode est enregistré comme une continuation et son exécution est reprogrammée.

Voici un exemple de code fondamental :

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

L'utilisation de la tâche asynchrone statique main est la norme moderne, éliminant le besoin de bloquer le fil principal à l'aide de méthodes traditionnelles telles que .Wait() ou .Result.

Performance et intégration des logiciels Iron Software

Bien que Task soit le type de retour standard pour le code asynchrone, la programmation asynchrone avancée dans .NET 10 utilise souvent ValueTask pour des gains de performance significatifs dans les "chemins chauds" où l'achèvement synchrone est probable (par exemple, la récupération d'une valeur mise en cache). ValueTask évite les allocations de mémoire, ce qui le rend essentiel pour les applications à haut débit.

Application des opérations asynchrones aux logiciels Iron Software

Iron Software produits, comme IronOCR (reconnaissance optique de caractères) et IronPDF (génération de PDF), sont des candidats parfaits pour tirer parti des appels asynchrones. Des opérations telles que la conversion d'un grand document HTML en PDF ou la numérisation de centaines de pages d'images pour le texte sont souvent des tâches liées à l'unité centrale ou impliquent des E/S de système de fichiers, bénéficiant immensément des méthodes asynchrones.

Lorsque vous utilisez les méthodes synchrones et asynchrones fournies par Iron Software, vous vous assurez que votre application reste très réactive.

Envisagez d'utiliser IronPDF pour créer un document à partir d'une URL spécifiée :

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 généré à l'aide de méthodes asynchrones

PDF rendu asynchrone

En utilisant la méthode asynchrone RenderHtmlAsPdfAsync(), nous évitons que l'application ne se fige ou ne se bloque lors du traitement de documents volumineux. Il s'agit de montrer comment écrire efficacement du code asynchrone pour un traitement complexe.

Bonnes pratiques et cas particuliers

1. gérer des tâches multiples et des entrées/sorties

Pour maximiser l'efficacité, vous devez lancer plusieurs tâches simultanément lorsque vous attendez un travail indépendant lié aux E/S, tel que la récupération de données d'un serveur distant ou l'exécution de requêtes de base de données.

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

Il s'agit d'un modèle standard pour créer des tâches qui s'exécutent simultanément, ce qui permet d'accélérer considérablement les temps de réponse des applications en utilisant des opérations asynchrones non bloquantes.

<Contexte de synchronisation et ConfigureAwait(false) 2

Lorsqu'une tâche attendue se termine, le comportement par défaut est de capturer le contexte de synchronisation et de s'assurer que la suite s'exécute sur le même thread (comme le thread de l'interface utilisateur). Cette précision est essentielle pour les applications d'interface utilisateur, mais elle entraîne des surcharges inutiles dans le code côté serveur ou dans le code de la bibliothèque.

L'utilisation de ConfigureAwait(false) indique au moteur d'exécution que le code après l'appel await peut reprendre sur tous les threads d'arrière-plan disponibles du pool de threads. Il s'agit d'une pratique essentielle pour les développeurs de bibliothèques, qui garantit des performances maximales pour les opérations asynchrones :

// 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. le danger de l'async void

L'une des règles les plus importantes de la programmation asynchrone est de ne jamais utiliser async void, sauf pour les gestionnaires d'événements asynchrones. Par exemple, une méthode de gestion de l'événement de clic sur un bouton utilisera typiquement async void :

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

Toute autre utilisation des méthodes asynchrones void est fortement déconseillée. Étant donné qu'une méthode async void ne peut pas être attendue, le thread appelant ne peut pas suivre son achèvement ou gérer les exceptions de manière fiable, ce qui rend la gestion des erreurs problématique. Toutes les autres méthodes asynchrones renvoient toujours Task ou Task.

4 Traitement des exceptions

Une gestion robuste des exceptions est essentielle. Lorsqu'une opération asynchrone échoue (par exemple, un appel à un service web qui rencontre une erreur), l'exception est stockée dans l'objet tâche. Lorsque vous attendez la tâche, l'expression await rejette l'exception sur le thread courant (celui qui reprend la suite), ce qui permet aux blocs try...catch standard de fonctionner efficacement pour la gestion des exceptions.

Conclusion

Le modèle async et await en C# est une fonctionnalité qui change le paradigme, éloignant les développeurs de la programmation synchrone fragile vers des méthodes asynchrones résilientes et évolutives. En comprenant la machine d'état sous-jacente et en adhérant aux meilleures pratiques - comme la priorisation de Task par rapport à async void, l'utilisation de ConfigureAwait(false) dans les bibliothèques et la mise en œuvre correcte du traitement des exceptions - les développeurs peuvent créer des applications qui gèrent des tâches de traitement complexes (comme celles de la suite d'Iron Software) avec des performances exceptionnelles.

Iron Software s'engage à développer des produits dont la programmation asynchrone haute performance est au cœur, garantissant que vos pratiques d'écriture de code se traduisent par un débit maximal. Explorez le monde d'Iron Software et découvrez comment l'exploitation du traitement des tâches asynchrones peut améliorer considérablement la vitesse et la réactivité de votre application