Qu'est-ce qu'un délégué?
Je suis confus que quel est le rôle réel d'un délégué?
On m'a posé cette question à plusieurs reprises lors de mes entretiens, mais je ne pense pas que les intervieweurs étaient satisfaits de ma réponse.
Quelqu'un peut-il me donner la meilleure définition, en une phrase, avec un exemple concret?
J'aime penser à un délégué comme "un pointeur sur une fonction". Cela remonte aux jours C, mais l'idée est toujours valable.
L'idée est que vous devez être en mesure d'invoquer un morceau de code, mais ce morceau de code que vous allez invoquer n'est connu qu'au moment de l'exécution. Donc, vous utilisez un "délégué" à cette fin. Les délégués sont utiles pour des choses telles que les gestionnaires d'événements, par exemple lorsque vous faites différentes choses en fonction d'événements différents.
Voici une référence pour C #, vous pouvez regarder:
En C #, par exemple, supposons que nous voulions effectuer un calcul et utiliser une méthode de calcul différente que nous ne connaissons pas avant l'exécution. Donc, nous pourrions avoir quelques méthodes de calcul comme ceci:
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é en tant que paramètre comme ceci:
public static double CalcMyTotal(double amt, calcTotalDelegate calcTotal)
{
return calcTotal(amt);
}
Et nous pourrions appeler la méthode CalcMyTotal en transmettant la méthode déléguée 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.
vous définissez simplement la méthode que vous souhaitez utiliser pour 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, donc la syntaxe peut être 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);
}
[~ # ~] q [~ # ~] Que sont les délégués?
[~ # ~] a [~ # ~] Lorsqu'un objet reçoit une demande, il peut gérer la demande lui-même ou transmettez la demande à un deuxième objet pour effectuer le travail. Si l'objet décide de transmettre la demande, vous indiquez qu'il a transféré la responsabilité du traitement de la demande au deuxième objet.
Ou, comme pseudo exemple simple: quelque chose envoie une requête à object1. object1 transmet ensuite la requête et lui-même à object2 - le délégué. object2 traite la requête et effectue certains travaux. (note: le lien ci-dessus donne de bons exemples)
Un délégué est un objet pouvant faire référence à une méthode. Ainsi, lorsque nous créons un délégué, nous créons un objet pouvant contenir une référence à une méthode. De plus, la méthode peut être appelée par cette référence. Ainsi, un délégué peut invoquer la méthode à laquelle il fait référence. L'avantage principal d'un délégué est qu'il nous permet de spécifier un appel à une méthode, mais que la méthode réellement invoquée est déterminée au moment de l'exécution, pas au moment de la compilation.
Délégué simple
Declaration of delegate:
delegate-modifier delegate return-type delegate-name(parameters)
Implementation of delegate:
Delegate-name delegate-object=new Delegate-name(method of class)
Pensez à déléguer comme à une implémentation simplifiée du modèle de commande.
Ici, je vais expliquer les délégués, les délégués de multidiffusion et leur utilisation. Déléguer est un type qui contient la méthode de référence (s) dans un objet. Il est également appelé pointeur de fonction de type sécurisé. Nous pouvons 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 à n’importe quelle méthode avec une signature compatible. Vous pouvez appeler (ou appeler) la méthode via l'instance de délégué. Les délégués sont utilisés pour transmettre des méthodes en tant qu'arguments à d'autres méthodes. Les gestionnaires d'événements ne sont rien de plus que des méthodes invoquées par le biais de délégués. Encapsuler l'appel de l'appelant de la méthode par une utilisation L'utilisation efficace du délégué améliore les performances de l'application Utilisée pour appeler une méthode de manière asynchrone. Il y a quelques propriétés de délégués 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.
delegate public type_of_delegate delegate_name () // Declaration
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 String.
L'exemple suivant montre une opération de délégué:
namespace MyDelegate
{
class Program
{
private delegate void Show(string s);
// Create a method for a delegate.
public static void MyDelegateMethod(string me
ssage)
{
System.Console.WriteLine(message);
}
static void Main(string[] args)
{
Show p = MyDelegateMethod;
p("My Delegate");
p.Invoke("My Delegate");
System.Console.ReadLine();
}
}
}
Qu'est-ce qu'un délégué de multidiffusion?
C'est un délégué qui détient la référence de plusieurs méthodes. Les délégués de multidiffusion ne doivent contenir que des méthodes qui renvoient void, sinon il y a une exception d'exécution.
delegate void MyMulticastDelegate(int i, string s);
Class Class2
{
static void MyFirstDelegateMethod(int i, string s)
{
Console.WriteLine("My First Method");
}
static void MySecondDelegateMethod(int i, string s)
{
Console.WriteLine("My Second Method");
}
static void Main(string[] 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, le délégué 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 du .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 objet, il peut être transmis en tant que paramètre ou attribué à 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. Cela s'appelle un rappel asynchrone.
Vous trouverez une grande explication et une mise en œuvre pratique du motif Délégué dans les collections Google Collections Transfert (ainsi que le motif Décorateur).
Un délégué est un objet 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é objet
2) Le type est-il sûr, c’est-à-dire qu’il ne peut pointer que sur une méthode et que vous ne pouvez pas lire l’adresse de mémoire brute à laquelle il pointe
3) est fortement typé. Il ne peut pointer que sur les méthodes correspondant à ses signatures.
4) Peut indiquer plus d’une méthode à la fois.
Dans la communication d'événement, l'expéditeur ne sait pas quel objet gérera l'événement. Délégué est le type qui contient la référence de la méthode. Delegate a une signature et contient une référence à la méthode qui correspond à sa signature, de sorte que Delegate ressemble à un pointeur de fonction sécurisée.
button1.Click + = new System.EventHandler (button1_Click) System.EventHandler est déclaré en tant que délégué ici. Dans .net Events fonctionne sur le concept de délégué (comme un clic sur un bouton).
Delegate est utilisé lorsque vous ne savez pas quel code appeler lors de l'exécution. Donc, à 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 objet délégué est un objet qu'un autre objet consulte lorsqu'il se passe quelque chose dans cet objet. 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 la voiture eux-mêmes, auquel cas, ils sont leurs propres délégués pour leur voiture).
Les délégués 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 souhaitez exécuter cette partie de code chaque fois qu'un événement se produit.
Exemple:
- Application console - le code ne peut être exécuté qu'au moment de l'exécution du programme. (Écrit à l'intérieur de la méthode principale)
- Application Windows (programmation d'interface utilisateur) - le code peut être exécuté lorsque vous cliquez sur le bouton après avoir exécuté le programme.
C'est ce qu'ils disent, vous ne savez pas quelle méthode invoquera à la compilation. vous ne le connaissez qu'au moment de l'exécution lorsque vous cliquez sur le bouton.
Sans délégués, 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 une zone de texte, en sélectionnant un élément de la liste déroulante, etc.
Un délégué est quelque chose à laquelle une tâche est déléguée. L'objectif principal de la délégation est de découpler le code et de permettre une plus grande flexibilité et une réutilisation.
En programmation, et en particulier en programmation orientée objet, cela signifie que lorsqu'une méthode est appelée pour effectuer un travail, elle transfère le travail à la méthode d'un autre objet auquel elle fait référence. La référence peut pointer sur l'objet de votre choix, à condition que celui-ci soit conforme à un ensemble de méthodes prédéfini. Nous appelons cela "la 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, de conditions préalables et post-conditions (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 que je veux à tout moment sans changer le code dans SomeCaller car le type qui est passé par doIt() n'est pas concret mais plutôt abstrait puisqu'il s'agit d'une interface. Dans le monde Java, cela est souvent exprimé dans le paradigme du service où vous appelez un service (un objet se faisant passer pour un service via une interface spécifique) et le service appelle ensuite les délégués. Les méthodes du service sont appelées tâches à granularité grossière (makePayment (), createNewUser (), etc.), alors qu’en interne, cela fait beaucoup si la tâche est bien déléguée, les types de délégués étant des interfaces. au lieu 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 manière dont une implémentation est affectée dépasse le cadre de ce fil. Inversion de référence du contrôle et injection de dépendance.)