C# Task.Run (Comment ça marche pour les développeurs)

Introduction

Dans cet article, nous nous penchons sur les principes fondamentaux des Task.Run en C#, une construction puissante dans la programmation asynchrone. La programmation asynchrone est essentielle pour écrire des applications réactives et efficaces, en particulier lorsqu'il s'agit d'opérations qui peuvent bloquer l'exécution de votre application, comme les appels réseau ou les tâches de calcul intenses. Task.Run est l'une des méthodes asynchrones couramment utilisées pour décharger ces opérations sur un thread d'arrière-plan, améliorant ainsi les performances et la réactivité des applications. Nous allons explorer la méthode Task.Run et la méthode Bibliothèque IronPDF avec elle.

Comprendre Task.Run

Task.Run est une méthode d'appel fournie par .NET Core qui permet aux développeurs d'exécuter du code lié au processeur ou des opérations liées aux E/S de manière asynchrone sur un thread distinct du pool de threads. Cette méthode permet de maintenir la réactivité du fil de l'interface utilisateur en utilisant un fil asynchrone pour les opérations de longue durée. Il simplifie le lancement d'une nouvelle opération asynchrone sur un autre thread, qui peut ensuite être attendue à l'aide du mot-clé await.

Utilisation de base de Task.Run

Prenons un exemple simple où vous devez effectuer un long calcul. Au lieu d'exécuter cette tâche directement sur le thread principal, ce qui bloquerait l'interface utilisateur, vous pouvez utiliser Task.Run pour la gérer en arrière-plan :

static async Task PerformComputation() 
{
    int result = await Task.Run(() =>
    {
        int sum = 0;
        for (int i = 0; i < 1000000; i++)
        {
            sum += i;
        }
        return sum;
    });
    Console.WriteLine($"The result is {result}");
}

