Groupes de méthodes en C#

1. Groupe de méthodes en C#
2. Delegates en C#
3. Conversion des groupes de méthodes avec DELEGATE en C#
4. Delegate personnalisé simple pour les groupes de méthodes en C#
5. Utiliser des pointeurs de fonction pour les groupes de méthodes en C#

Cet article abordera les groupes de méthodes en C#.

Groupe de méthodes en C#

Nous rencontrons parfois un cas où une fonction peut avoir plus d’une implémentation. Il peut avoir une autre définition avec un ensemble ou un type de paramètres entièrement différent ou est généralement connu sous le nom de fonction surchargée.

Syntaxe:

void print(int x) {
  ///...code
}

void print(int x, int y) {
  ///...code for x and y
}

Ces fonctions ou méthodes sont appelées METHOD GROUPS.

Delegates en C#

DELEGATES sont des pointeurs vers les fonctions créées. En plus de pointer vers la fonction, il définit également le type de retour des fonctions et leurs paramètres.

Un délégué, disons, appelé LAPTOP peut avoir un type de retour comme void et un paramètre comme USERNAME (string). Nous avons une autre fonction appelée PC, qui a également le même type de retour et de paramètre que LAPTOP.

Nous pouvons appeler PC à partir du délégué LAPTOP dans ce scénario.

Exemple de code :

delegate void LAPTOP(string username);

static void PC(string username) {
  Console.WriteLine("USER: " + username + " has logged in!");
}

static void Main() {
  LAPTOP lap1 = PC;
  lap1("Hydrogen");
}

Vous pouvez remarquer que nous avons instancié l’instance LAPTOP avec PC, et que l’invoquer plus tard, nous fait imprimer le nom d’utilisateur passé par la méthode PC. C’est ainsi que les DELEGATES fonctionnent.

Conversion des groupes de méthodes avec DELEGATE en C#

Nous examinerons l’une des utilisations les plus courantes des groupes de méthodes et comment les gérer lorsqu’ils sont appelés. Nous avons discuté de la façon dont les groupes de méthodes sont des fonctions surchargées d’une méthode de base, et nous pouvons utiliser les groupes de méthodes comme nous le souhaitons en utilisant DELEGATES.

Dans notre exemple, supposons que nous ayons une méthode appelée CAR à partir de laquelle nous voulons adresser plusieurs autres méthodes, telles que DASHBOARD, WHEEL, LIGHTS etc. Nous n’utiliserons, par commodité, que deux méthodes : LIGHTS et MIRRORS.

Exemple de code :

delegate void CAR(bool start);

static void MIRROR(bool start) {
  if (start)
    Console.WriteLine("Mirror is now working!");
  else
    Console.WriteLine("Mirror is not stopped/closed");
}

static void LIGHTS(bool start) {
  if (start)
    Console.WriteLine("Lights are now working!");
  else
    Console.WriteLine("Lights have stopped/closed");
}

Maintenant que nous avons défini les méthodes, implémentons la méthode MAIN, où nous utilisons des délégués pour gérer ces groupes de méthodes.

CAR car = MIRROR;
car(true);

car = LIGHTS;
car(false);

Vous pouvez remarquer que l’objet CAR pointe vers le MIRROR, mais plus tard, il est amené à pointer vers LUMIÈRES. Ensuite, l’appel de la méthode appelle la fonction vers laquelle elle pointe.

Le nom de la fonction est attribué à l’objet car. Changer le pointeur DELEGATE pour qu’il pointe sur différentes méthodes de son groupe est appelé METHOD GROUP CONVERSION, et dans ce scénario, les LIGHTS, MIRRORS et CAR font tous partie du même groupe de méthodes.

Delegate personnalisé simple pour les groupes de méthodes en C#

Une manière simple de créer un DELEGATE pouvant pointer vers des GROUPES DE MÉTHODES est quelque chose d’aussi simple que ce qui suit.

Func<string> f_test = "AA".ToString;
Console.WriteLine(f_test());

L’invocation de ce qui précède produira la chaîne AA en conséquence. F_TEST pointe vers la méthode ToString et l’appelle.

Vous pouvez également remarquer que cette fonction pointe sur l’adresse de la méthode ToString et non sur la fonction elle-même. C’est ainsi que fonctionnent les pointeurs.

Un autre exemple a été fourni ci-dessous pour bien comprendre les GROUPES DE MÉTHODES.

Func<string, int> f_test = Convert.ToInt32;
Console.WriteLine(f_test("435"));

Syntaxe:

Func<param1, param2> name;
//param1 is the parameter passed in the function/method pointed to
//param 2 is the return type of that function/method that the delegate points to

Comme Convert.ToInt32 a un type de retour de INT et 18 différentes surcharges. Il est impératif de définir le type de paramètre car on veut appeler F_TEST avec une chaîne "435", et on définit PARAM2 comme STRING.

Définir PARAM2 est important même s’il n’y a qu’une seule surcharge d’une fonction présente ; parce que METHOD GROUPS sont des constructions de temps compilées, elles doivent être choisies pour une seule surcharge. Il est important de s’assurer que PARAM2 contient au moins une surcharge.

Vous pouvez également supprimer le cast dans LINQ lors de l’appel de List.Select(MethodGroup) dans une fonction. Nous ne détaillerons pas les contextes LINQ car cet article se concentre sur les GROUPES DE MÉTHODES.

Utiliser des pointeurs de fonction pour les groupes de méthodes en C#

Pointer vers différentes fonctions à partir d’un délégué n’est nécessaire que si vous travaillez dans des GROUPES DE MÉTHODES. Vous devez vous assurer que les types de retour et les paramètres correspondent dans de telles circonstances.

C# fournit déjà un mot-clé FUNC pour permettre de pointer vers différentes fonctions. Tout comme les pointeurs fonctionnent en pointant vers des adresses d’objets et de variables puis en les appelant, vous pouvez imaginer les délégués de la même manière.

Les pointeurs ont également tendance à avoir le même type de retour que les objets auxquels ils s’adressent. Les délégués doivent également prendre soin des paramètres en raison des exigences de la fonction.

Pointer vers des fonctions est nécessaire lorsque, par exemple, vous souhaitez stocker des fonctions dans un tableau et les appeler dynamiquement pour votre code ou transmettre les fonctions à d’autres fonctions à appeler. Les fonctions LAMBDA répondent également à la même exigence.

Cependant, les METHOD GROUPS sont des clusters courants avec des fonctions surchargées qui suivent un type de retour et de paramètre de base.