How to work with Action, Func, and Predicate delegates in C#

Bien que le passage d’objets en tant qu’arguments soit une manière standard et familière d’appeler des méthodes, fournir des méthodes en tant qu’arguments à d’autres méthodes l’est moins. Cependant, nous devons souvent passer une méthode en tant que paramètre à une autre méthode lorsque nous travaillons avec la gestion des événements en C#. Nous faisons cela en utilisant des délégués.

J’ai fourni un aperçu des délégués dans un article précédent ici. Dans cet article, nous allons examiner comment nous pouvons travailler avec les délégués Action, Func et Predicate en C#. Pour travailler avec les exemples de code fournis dans cet article, vous devez avoir installé Visual Studio 2022 sur votre système. Si vous n’en avez pas déjà une copie, vous pouvez télécharger Visual Studio 2022 ici.

Un délégué est un pointeur de fonction de type sécurisé qui peut référencer une méthode qui a la même signature que le délégué. Les délégués sont utilisés pour définir les méthodes de rappel et implémenter la gestion des événements, et sont déclarés à l’aide du mot-clé « delegate ». Vous pouvez déclarer un délégué qui peut apparaître seul ou même imbriqué dans une classe.

Que sont les délégués Func et Action ? Comment peuvent-ils être utilisés ?

Les délégués les plus courants en C# sont le délégué Func et le délégué Action. Les deux sont des types de référence qui encapsulent une méthode. Le délégué Func pointe vers une méthode qui accepte des paramètres et renvoie une valeur ; le délégué Action pointe vers une méthode qui accepte des paramètres mais ne renvoie pas de valeur (c’est-à-dire renvoie void).

Les deux objets délégués prendront zéro ou plusieurs paramètres, et nous pouvons les utiliser avec des expressions lambda ou des méthodes anonymes.

La syntaxe pour créer un délégué d’action en C # est

Action<TParameter>

Nous pouvons créer un délégué d’action en C# en utilisant le mot-clé Action.

Action<string> actionDelegate = new Action<string>(DisplayText);
actionDelegate("Hello World!");

La syntaxe pour déclarer un délégué Func en C # est

Func<TParameter, TOutput>

Pour créer un délégué de fonction en C#, nous utilisons le mot-clé Func.

public class DelegateHelper
{
  Func<double, double> functionDelegate = new Func<double, double>(GetTax);
  public static double GetTax(double netSalary)
  {
      return (double)(netSalary * .3);
  }
}
Console.WriteLine(DelegateHelper.GetTax(100000));

Ici, la classe DelegateHelper contient une méthode statique nommée GetTax, qui calcule et renvoie l’impôt en fonction du salaire net, et un délégué qui pointe vers cette méthode. Un délégué Func a été utilisé pour appeler la méthode GetTax.

Utiliser des délégués d’action en C#

La liste de codes suivante fournit un autre exemple d’utilisation d’un délégué d’action. Ce morceau de code, une fois exécuté, imprimerait le mot « Bonjour !!! » dans la fenêtre de la console.

static void Main(string[] args)
        {
            Action<string> action = new Action<string>(Display);
            action("Hello!!!");
            Console.Read();
        }
static void Display(string message)
        {
            Console.WriteLine(message);
        }

Utilisation des délégués Func en C#

Et voici un deuxième exemple d’utilisation d’un délégué Func en C#. L’extrait de code suivant imprime la valeur d’un compte de remboursement de la santé ou HRA (calculée comme 40 % du salaire de base). Le salaire de base est transmis au délégué comme argument.

static void Main(string[] args)
        {
            Func<int, double> func = new Func<int, double>(CalculateHra);
            Console.WriteLine(func(50000));
            Console.Read();
        }
        static double CalculateHra(int basic)
        {
            return (double)(basic * .4);
        }

