Action C# (Comment ça marche pour les développeurs)

Dans ce tutoriel, nous allons enseigner les concepts de Action C#, délégué Func, et les sujets connexes. Ce guide est conçu pour les débutants et vous guidera à travers les bases, fournira des exemples et expliquera les termes clés du délégué d'action.

Commençons par comprendre ce que sont les délégués en C#. Nous explorerons la bibliothèque IronPDF plus tard dans l'article.

Comprendre les délégués dans C# ;

Les délégués sont une construction de programmation qui agit comme des références à des méthodes, définies par un ensemble particulier de paramètres et un type de retour, encapsulant des fonctionnalités telles que le type de délégué prédéfini et permettant aux méthodes de renvoyer des valeurs.

Il permet de passer des méthodes en tant qu'arguments. Essentiellement, un délégué sert de pointeur de fonction, indiquant la méthode qu'il représente. En C#, il existe deux types de délégués prédéfinis qui sont largement utilisés : Func et Action.

Qu'est-ce qu'un délégué Func ?

Le délégué Func représente une méthode qui peut avoir une valeur de retour. Le dernier paramètre de type spécifie le type de retour, et les types précédents spécifient les paramètres d'entrée.

Par exemple, un Func<int, int, string> prend deux paramètres entiers et retourne un message sous forme de chaîne de caractères.

Les délégués en pratique : Exemples

Examinons quelques exemples pour comprendre comment les délégués Func et Action fonctionnent en C#.

Exemple de délégué à l'action

Un délégué Action, un type de délégué prédéfini, est utilisé lorsque vous souhaitez exécuter une méthode qui ne renvoie pas spécifiquement une valeur, mais qui se concentre plutôt sur des opérations. Voici un exemple de base :

Action<string> display = message => Console.WriteLine(message);
display("Hello, World!");

Action<string> display = message => Console.WriteLine(message);
display("Hello, World!");

Dim display As Action(Of String) = Sub(message) Console.WriteLine(message)
display("Hello, World!")

Ce code définit un délégué Action, illustrant l'utilisation d'une méthode anonyme, qui prend un seul paramètre de type chaîne et l'imprime sur la console. Le symbole => est utilisé pour définir une expression lambda, qui est une manière concise d'écrire des méthodes anonymes.

Exemple de délégué Func

Un délégué Func, qui retourne une valeur, peut être utilisé comme suit :

Func<int, int, int> add = (x, y) => x + y;
int result = add(5, 3);
Console.WriteLine(result);

Func<int, int, int> add = (x, y) => x + y;
int result = add(5, 3);
Console.WriteLine(result);

Dim add As Func(Of Integer, Integer, Integer) = Function(x, y) x + y
Dim result As Integer = add(5, 3)
Console.WriteLine(result)

Cet exemple crée un délégué Func qui prend deux paramètres entiers et retourne leur somme. La somme s'affichera sur la console comme suit :

Concepts clés

Méthodes anonymes

Les méthodes anonymes en C# permettent de définir des méthodes inline sans nom. Ils sont souvent utilisés avec les délégués pour créer directement des instances de délégués.

Expressions lambda

Les expressions lambda sont un raccourci pour écrire des méthodes anonymes. Ils permettent d'écrire moins de code tout en obtenant le même résultat.

Délégué générique

Un délégué générique peut travailler avec n'importe quel type de données. Func et Action sont des exemples de délégués génériques, offrant plus de flexibilité en vous permettant de spécifier les types d'entrée et de sortie à l'exécution.

Instance déléguée

Une instance de délégué est créée avec le mot-clé new ou en assignant simplement une méthode qui correspond à la signature du délégué.

Espace de noms du système

Le namespace System dans .NET contient des types intégrés tels que Func et Action, qui font partie de la bibliothèque de classes de base.

Programmation asynchrone avec des délégués

Les délégués, y compris Action et Func, sont essentiels pour gérer les tâches asynchrones en C#. Ils permettent aux développeurs d'encapsuler une référence à une méthode qui peut ensuite être exécutée de manière asynchrone. Cela signifie que le thread principal de l'application peut lancer une tâche et poursuivre d'autres travaux jusqu'à ce que la tâche soit terminée.

À ce stade, une méthode de rappel, référencée par un délégué, est appelée pour traiter le résultat. Ce modèle est essentiel pour créer des interfaces utilisateur réactives qui restent interactives même lors d'opérations de longue durée.

Exemple : Traitement asynchrone des fichiers

