Délégués, pourquoi ?

Question

Duplicatas possibles :
Quand utiliseriez-vous les délégués en C# ?
Le but des délégués

J'ai vu de nombreuses questions concernant l'utilisation des délégués. Je ne sais toujours pas où et POURQUOI vous utilisez les délégués au lieu d'appeler la méthode directement.

J'ai entendu cette phrase à de nombreuses reprises : "L'objet délégué peut alors être passé au code qui peut appeler la méthode référencée, sans avoir à savoir au moment de la compilation quelle méthode sera invoquée."

Je ne comprends pas en quoi cette affirmation est correcte.

J'ai écrit les exemples suivants. Disons que vous avez 3 méthodes avec les mêmes paramètres :

   public int add(int x, int y)
    {
        int total;
        return total = x + y;
    }
    public int multiply(int x, int y)
    {
        int total;
        return total = x * y;
    }
    public int subtract(int x, int y)
    {
        int total;
        return total = x - y;
    }

Maintenant je déclare un délégué :

public delegate int Operations(int x, int y);

Maintenant, je peux aller plus loin et déclarer un handler pour utiliser ce délégué (ou votre délégué directement).

Appelez le délégué :

MyClass f = new MyClass();

Operations p = new Operations(f.multiply);
p.Invoke(5, 5);

ou appeler avec le gestionnaire

f.OperationsHandler = f.multiply;
//just displaying result to text as an example
textBoxDelegate.Text = f.OperationsHandler.Invoke(5, 5).ToString();

Dans ces deux cas, je vois que ma méthode "multiplier" est spécifiée. Pourquoi les gens utilisent-ils l'expression "changer la fonctionnalité au moment de l'exécution" ou celle ci-dessus ?

Pourquoi utiliser les délégués si chaque fois que je déclare un délégué, il a besoin d'une méthode vers laquelle pointer ? Et s'il a besoin d'une méthode vers laquelle pointer, pourquoi ne pas simplement appeler cette méthode directement ? Il me semble que je dois écrire plus de code pour utiliser les délégués que pour utiliser directement les fonctions.

Quelqu'un peut-il me donner une situation réelle ? Je suis totalement perdue.

Answer 1

Changer la fonctionnalité au moment de l'exécution n'est pas ce que les délégués accomplissent.

En gros, les délégués vous évitent de taper des tonnes de texte.

Par exemple :

class Person
{
    public string Name { get; }
    public int Age { get; }
    public double Height { get; }
    public double Weight { get; }
}

IEnumerable<Person> people = GetPeople();

var orderedByName = people.OrderBy(p => p.Name);
var orderedByAge = people.OrderBy(p => p.Age);
var orderedByHeight = people.OrderBy(p => p.Height);
var orderedByWeight = people.OrderBy(p => p.Weight);

Dans le code ci-dessus, le p => p.Name , p => p.Age etc. sont toutes des expressions lambda qui ont pour valeur Func<Person, T> les délégués (où T es string , int , double y double respectivement).

Voyons maintenant comment nous aurions pu obtenir ce résultat. sans des délégués. Au lieu d'avoir le OrderBy prend un paramètre de délégué, nous devrions renoncer à la généricité et définir ces méthodes :

public static IEnumerable<Person> OrderByName(this IEnumerable<Person> people);
public static IEnumerable<Person> OrderByAge(this IEnumerable<Person> people);
public static IEnumerable<Person> OrderByHeight(this IEnumerable<Person> people);
public static IEnumerable<Person> OrderByWeight(this IEnumerable<Person> people);

Ce serait tout à fait sucer . Tout d'abord, le code est devenu infiniment moins réutilisable puisqu'il ne s'applique qu'aux collections du type Person type. De plus, nous devons copier et coller le même code quatre fois, en ne changeant qu'une ou deux lignes dans chaque copie (où la propriété pertinente de la balise Person est référencée -- sinon tout serait identique) ! Cela deviendrait rapidement une pagaille impossible à maintenir.

Les délégués vous permettent donc de rendre votre code plus réutilisable. y plus facile à maintenir en faisant abstraction de certains comportements dans du code qui peut être activé ou désactivé.

Answer 2

Délégués .NET : Une histoire pour s'endormir en C#

Answer 3

Les délégués sont extrêmement utiles, surtout après l'introduction de linq et des closures.

Un bon exemple est la fonction "Where", l'une des méthodes standard de linq. Where" prend une liste et un filtre, et renvoie une liste d'éléments correspondant au filtre. (L'argument filtre est un délégué qui prend un T et renvoie un booléen).

Parce qu'elle utilise un délégué pour spécifier le filtre, la fonction Where est extrêmement flexible. Vous n'avez pas besoin de fonctions Where différentes pour filtrer les nombres impairs et les nombres premiers, par exemple. La syntaxe d'appel est également très concise, ce qui ne serait pas le cas si vous utilisiez une interface ou une classe abstraite.

Plus concrètement, lorsque vous prenez un délégué, vous pouvez écrire ceci :

var result = list.Where(x => x != null);
...

au lieu de ça :

var result = new List<T>();
foreach (var e in list)
    if (e != null)
        result.add(e)
...

Answer 4

Pourquoi les délégués sont utilisés si à chaque fois que je je déclare un délégué, il a besoin d'une méthode vers laquelle il doit pointer ? et s'il a besoin d'une méthode à pointer, pourquoi ne pas simplement appeler cette méthode directement ?

Comme les interfaces, les délégués vous permettent de découpler et de généraliser votre code. Vous utilisez généralement les délégués lorsque vous ne savez pas à l'avance quelles méthodes vous voudrez exécuter - lorsque vous savez seulement que vous voudrez exécuter quelque chose qui correspond à une certaine signature.

Prenons l'exemple d'une classe de minuterie qui exécute une méthode à intervalles réguliers :

public delegate void SimpleAction();

public class Timer {
    public Timer(int secondsBetweenActions, SimpleAction simpleAction) {}
}

Vous pouvez brancher n'importe quoi sur cette minuterie, de sorte que vous pouvez l'utiliser dans n'importe quel autre projet ou application sans essayer de prédire comment vous l'utiliserez et sans limiter son utilisation à une petite poignée de scénarios auxquels vous pensez à l'heure actuelle .

Answer 5

Laissez-moi vous donner un exemple. Si votre classe expose un event On peut lui attribuer un certain nombre de délégués au moment de l'exécution, qui seront appelés pour signaler que quelque chose s'est produit. Lorsque vous avez écrit la classe, vous n'aviez aucune idée des délégués qu'elle finirait par exécuter. Au lieu de cela, cela est déterminé par celui qui utilise votre classe.