Notez que le deuxième paramètre de la déclaration du délégué Func dans l’extrait de code fourni ci-dessus représente le type de retour de la méthode vers laquelle le délégué pointerait. Dans cet exemple, la valeur Hra calculée est renvoyée sous la forme double.

Utiliser des délégués de prédicat en C#

Un prédicat est un délégué qui accepte un ou plusieurs paramètres génériques et renvoie une valeur booléenne. Les délégués de prédicat sont généralement utilisés pour effectuer des opérations de recherche basées sur un ensemble de critères.

Il s’agit de la syntaxe d’un délégué de prédicat.

Predicate<T>

Notez que le prédicat est fondamentalement équivalent à Func.

Considérez la classe d’entité suivante nommée Customer.

class Customer
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Address { get; set; }
        public string City { get; set; }
        public string State { get; set; }
        public string Country { get; set; }
    }

Ensuite, créez une liste de clients et stockez-y les objets Customer.

 List<Customer> custList = new List<Customer>();
            custList.Add(new Customer { Id = 1, FirstName = "Joydip", LastName = "Kanjilal", State = "Telengana", City = "Hyderabad", Address = "Begumpet", Country = "India" });
            custList.Add(new Customer { Id = 2, FirstName = "Steve", LastName = "Jones", State = "OA", City = "New York", Address = "Lake Avenue", Country = "US" });

Voici la liste complète du code qui montre comment nous pouvons utiliser un délégué de prédicat pour rechercher des données.

static void Main(string[] args)
        {
            List<Customer> custList = new List<Customer>();
            custList.Add(new Customer { Id = 1, FirstName = "Joydip", LastName = "Kanjilal", State = "Telengana", City = "Hyderabad", Address = "Begumpet", Country = "India" });
            custList.Add(new Customer { Id = 2, FirstName = "Steve", LastName = "Jones", State = "OA", City = "New York", Address = "Lake Avenue", Country = "US" });
            Predicate<Customer> hydCustomers = x => x.Id == 1;
            Customer customer = custList.Find(hydCustomers);
            Console.WriteLine(customer.FirstName);
            Console.Read();
        }

Lorsque l’extrait de code ci-dessus est exécuté, le nom « Joydip » s’affiche dans la fenêtre de la console.

Utilisation de la variance dans les délégués

Lorsque vous définissez vos délégués, vous pouvez utiliser la covariance et la contravariance pour donner à votre délégué un niveau de flexibilité plus élevé. L’approche de covariance permet à une méthode d’avoir un type de retour plus dérivé que celui défini dans le délégué. Avec la contravariance, vous pouvez définir une méthode avec moins d’arguments dérivés que ceux du type délégué.

L’extrait de code suivant illustre la covariance dans les délégués :

classe TypeA {}

classe TypeB : TypeA {}

délégué public TypeA MyDelegate();

public static TypeA HandlerA()

{

//Quelque code

}

public static TypeB HandlerB()

{

//Quelque code

}

MyDelegate déléguéA = ContrôleurA ;

MonDélégué déléguéB = GestionnaireB ;

Considérons maintenant les deux déclarations de délégué suivantes :

public void délégué KeyEventHandler (expéditeur d’objet, KeyEventArgs e)

public void délégué MouseEventHandler (expéditeur d’objet, MouseEventArgs e)

Étant donné que EventArgs est la classe de base des classes KeyEventArgs et MouseEventArgs, vous pouvez tirer parti de la contravariance pour combiner cela en un seul contrôleur capable de gérer les événements de touche et de souris, comme indiqué dans l’extrait de code ci-dessous :

private void MyCommonHandler (expéditeur d’objet, System.EventArgs e)

{

//Quelque code

}

Les délégués font partie des fonctionnalités les plus largement utilisées du langage de programmation C#. Ils sont idéaux pour mettre en œuvre une programmation événementielle. Dans la plupart des cas, le type de retour de la méthode pointée par un délégué doit être identique au type spécifié dans la déclaration du délégué.

Copyright © 2023 IDG Communications, Inc.

Source