Quelqu’un peut-il distiller en anglais qui est ce qu’est un délégué?

Dans les termes les plus simples possibles, il s’agit essentiellement d’un pointeur sur une méthode.

Vous pouvez avoir une variable contenant un type de délégué (tout comme une variable int pouvant contenir un type int). Vous pouvez exécuter la méthode indiquée par le délégué en appelant simplement votre variable comme une fonction.

Cela vous permet d’avoir des fonctions variables, tout comme vous pourriez avoir des données variables. Votre object peut accepter des delegates d’autres objects et les appeler, sans avoir à définir lui-même toutes les fonctions possibles.

Cela s’avère très utile lorsque vous souhaitez qu’un object agisse en fonction de critères spécifiés par l’utilisateur. Par exemple, filtrer une liste en fonction d’une expression true / false définie par l’utilisateur. Vous pouvez laisser l’utilisateur spécifier la fonction de délégué à utiliser en tant que filtre pour évaluer chaque élément de la liste.

J’ai une fonction:

public long GiveMeTwoTimesTwo() { return 2 * 2; } 

Cette fonction est nul. Et si je veux 3 * 3?

 public long GiveMeThreeTimesThree() { return 3 * 3; } 

Trop de dactylographie. Je suis fainéant!

 public long SquareOf(int n) { return n * n; } 

Ma fonction SquareOf ne tient pas compte de ce que n est. Il fonctionnera correctement pour tout n entré. Il ne sait pas exactement quel nombre n est, mais il sait que n est un entier. Vous ne pouvez pas transmettre "Haha not an integer" à SquareOf .

Voici une autre fonction:

 public void DoSomethingRad() { int x = 4; long y = SquareOf(x); Console.WriteLine(y); } 

Contrairement à son nom, DoSomethingRad ne fait rien en réalité. Cependant, il écrit le SquareOf (4) qui est 16. Peut-on le changer pour qu’il soit moins ennuyeux?

 public void DoSomethingRad(int numberToSquare) { long y = SquareOf(numberToSquare); Console.WriteLine(y); } 

DoSomethingRad est clairement toujours assez échoué. Mais au moins, nous pouvons maintenant passer d’un nombre à l’autre pour qu’il n’écrive pas 16 à chaque fois. (Ça va écrire 1, ou 4, ou 9, ou 16, ou … zzzz toujours assez ennuyeux).

Ce serait bien s’il y avait un moyen de changer ce qui arrive au nombre transmis. Peut-être que nous ne voulons pas résoudre le problème; peut-être voulons-nous le mettre en cube ou le soustraire de 69 (nombre choisi au hasard dans ma tête).

Après SquareOf , il semble que la seule partie de SquareOf dont DoSomethingRad soucie est que nous pouvons lui donner un entier ( numberToSquare ) et qu’il nous donne un long (parce que sa valeur de retour dans y et y est long ) .

 public long CubeOf(int n) { return n * n * n; } public void DoSomethingLeet(int numberToSquare) { long y = CubeOf(numberToSquare); Console.WriteLine(y); } 

Voyez comment DoSomethingLeet est similaire à DoSomethingRad ? Si seulement il y avait un moyen de passer un comportement ( DoX() ) au lieu de simplement data ( int n ) …

Alors maintenant, si nous voulons écrire un carré d’un nombre, nous pouvons faire DoSomethingRad et si nous voulons écrire le cube d’un nombre, nous pouvons faire DoSomethingLeet . Donc, si nous voulons écrire le nombre soustrait de 69, devons-nous créer une autre méthode, DoSomethingCool ? Non, car cela prend trop de dactylographie (et surtout, cela empêche notre capacité de modifier un comportement intéressant en ne modifiant qu’un aspect de notre programme).

Nous arrivons donc à:

 public long Radlicious(int doSomethingToMe, Func doSomething) { long y = doSomething(doSomethingToMe); Console.WriteLine(y); } 

Nous pouvons appeler cette méthode en écrivant ceci:

 Radlicious(77, SquareOf); 

