Qu’est-ce qu’un délégué?

Je suis confus que quel est le rôle actuel d’un délégué? On m’a posé cette question à plusieurs resockets dans mes entretiens, mais je ne pense pas que les intervieweurs étaient satisfaits de ma réponse.

Quelqu’un peut-il me dire la meilleure définition, en une phrase, avec un exemple pratique?

Merci

J’aime penser à un délégué comme “un pointeur vers une fonction”. Cela remonte à C days, mais l’idée tient toujours.

L’idée est que vous devez être capable d’appeler un morceau de code, mais ce morceau de code que vous allez appeler n’est pas connu avant l’exécution. Donc, vous utilisez un “délégué” à cette fin. Les delegates sont utiles pour des choses comme les gestionnaires d’événements, par exemple, où vous faites différentes choses en fonction de différents événements.

Voici une référence pour C #:

En C #, par exemple, supposons que nous voulions faire un calcul et que nous voulions utiliser une méthode de calcul différente que nous ne connaissons pas avant l’exécution. Nous pourrions donc avoir quelques méthodes de calcul comme celle-ci:

public static double CalcTotalMethod1(double amt) { return amt * .014; } public static double CalcTotalMethod2(double amt) { return amt * .056 + 42.43; } 

Nous pourrions déclarer une signature de délégué comme ceci:

 public delegate double calcTotalDelegate(double amt); 

Et puis nous pourrions déclarer une méthode qui prend le délégué comme paramètre comme ceci:

 public static double CalcMyTotal(double amt, calcTotalDelegate calcTotal) { return calcTotal(amt); } 

Et nous pourrions appeler la méthode CalcMyTotal passant dans la méthode delegate que nous voulions utiliser.

 double tot1 = CalcMyTotal(100.34, CalcTotalMethod1); double tot2 = CalcMyTotal(100.34, CalcTotalMethod2); Console.WriteLine(tot1); Console.WriteLine(tot2); 

un délégué est simplement un pointeur de fonction.
il suffit de mettre vous atsortingbuer la méthode que vous souhaitez exécuter votre délégué. puis plus tard dans le code, vous pouvez appeler cette méthode via Invoke.

