Dans cet article, nous plongeons dans 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, surtout 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 computationnelles 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 les performances 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 liées à l'I/O de manière asynchrone sur un thread séparé du pool de threads. Cette méthode est bénéfique pour garder votre thread d'interface utilisateur réactif en utilisant un thread asynchrone pour effectuer des opérations de longue durée. Elle simplifie le démarrage d'une nouvelle opération asynchrone sur un thread différent, qui peut ensuite être attendue en utilisant le mot-clé await.

Utilisation de base de Task.Run

Considérons un exemple simple où vous devez effectuer un calcul long. 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 :

using System;
using System.Threading.Tasks;

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}");
}

using System;
using System.Threading.Tasks;

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}");
}

Imports System
Imports System.Threading.Tasks

Shared Async Function PerformComputation() As Task
	Dim result As Integer = Await Task.Run(Function()
		Dim sum As Integer = 0
		For i As Integer = 0 To 999999
			sum += i
		Next i
		Return sum
	End Function)
	Console.WriteLine($"The result is {result}")
End Function

Imports System
Imports System.Threading.Tasks

Shared Async Function PerformComputation() As Task
	Dim result As Integer = Await Task.Run(Function()
		Dim sum As Integer = 0
		For i As Integer = 0 To 999999
			sum += i
		Next i
		Return sum
	End Function)
	Console.WriteLine($"The result is {result}")
End Function

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 d'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 jusqu'à ce que la tâche soit terminée, sans bloquer le thread courant.

Approfondir les tâches et threads asynchrones

Lorsque vous invoquez Task.Run, le .NET Framework attribue un thread du pool de threads pour exécuter la tâche spécifiée. Cela est efficace car cela évite les frais de création de nouveaux threads pour chaque tâche et aide à utiliser les ressources système plus efficacement. Le pool de threads gère un ensemble de threads de travail pour votre application, qui peuvent exécuter plusieurs tâches simultanément sur plusieurs cœurs.

Gérer plusieurs tâches

Vous pouvez exécuter une nouvelle tâche de manière concurrente 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 initier plusieurs tâches :

using System;
using System.Threading.Tasks;

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;
}

using System;
using System.Threading.Tasks;

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;
}

Imports System
Imports System.Threading.Tasks

Shared Async Function HandleMultipleTasks() As Task
	Dim task1 As Task(Of Integer) = Task.Run(Function()
		Return PerformLongRunningWork("Task 1")
	End Function)

	Dim task2 As Task(Of Integer) = Task.Run(Function()
		Return PerformLongRunningWork("Task 2")
	End Function)

	' Wait for tasks to finish and print the results
	Dim results() As Integer = Await Task.WhenAll(task1, task2)
	Console.WriteLine($"Results of Task 1: {results(0)}, Task 2: {results(1)}")
End Function

Shared Function PerformLongRunningWork(ByVal taskName As String) As Integer
	Dim result As Integer = 0
	For i As Integer = 0 To 499999
		result += i
	Next i
	Console.WriteLine($"{taskName} completed.")
	Return result
End Function

Imports System
Imports System.Threading.Tasks

Shared Async Function HandleMultipleTasks() As Task
	Dim task1 As Task(Of Integer) = Task.Run(Function()
		Return PerformLongRunningWork("Task 1")
	End Function)

	Dim task2 As Task(Of Integer) = Task.Run(Function()
		Return PerformLongRunningWork("Task 2")
	End Function)

	' Wait for tasks to finish and print the results
	Dim results() As Integer = Await Task.WhenAll(task1, task2)
	Console.WriteLine($"Results of Task 1: {results(0)}, Task 2: {results(1)}")
End Function

Shared Function PerformLongRunningWork(ByVal taskName As String) As Integer
	Dim result As Integer = 0
	For i As Integer = 0 To 499999
		result += i
	Next i
	Console.WriteLine($"{taskName} completed.")
	Return result
End Function

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 leur permet de s'exécuter simultanément. Une fois les deux tâches terminées, elle continue avec la ligne de code suivante.

Meilleures pratiques et considérations

Bien que Task.Run soit un outil précieux pour la programmation asynchrone, il est important de l'utiliser judicieusement pour éviter les pièges courants tels que la sur-utilisation des ressources système ou le déclenchement d'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 les travaux liés au processeur et non pour les opérations liées à l'I/O. Pour les tâches liées à l'I/O, utilisez des opérations d'I/O asynchrones disponibles dans les bibliothèques .NET.

Faites attention aux threads du pool de threads

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

Évitez le code synchrone

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

Introduction à IronPDF

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. Elle est conçue pour les développeurs .NET et simplifie la création de PDF en utilisant le contenu web que vous avez déjà, assurant que ce que vous voyez dans le navigateur est ce que vous obtenez dans le PDF. Elle convient à diverses applications .NET, qu'elles soient web, de bureau ou basées sur serveur, et offre des fonctionnalités telles que l'édition de PDF, la gestion des formulaires et la création de documents sécurisés.

En termes plus simples, IronPDF vous aide à transformer facilement et avec précision des pages web en PDFs. Vous n'avez pas besoin de vous embrouiller avec des API complexes ; concevez simplement votre page en HTML et IronPDF fait le reste. Elle fonctionne sur différentes plateformes .NET et offre des outils pour ajuster, sécuriser et interagir avec vos PDFs.

IronPDF avec Task.Run

Exemple de code

Voici un exemple simple d'utilisation de IronPDF avec Task.Run en C#. Cet exemple démontre comment générer un PDF à partir de contenu HTML de manière asynchrone. C'est particulièrement utile pour éviter les blocages de l'interface utilisateur dans les applications de bureau ou 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("async IronPDF.pdf");
    }
    
    // Main method to execute the PDF generation
    public static void Main()
    {
        // Set the license key for IronPDF
        License.LicenseKey = "License-Key";

        // Calling the async PDF generation method and blocking the Main thread until completion
        Task.Run(async () => await PdfGenerator.CreatePdfAsync()).Wait();
        
        // Inform the user that the PDF generation is complete
        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("async IronPDF.pdf");
    }
    
    // Main method to execute the PDF generation
    public static void Main()
    {
        // Set the license key for IronPDF
        License.LicenseKey = "License-Key";

        // Calling the async PDF generation method and blocking the Main thread until completion
        Task.Run(async () => await PdfGenerator.CreatePdfAsync()).Wait();
        
        // Inform the user that the PDF generation is complete
        System.Console.WriteLine("PDF generated.");
    }
}

Sortie

Ce exemple encapsule la génération de PDF dans un Task, la rendant adaptée aux applications requérant des opérations non bloquantes.

Conclusion

Task.Run est une fonctionnalité puissante en C# pour gérer efficacement les tâches asynchrones. En comprenant comment l'utiliser correctement, vous pouvez améliorer les performances et la réactivité de vos applications. N'oubliez pas de considérer si une tâche est liée au processeur ou à l'I/O lorsque vous décidez comment implémenter des opérations asynchrones, et visez toujours à garder le thread de l'interface utilisateur libre de toute tâche de traitement intensif.

Les développeurs peuvent tester IronPDF en utilisant son essai gratuit avant de décider d'acheter. Le prix de départ pour une licence est $999.