Func est un type spécial de délégué. Il stocke le comportement qui accepte les entiers et crache des s long . Nous ne sums pas sûrs de ce que la méthode décrite va faire avec un entier donné que nous passons; tout ce que nous soaps, c’est que, quoi qu’il arrive, nous aurons un long retour.

Nous n’avons pas à donner de paramètre à SquareOf car Func décrit le comportement , pas les données. L’appel de Radlicious(77, SquareOf) donne simplement à Radlicious le comportement général de SquareOf (“je prends un nombre et lui retourne son carré”), et non ce que SquareOf fera à un entier spécifique .

Maintenant, si vous avez compris ce que je dis, alors vous m’avez déjà dépassé, car je ne comprends pas vraiment ce genre de choses.

* RÉPONSE FINALE, COMMENCEZ À L’IDIOCIE GAGNANTE *

Je veux dire, il semble que les int pourraient être perçus comme un comportement vraiment ennuyeux:

 static int Nine() { return 9; } 

Cela dit, la ligne de démarcation entre données et comportement semble s’estomper, ce qui est normalement perçu comme une donnée est tout simplement un comportement ennuyeux.

Bien sûr, on pourrait imaginer un comportement super “intéressant”, qui prend toutes sortes de parameters abstraits, mais qui nécessite une tonne d’informations pour pouvoir l’appeler. Et si cela nous obligeait à fournir le code source qu’il comstackrait et exécuterait pour nous?

Eh bien, alors notre abstraction semble nous avoir ramené à la case départ. Nous avons un comportement si abstrait qu’il faut tout le code source de notre programme pour déterminer ce qu’il va faire. C’est un comportement totalement indéterminé: la fonction peut tout faire, mais elle doit être fournie avec tout ce qui est en jeu pour déterminer ce qu’elle fait. D’autre part, un comportement totalement déterminé, tel que Nine() , ne nécessite aucune information supplémentaire, mais ne peut rien faire d’autre que de renvoyer 9 .

Et alors? Je ne sais pas.

Un délégué est un pointeur sur une méthode. Vous pouvez ensuite utiliser votre délégué comme paramètre d’autres méthodes.

voici un lien vers un tutoriel simple.

La question que j’avais était: «Alors, pourquoi voudrais-je faire cela? Vous ne l’obtiendrez pas vraiment tant que vous n’aurez pas résolu le problème de programmation.

Il est intéressant de noter que personne n’a mentionné l’un des principaux avantages de la délégation – il est préférable de le sous-classer lorsque vous réalisez que l’inheritance n’est pas une solution miracle et crée généralement plus de problèmes qu’il n’en résout. C’est la base de nombreux modèles de conception, notamment le modèle de stratégie .

Une instance de délégué est une référence à une méthode. Leur utilité tient au fait que vous pouvez créer un délégué lié à une méthode particulière sur une instance particulière d’un type. L’instance de délégué vous permet d’appeler cette méthode sur cette instance particulière même si l’object sur lequel vous allez invoquer la méthode a quitté votre étendue lexicale.

L’utilisation la plus courante des instances de délégué de ce type consiste à prendre en charge le concept de rappel au niveau de la langue.

Il fait simplement référence à une méthode. Ils sont très utiles pour travailler avec le filetage croisé.

Voici un exemple tout droit sorti de mon code.

  //Start our advertisiment thread rotator = new Thread(initRotate); rotator.Priority = ThreadPriority.Lowest; rotator.Start(); #region Ad Rotation private delegate void ad(); private void initRotate() { ad ad = new ad(adHelper); while (true) { this.Invoke(ad); Thread.Sleep(30000); } } private void adHelper() { List tmp = Lobby.AdRotator.RotateAd(); picBanner.ImageLocation = @tmp[0].ToSsortingng(); picBanner.Tag = tmp[1].ToSsortingng(); } #endregion 

Si vous n’avez pas utilisé de délégué, vous ne pourriez pas vous identifier et appeler la fonction Lobby.AdRotator.