du code à démontrer (écrit ceci de la mémoire pour que la syntaxe soit désactivée)

 delegate void delMyDelegate(object o); private void MethodToExecute1(object o) { // do something with object } private void MethodToExecute2(object o) { // do something else with object } private void DoSomethingToList(delMyDelegate methodToRun) { foreach(object o in myList) methodToRun.Invoke(o); } public void ApplyMethodsToList() { DoSomethingToList(MethodToExecute1); DoSomethingToList(MethodToExecute2); } 

Prise d’ici

Q Que sont les delegates?
A Lorsqu’un object reçoit une demande, l’object peut gérer la demande elle-même ou transmettre la demande à un second object pour effectuer le travail. Si l’object décide de transmettre la demande, vous dites que l’object a transféré la responsabilité du traitement de la demande au second object.

Ou, comme un pseudo exemple simple: quelque chose envoie une requête à object1. object1 transfère alors la requête et s’adresse elle-même à object2 – le délégué. object2 traite la requête et effectue un travail. (note: le lien ci-dessus donne de bons exemples)

Pensez à déléguer comme à une implémentation simplifiée du modèle de commande.

Un délégué est un object pouvant faire référence à une méthode. Ainsi, lorsque nous créons un délégué, nous créons un object pouvant contenir une référence à une méthode. De plus, la méthode peut être appelée via cette référence. Ainsi, un délégué peut invoquer la méthode à laquelle il fait référence. Le principal avantage d’un délégué est qu’il nous permet de spécifier un appel à une méthode, mais que la méthode invoquée est déterminée à l’exécution et non à la compilation.

Simple délégué

 Declaration of delegate: delegate-modifier delegate return-type delegate-name(parameters) Implementation of delegate: Delegate-name delegate-object=new Delegate-name(method of class) 

http://knowpacific.wordpress.com/2012/01/26/delegate/

Ici, je vais expliquer les delegates, les delegates à la multidiffusion et leur utilisation. Delegate est un type qui contient la référence de la méthode dans un object. Il est également appelé un pointeur de fonction de type sécurisé. On peut dire qu’un délégué est un type qui définit une signature de méthode.

Lorsque vous instanciez un délégué, vous pouvez associer son instance à toute méthode avec une signature compatible. Vous pouvez appeler (ou appeler) la méthode via l’instance du délégué. Les delegates sont utilisés pour transmettre des méthodes comme arguments à d’autres méthodes. Les gestionnaires d’événements ne sont rien d’autre que des méthodes appelées par des delegates. Les avantages de l’utilisation des delegates sont les suivants: Encapsulation de l’appel de la méthode à partir de l’appelant L’utilisation efficace du délégué améliore les performances de l’application Utilisé pour appeler une méthode de manière asynchrone. Il y a quelques propriétés des delegates sont

 Delegates are like C++ function pointers but are type safe. Delegates allow methods to be passed as parameters. Delegates can be used to define callback methods. Delegates can be chained together; for example, multiple methods can be called on a single event. Methods do not have to match the delegate signature exactly. 

délégué public type_of_delegate nom_délégué () // Déclaration

 You can use delegates without parameters or with parameter list If you are referring to the method with some data type then the delegate which you are declaring should be in the same format. This is why it is referred to as type safe function pointer. Here I am giving an example with Ssortingng. 

L’exemple suivant montre une opération de délégué:

  namespace MyDelegate { class Program { private delegate void Show(ssortingng s); // Create a method for a delegate. public static void MyDelegateMethod(ssortingng me ssage) { System.Console.WriteLine(message); } static void Main(ssortingng[] args) { Show p = MyDelegateMethod; p("My Delegate"); p.Invoke("My Delegate"); System.Console.ReadLine(); } } } 

Qu’est-ce que Multicast Delegate?

C’est un délégué qui détient la référence de plusieurs méthodes. Les delegates multidiffusion ne doivent contenir que des méthodes qui renvoient void, sinon il existe une exception d’exécution.

  delegate void MyMulticastDelegate(int i, ssortingng s); Class Class2 { static void MyFirstDelegateMethod(int i, ssortingng s) { Console.WriteLine("My First Method"); } static void MySecondDelegateMethod(int i, ssortingng s) { Console.WriteLine("My Second Method"); } static void Main(ssortingng[] args) { MyMulticastDelegate Method= new MyMulticastDelegate(MyFirstDelegateMethod); Method+= new MyMulticastDelegate (MySecondDelegateMethod); Method(1,"Hi"); // Calling 2 Methodscalled Method-= new MyMulticastDelegate (MyFirstDelegateMethod); Method(2,"Hi"); //Only 2nd Method calling } } 

Ici, Delegate est ajouté à l’aide de l’opérateur + = et supprimé à l’aide de l’opérateur – =.

Les types de délégué sont dérivés de la classe Delegate dans le .NET Framework. Les types de délégué sont scellés – ils ne peuvent pas être dérivés. Le délégué instancié étant un object, il peut être transmis en tant que paramètre ou affecté à une propriété. Cela permet à une méthode d’accepter un délégué en tant que paramètre et d’appeler le délégué ultérieurement. Ceci est connu comme un rappel asynchrone.

Une excellente explication et une implémentation pratique du modèle de délégué peuvent être trouvées dans les classes de transfert des collections Google (également le motif Décorateur).

Dans Event communication, l’expéditeur ne sait pas quel object traitera l’événement. Delegate est un type qui détient la référence de méthode. Delegate a la signature et contient une référence à la méthode qui correspond à sa signature, de sorte que Delegate est comme un pointeur de fonction sécurisé de type.

button1.Click + = new System.EventHandler (button1_Click) System.EventHandler est déclaré ici en tant que délégué In .net Events fonctionne sur le concept de Delegate (comme Button Click)

Delegate est utilisé lorsque vous ne savez pas quel code appeler au moment de l’exécution. À ce moment-là, Delegate est utilisé pour gérer les événements.

http://msdn.microsoft.com/en-us/library/ms173171(v=vs.80).aspx

Un object délégué est un object que consulte un autre object lorsque quelque chose se produit dans cet object. Par exemple, votre réparateur est votre délégué si quelque chose arrive à votre voiture. vous allez chez votre réparateur et lui demandez de réparer la voiture pour vous (bien que certains préfèrent réparer eux-mêmes la voiture, auquel cas ils sont leur propre délégué pour leur voiture).

Un délégué est un object qui représente un pointeur sur une fonction. Cependant, ce n’est pas un pointeur de fonction ordinaire en ce sens qu’il:

1) est orienté object

2) Le type est-il sûr, c’est-à-dire qu’il ne peut pointer que vers une méthode et que vous ne pouvez pas lire l’adresse mémoire brute vers laquelle il pointe?

3) Est fortement typé. Il ne peut que pointer vers des méthodes correspondant à ses signatures.

4) Peut indiquer plus d’une méthode à la fois.

Les delegates sont principalement utilisés avec des événements.

Le besoin est:

Vous ne voulez pas exécuter un morceau de code au moment où vous exécutez le programme. Après avoir exécuté le programme, vous voulez exécuter ce morceau de code chaque fois qu’un événement se produit.

Exemple :

  1. Application console – le code ne peut être exécuté qu’au moment où vous exécutez le programme. (Écrit à l’intérieur de la méthode principale)
  2. Application Windows (programmation de l’interface utilisateur) – Le code peut être exécuté en cliquant sur le bouton après avoir exécuté le programme.

C’est ce qu’ils disent, vous ne savez pas quelle méthode invoquera au moment de la compilation. vous ne le savez qu’au moment de l’exécution lorsque vous cliquez sur le bouton.

Sans delegates, aucune programmation d’interface utilisateur n’est possible. Parce que vous exécutez du code chaque fois que l’utilisateur crée des événements en cliquant sur le bouton, en tapant dans la zone de texte, en sélectionnant l’élément de liste déroulante, etc.

Un délégué est une tâche à laquelle une tâche est déléguée. L’objective principal de la délégation est de découpler le code et de permettre une plus grande flexibilité et réutilisation.

Dans la programmation, et plus particulièrement dans la programmation orientée object, cela signifie que lorsqu’une méthode est appelée pour effectuer un travail, elle passe le travail à la méthode d’un autre object auquel elle fait référence. La référence pourrait pointer sur n’importe quel object que nous souhaitons, tant que l’object est conforme à un ensemble de méthodes prédéfini. Nous l’appelons “programmation à une interface” (par opposition à la programmation d’une implémentation de classe concrète). Une interface est fondamentalement un modèle générique et n’a aucune implémentation; cela signifie simplement une recette, un ensemble de méthodes, des conditions préalables et des postconditions (règles).

Exemple simple:

 SomeInterface { public void doSomething(); } SomeImplementation implements SomeInterface { public void doSomething() { System.err.println("Was it good for you?"); } } SomeCaller { public void doIt(SomeInterface someInterface) { someInterface.doSomething(); } } 

Maintenant, vous voyez que je peux utiliser n’importe quelle implémentation à tout moment sans changer le code dans SomeCaller car le type auquel doIt() est passé n’est pas concret mais plutôt abstrait puisqu’il s’agit d’une interface. Dans le monde Java, cela s’exprime souvent dans le paradigme du service où vous appelez un service (un object se affichant lui-même en tant que service via une interface spécifique) et le service appelle ensuite les delegates pour l’aider à faire son travail. Les méthodes du service sont nommées comme tâches à gros grain (makePayment (), createNewUser (), etc.), alors qu’en interne, il fait beaucoup de travail grâce à la délégation, les types de delegates étant des interfaces plutôt que des implémentations concrètes.

 SomeService { SomeInterface someImplementation = ... // assign here SomeOtherInterface someOtherImplementation = ... // okay, let's add a second public void doSomeWork() { someImplementation.doSomething(); someOtherImplementation.doSomethingElse(); } } 

(NB: la façon dont une implémentation est assignée dépasse la scope de ce thread. Inversion de recherche du contrôle et dependency injections.)

Bien que ce ne soit pas vraiment un “pointeur de fonction”, un délégué peut sembler être un langage dynamic comme PHP:

$func = 'foo'; $func(); function foo() { print 'foo'; }
$func = 'foo'; $func(); function foo() { print 'foo'; } 

ou en JavaScript, vous pouvez faire quelque chose comme:

var func = function(){ alert('foo!'); } func();
var func = function(){ alert('foo!'); } func();