Expliquer le concept de délégation en C#

Si vous êtes un programmeur C, vous pouvez considérer un délégué comme un pointeur vers une fonction. Cependant, un délégué en C# est plus qu’un simple pointeur de fonction. Cet article explique le concept de délégation et son utilisation dans la programmation quotidienne.

Essentiellement, la délégation fournit un niveau d'indirection. Ils encapsulent un morceau de code qui peut être transmis et exécuté de manière sécurisée. Plutôt que d’exécuter le comportement immédiatement, celui-ci est contenu dans un objet. Vous pouvez effectuer plusieurs opérations sur cet objet, dont l'une consiste à exécuter un comportement contenu.

L'utilisation de délégués nous permet d'écrire des fonctions d'ordre supérieur, c'est-à-dire des fonctions qui peuvent recevoir des fonctions en tant que paramètres ou renvoyer des fonctions en tant que valeurs de retour. Un type délégué définit la signature de méthode qu'un délégué peut représenter, en particulier le type de retour de la méthode et ses types de paramètres. Dans l'exemple suivant, Transformer est un délégué qui peut représenter n'importe quelle méthode qui accepte et renvoie un entier.

delegate int Transformer(int x);

Nous pouvons attribuer n'importe quelle méthode (y compris les méthodes lambda, d'instance ou statiques) à une instance de Transformer qui satisfait à la signature. Par exemple : 

Transformer square = x => x * x;
Transformer cube = x => x * x * x;

Console.WriteLine(square(3)); // prints 9
Console.WriteLine(cube(5)); // prints 125

Quand utiliser la délégation ?

Les délégués sont généralement utilisés lorsque le code qui souhaite effectuer certaines opérations ne connaît pas les détails de ces opérations mais connaît l'interface de ces opérations. p>

En programmation, nous rencontrons souvent des situations où nous devons effectuer une opération spécifique, mais nous ne savons pas à l'avance quelle méthode appeler pour l'effectuer. Les délégués nous aident à résoudre ce problème en remplaçant le comportement par un délégué, puis en transmettant une instance concrète du délégué avec le comportement approprié selon le contexte et la situation.

Pour qu'un délégué puisse faire quoi que ce soit, quatre choses doivent se produire -

1) Le type de délégué doit être déclaré.

Un type délégué est essentiellement la définition de la fonction qu'il représente, c'est-à-dire qu'il se compose des paramètres, des types que la fonction acceptera et du type de retour qu'elle renvoie.

Par exemple, un type délégué représentant une méthode qui accepte deux nombres en entrée et renvoie un nombre pourrait être déclaré comme -

delegate int Processor(int numOne, int numTwo);

Un processeur est un type similaire aux types créés par les classes. Pour créer une instance de ce type, vous avez besoin d'une méthode qui accepte deux nombres en entrée et renvoie une valeur booléenne.

2) Le code à exécuter doit être contenu dans la méthode.

Définissez une méthode avec exactement la même signature que le type de délégué ci-dessus et faites ce que vous voulez en fonction de la situation d'exécution. Par exemple, l'une des méthodes suivantes peut être utilisée pour créer une instance de processeur, car elles prennent toutes deux nombres et renvoient un nombre.

static int Add(int numOne, int numTwo){
   Return numOne + numTwo;
}
static int Subtract(int numOne, int numTwo){
   Return numOne - numTwo;
}

3) Une instance déléguée doit être créée.

Maintenant que vous disposez d'un type de délégué et d'une méthode avec la signature correcte, vous pouvez créer une instance de ce type de délégué. Ce faisant, nous disons essentiellement au compilateur C# d’exécuter cette méthode lorsque l’instance déléguée est appelée.

Processor processorOne = new Processor(Add);
Processor processorTwo = new Processor(Subtract);

L'exemple ci-dessus suppose que les méthodes Add et Subtract sont définies dans la même classe où nous créons l'instance de délégué. Si ces méthodes sont définies dans différentes classes, nous aurons besoin d’une instance de cette classe.

4) L'instance déléguée doit être appelée.

Cela appelle simplement une méthode sur une instance de délégué, sans surprise nommée Invoke. Cette méthode sur l'instance de délégué a la même liste de paramètres et le même type de retour que ceux spécifiés par la déclaration du type de délégué. L’appel d’Invoke effectuera l’opération de l’instance de délégué.

int sum = processorOne.Invoke(3, 5);

Mais C# rend les choses beaucoup plus faciles. Vous pouvez appeler l'instance de délégué directement comme s'il s'agissait d'une méthode elle-même. Par exemple,

int difference = processorTwo(10, 6);

Combiner et supprimer des délégués

Si nous voulons effectuer une série d'opérations différentes avec un seul appel d'instance de délégué, C# nous permet de le faire. système. Le type délégué possède deux méthodes statiques appelées Combine et Remove.

1. Composition

Crée un nouveau délégué avec une liste d'appels concaténant la liste d'appels du délégué passée en argument. Lorsqu'une nouvelle instance de délégué est appelée, toutes ses opérations sont effectuées séquentiellement.

public static Delegate Combine(params Delegate[] delegates); // OR
public static Delegate Combine(Delegate a, Delegate b);

Si une opération dans la liste d'appels génère une exception, cela empêchera l'exécution de toute opération ultérieure.

2. Supprimer

Supprimez la dernière occurrence de la liste d'appels du délégué de la liste d'appels d'un autre délégué. Renvoie un nouveau délégué contenant la liste d'appels formée en prenant la liste d'appels source et en supprimant la dernière occurrence de la liste d'appels de valeurs.

public static Delegate Remove(Delegate source, Delegate value);

Résumé

• Un délégué encapsule le comportement à l'aide d'un type et d'un ensemble de paramètres spécifiques, similaires à une interface de méthode unique.

• La signature de type décrite par une déclaration de type délégué détermine quelles méthodes peuvent être utilisées pour créer une instance de délégué et la signature des appels.

• La création d'une instance de délégué nécessite la méthode que nous souhaitons exécuter lorsque le délégué est appelé.

• Les instances de délégué sont immuables, semblables aux chaînes.

• Chaque instance de délégué contient une liste d'appels - une liste d'opérations.

• Les instances déléguées peuvent être combinées et supprimées les unes des autres.

ul>

Exemple

Démonstration en temps réel

using System;
class Program{
   delegate int Transformer(int x);
   delegate int Processor(int numOne, int numTwo);
   static void Main(){
      Transformer square = x => x * x;
      Transformer cube = x => x * x * x;
      Console.WriteLine(square(3)); // prints 9
      Console.WriteLine(cube(5)); // prints 125
      Processor processorOne = new Processor(Add);
      Processor processorTwo = new Processor(Subtract);
      int sum = processorOne.Invoke(3, 5);
      Console.WriteLine(sum); // prints 8
      int difference = processorTwo(10, 6);
      Console.WriteLine(difference); // prints 4
   }
   static int Add(int numOne, int numTwo){
      return numOne + numTwo;
   }
   static int Subtract(int numOne, int numTwo){
      return numOne - numTwo;
   }
}

Sortie

9
125
8
4

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!