Comme d’autres l’ont dit, un délégué est une référence à une fonction. Une des utilisations les plus bénéfiques (IMO) est les événements. Lorsque vous enregistrez un événement, vous enregistrez une fonction pour l’événement à appeler et les delegates sont parfaits pour cette tâche.

Dans les termes les plus élémentaires, un délégué est simplement une variable qui contient (une référence à) une fonction. Les delegates sont utiles car ils vous permettent de transmettre une fonction en tant que variable sans se soucier de “d’où” provient réellement la fonction.

Bien sûr, il est important de noter que la fonction n’est pas copiée lorsqu’elle est regroupée dans une variable; c’est juste être lié par référence. Par exemple:

 class Foo { public ssortingng Bar { get; set; } public void Baz() { Console.WriteLine(Bar); } } Foo foo = new Foo(); Action someDelegate = foo.Baz; // Produces "Hello, world". foo.Bar = "Hello, world"; someDelegate(); 

En termes les plus simples, la responsabilité d’exécuter une méthode est déléguée à un autre object. Supposons que le président d’une nation décède et que le président des États-Unis soit censé être présent à l’enterrement avec message de condoléances. Si le président des États-Unis ne peut pas y aller, il déléguera cette responsabilité à l’un des vice-présidents ou au secrétaire de l’État.

La même chose va dans le code. Un délégué est un type, c’est un object capable d’exécuter la méthode.

par exemple.

 Class Person { public ssortingng GetPersonName(Person person) { return person.FirstName + person.LastName; } //Calling the method without the use of delegate public void PrintName() { Console.WriteLine(GetPersonName(this)); } //using delegate //Declare delegate which matches the methods signature public delegate ssortingng personNameDelegate(Person person); public void PrintNameUsingDelegate() { //instantiate personNameDelegate = new personNameDelegate(GetPersonName); //invoke personNameDelegate(this); } } 

La méthode GetPersonName est appelée à l’aide de l’object délégué personNameDelegate. Alternativement, nous pouvons avoir la méthode PrintNameUsingDelegate pour prendre un délégué en tant que paramètre.

 public void PrintNameUsingDelegate(personNameDelegate pnd, Person person) { pnd(person); } 

L’avantage est que si quelqu’un veut imprimer le nom en tant que lastname_firstname, il lui suffit d’envelopper cette méthode dans personNameDelegate et de la passer à cette fonction. Aucun autre changement de code n’est requirejs.

Les delegates sont particulièrement importants pour

1. Événements
2. Appels asynchrones
3. LINQ (comme expressions lambda)

Si vous deviez déléguer une tâche à quelqu’un, le délégué serait la personne qui reçoit le travail.

En programmation, c’est une référence au bloc de code qui sait réellement faire quelque chose. Il s’agit souvent d’un pointeur sur la fonction ou la méthode qui gérera un élément.

Dans les termes les plus simples que je puisse trouver, voici ceci: Un délégué forcera le fardeau du travail entre les mains d’une classe qui sait à peu près ce qu’il faut faire. Pensez-y comme un enfant qui ne veut pas devenir complètement son grand frère mais qui a toujours besoin de ses conseils et de ses ordres. Au lieu d’hériter toutes les méthodes de son frère (c.-à-d. Le sous-classement), il demande simplement à son frère de faire le travail ou Le petit frère fait quelque chose qui nécessite des actions du grand frère. Lorsque vous tombez dans les lignes de protocoles, le grand frère définit ce qui est absolument nécessaire, ou il vous donne la possibilité de choisir ce que vous voulez lui faire faire lors de certains événements (protocoles informels et formels décrits dans l’objective C).

L’avantage absolu de ce concept est qu’il n’est pas nécessaire de créer une sous-classe. Si vous souhaitez que quelque chose se mette en place, suivez les ordres lorsqu’un événement se produit, le délégué permet à une classe développée de garder sa main et de donner des ordres si nécessaire.