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

Introduction

Dans cet article, nous examinons les fondamentaux de 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éléguer ces opérations à un thread en arrière-plan, améliorant ainsi la performance et la réactivité des applications. Nous explorerons la méthode Task.Run et les fonctionnalités complètes de la 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 I/O de manière asynchrone sur un thread séparé 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 de l'exécuter directement sur le thread principal, ce qui bloquerait l'interface utilisateur, vous pouvez utiliser Task.Run pour le 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 plage de nombres. En utilisant Task.Run, ce calcul est déchargé sur un thread en arrière-plan, permettant au thread principal de rester réactif. Le mot-clé de tâche await est utilisé pour attendre de manière asynchrone l'achèvement de la tâche, sans bloquer le thread actuel.

Approfondir les tâches asynchrones et les threads

Lorsque vous invoquez Task.Run, le .NET Framework affecte un thread du pool de threads pour exécuter 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 bénéfique 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 démarre deux tâches asynchrones. La méthode Task.WhenAll est utilisée pour attendre chaque tâche asynchrone, ce qui permet de les 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 judicieusement afin d'éviter des pièges courants tels que la surutilisation des ressources système ou provoquer un comportement inattendu dans votre application.

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

Il est préférable d'utiliser Task.Run pour le travail lié au processeur et non pour les opérations liées à l'E/S. 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

N'oubliez pas que Task.Run utilise des 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 démarrées par Task.Run, évitez d'utiliser des attentes synchrones telles que les méthodes Task.Result ou Task.Wait, car elles peuvent entraîner des blocages, notamment dans des contextes comme les applications UI.

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 de PDF dans une Tâche, la rendant adaptée aux applications nécessitant des opérations non bloquantes.

Conclusion

Task.Run est une fonctionnalité puissante en C# pour 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 en utilisant sa version d'essai gratuite avant de décider de l'acheter. Le prix de départ pour une licence est de $749.