static async Task PerformComputation() 
{
    int result = await Task.Run(() =>
    {
        int sum = 0;
        for (int i = 0; i < 1000000; i++)
        {
            sum += i;
        }
        return sum;
    });
    Console.WriteLine($"The result is {result}");
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Sortie

Dans l'exemple ci-dessus, l'expression lambda à l'intérieur de Task.Run représente un bloc de code lié au processeur qui additionne une large gamme de nombres. En utilisant Task.Run, ce calcul est déchargé sur un thread d'arrière-plan, ce qui permet au thread principal de rester réactif. Le mot-clé await est utilisé pour attendre de manière asynchrone que la tâche se termine, sans bloquer le thread en cours.

Approfondir les tâches asynchrones et les threads

Lorsque vous invoquez Task.Run, le Framework .NET affecte un thread du pool de threads à l'exécution de la tâche spécifiée. Cette méthode est efficace car elle évite la création de nouveaux threads pour chaque tâche et permet d'utiliser les ressources du système de manière plus efficace. Le pool de threads gère un ensemble de threads de travail pour votre application, qui peut exécuter plusieurs tâches simultanément sur plusieurs cœurs.

Gestion de tâches multiples

Vous pouvez exécuter une nouvelle tâche simultanément en utilisant Task.Run, ce qui est utile pour les applications qui doivent effectuer plusieurs opérations indépendantes simultanément. Voici comment vous pouvez lancer plusieurs tâches :

static async Task HandleMultipleTasks()
{
    Task<int> task1 = Task.Run(() =>
    {
        return PerformLongRunningWork("Task 1");
    });
    Task<int> task2 = Task.Run(() =>
    {
        return PerformLongRunningWork("Task 2");
    });
    // Wait for tasks to finish and print the results
    int[] results = await Task.WhenAll(task1, task2); 
    Console.WriteLine($"Results of Task 1: {results[0]}, Task 2: {results[1]}");
}
static int PerformLongRunningWork(string taskName)
{
    int result = 0;
    for (int i = 0; i < 500000; i++)
    {
        result += i;
    }
    Console.WriteLine($"{taskName} completed.");
    return result;
}

static async Task HandleMultipleTasks()
{
    Task<int> task1 = Task.Run(() =>
    {
        return PerformLongRunningWork("Task 1");
    });
    Task<int> task2 = Task.Run(() =>
    {
        return PerformLongRunningWork("Task 2");
    });
    // Wait for tasks to finish and print the results
    int[] results = await Task.WhenAll(task1, task2); 
    Console.WriteLine($"Results of Task 1: {results[0]}, Task 2: {results[1]}");
}
static int PerformLongRunningWork(string taskName)
{
    int result = 0;
    for (int i = 0; i < 500000; i++)
    {
        result += i;
    }
    Console.WriteLine($"{taskName} completed.");
    return result;
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Sortie

Dans cet exemple, HandleMultipleTasks lance deux tâches asynchrones. La méthode Task.WhenAll est utilisée pour attendre chaque tâche asynchrone, ce qui leur permet de s'exécuter simultanément. Une fois les deux tâches terminées, il passe à la ligne de code suivante.

Bonnes pratiques et considérations

Bien que Task.Run soit un outil précieux pour la programmation asynchrone, il est important de l'utiliser à bon escient afin d'éviter les écueils courants tels que l'utilisation excessive des ressources du système ou l'apparition de comportements inattendus dans votre application.

Utiliser Task.Run pour les opérations liées au processeur

Il est préférable d'utiliser Task.Run pour les travaux liés au processeur et non pour les opérations liées aux entrées/sorties. Pour les tâches liées aux E/S, utilisez les opérations d'E/S asynchrones disponibles dans les bibliothèques .NET.

Soyez prudent avec les fils de pool de fils

Rappelez-vous que Task.Run utilise les threads du pool de threads. L'épuisement de ces threads par l'exécution d'un trop grand nombre d'opérations simultanées peut entraîner des retards dans le démarrage des tâches et une lenteur générale de l'application.

Éviter le code synchrone

Lorsque vous attendez des tâches lancées par Task.Run, évitez d'utiliser des attentes synchrones comme les méthodes Task.Result ou Task.Wait, car elles peuvent conduire à des blocages, en particulier dans des contextes tels que les applications d'interface utilisateur.

IronPDF Introduction

IronPDF est une bibliothèque C# qui vous permet de générer et de gérer des **Fichiers PDF directement à partir de HTML, CSS et JavaScript. Conçu pour les développeurs .NET, il simplifie la création de PDF en utilisant le contenu web dont vous disposez déjà, ce qui garantit que ce que vous voyez dans le navigateur correspond à ce que vous obtenez dans le PDF. Il convient à diverses applications .NET, qu'elles soient Web, de bureau ou basées sur un serveur, et offre des fonctionnalités telles que l'édition de PDF, la gestion de formulaires et la création de documents sécurisés.

En termes plus simples, IronPDF vous aide à transformer des pages web en PDF de manière simple et précise. Vous n'avez pas besoin de vous embarrasser d'API complexes ; il vous suffit de concevoir votre page en HTML et IronPDF s'occupe du reste. Il fonctionne sur différentes plateformes .NET et offre des outils pour ajuster, sécuriser et interagir avec vos PDF.

IronPDF avec Task.Run

Exemple de code

Voici un exemple simple d'utilisation de IronPDF avec Task.Run en C#. Cet exemple montre comment générer un PDF à partir d'un contenu HTML de manière asynchrone. Ceci est particulièrement utile pour éviter le gel de l'interface utilisateur dans les applications de bureau ou pour gérer la charge dans les applications web :

using IronPdf;
using System.Threading.Tasks;
public class PdfGenerator
{
    public static async Task CreatePdfAsync()
    {
        var renderer = new ChromePdfRenderer();
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is an async PDF generation.</p>";
        // Run the PDF generation in a separate task
        var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(htmlContent));
        // Save the PDF to a file
        pdf.SaveAs("asyncIronPDF.pdf");
    }
    // Usage
    public static void Main()
    {
        License.LicenseKey = "License-Key";
        Task.Run(async () => await PdfGenerator.CreatePdfAsync()).Wait();
        System.Console.WriteLine("PDF generated.");
    }
}

using IronPdf;
using System.Threading.Tasks;
public class PdfGenerator
{
    public static async Task CreatePdfAsync()
    {
        var renderer = new ChromePdfRenderer();
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is an async PDF generation.</p>";
        // Run the PDF generation in a separate task
        var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(htmlContent));
        // Save the PDF to a file
        pdf.SaveAs("asyncIronPDF.pdf");
    }
    // Usage
    public static void Main()
    {
        License.LicenseKey = "License-Key";
        Task.Run(async () => await PdfGenerator.CreatePdfAsync()).Wait();
        System.Console.WriteLine("PDF generated.");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Sortie

Cet exemple encapsule la génération du PDF dans une Tâche, ce qui le rend adapté aux applications qui nécessitent des opérations non bloquantes.

Conclusion

Task.Run est une fonctionnalité puissante de C# permettant de gérer efficacement les tâches asynchrones. En sachant l'utiliser correctement, vous pouvez améliorer les performances et la réactivité de vos applications. N'oubliez pas de tenir compte du fait qu'une tâche est liée au processeur ou aux E/S lorsque vous décidez de la manière de mettre en œuvre des opérations asynchrones, et essayez toujours de faire en sorte que le fil d'exécution de l'interface utilisateur ne soit pas soumis à des tâches de traitement lourdes.

Les développeurs peuvent tester IronPDF à l'aide de la fonctionessai gratuit avant de décider d'acheter. Le prix de départ d'une licence est de 749 $.