Considérons une application qui doit traiter un fichier volumineux. L'utilisation d'un délégué Action en conjonction avec des modèles de programmation asynchrones comme Task peut améliorer de manière significative les performances de l'application :

public async Task ProcessFileAsync(string filePath, Action<string> onComplete)
{
    // Asynchronously read file content
    string fileContent = await File.ReadAllTextAsync(filePath);
    // Process the file content here (omitted for brevity)
    // Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.");
}

public async Task ProcessFileAsync(string filePath, Action<string> onComplete)
{
    // Asynchronously read file content
    string fileContent = await File.ReadAllTextAsync(filePath);
    // Process the file content here (omitted for brevity)
    // Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.");
}

Public Async Function ProcessFileAsync(ByVal filePath As String, ByVal onComplete As Action(Of String)) As Task
	' Asynchronously read file content
	Dim fileContent As String = Await File.ReadAllTextAsync(filePath)
	' Process the file content here (omitted for brevity)
	' Once processing is complete, invoke the onComplete callback
	If onComplete IsNot Nothing Then
		onComplete.Invoke("File processing completed successfully.")
	End If
End Function

Dans cet exemple, File.ReadAllTextAsync est utilisé pour lire le contenu du fichier sans bloquer le thread principal. Une fois le fichier traité, un délégué Action nommé onComplete est invoqué pour notifier l'appelant que l'opération est terminée, permettant ainsi d'effectuer d'autres actions comme la mise à jour de l'interface utilisateur ou l'enregistrement des résultats.

Introduction d'IronPDF : Une C&num ; bibliothèque PDF

IronPDF est une bibliothèque PDF C# complète conçue pour les développeurs .NET afin de créer, éditer et manipuler des fichiers PDF avec facilité. Il se distingue par un moteur de rendu basé sur Chrome, garantissant des PDF parfaits au pixel près à partir de contenu HTML, CSS, JavaScript et images.

IronPDF est compatible avec un large éventail de frameworks et d'environnements .NET, notamment .NET Standard, .NET Framework et .NET Core, sur les plateformes Windows, Linux et macOS.

Installation d'IronPDF

Pour incorporer IronPDF for .NET dans vos projets .NET, vous pouvez utiliser NuGet, ce qui est la méthode la plus simple. Il suffit d'ouvrir la console du gestionnaire de paquets dans Visual Studio et d'exécuter la commande suivante :

Install-Package IronPdf

Cette commande récupère et installe le paquetage IronPDF, configurant votre projet pour commencer à utiliser IronPDF pour la génération et la manipulation de PDF.

Exemple de code avec un délégué d'action

Voici un exemple simple démontrant comment utiliser IronPDF en conjonction avec un délégué d'action pour effectuer une tâche de génération de PDF :

using IronPdf;
using System;
class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();
        Action<string> generatePdf = html =>
        {
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs("example.pdf");
        };
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

using IronPdf;
using System;
class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();
        Action<string> generatePdf = html =>
        {
            var pdf = renderer.RenderHtmlAsPdf(html);
            pdf.SaveAs("example.pdf");
        };
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

Imports IronPdf
Imports System
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		Dim generatePdf As Action(Of String) = Sub(html)
			Dim pdf = renderer.RenderHtmlAsPdf(html)
			pdf.SaveAs("example.pdf")
		End Sub
		generatePdf("<p>Hello, world!</p>")
		Console.WriteLine("PDF generated successfully.")
	End Sub
End Class

Cet exemple définit un délégué d'action qui prend une chaîne de caractères HTML et utilise IronPDF pour la transformer en document PDF.

Le PDF généré est ensuite enregistré dans le système de fichiers. Cette approche montre comment les délégués peuvent être utilisés pour encapsuler la logique de génération de PDF, ce qui rend votre code plus modulaire et plus flexible.

Licences

IronPDF propose diverses options de licence pour les développeurs, allant des licences pour développeurs individuels aux accords d'entreprise. Les prix de ces licences commencent à partir de $749.

Conclusion

À présent, vous devriez avoir une compréhension de base des délégués Action et Func en C#, ainsi que de la façon d'utiliser les méthodes anonymes et les expressions lambda. N'oubliez pas que la pratique est essentielle pour maîtriser les concepts de délégation. Essayez de créer vos propres exemples pour définir, attribuer et invoquer des délégués.

Vous pouvez explorer librement les capacités d'IronPDF avec sa version d'essai gratuite. Si cela convient aux exigences de votre projet, vous pouvez obtenir une licence avec des prix à partir de $749.