Qu'est-ce que Délégué?

un délégué est simplement un pointeur de fonction.

pour faire simple vous attribuer la méthode que vous souhaitez exécuter votre délégué.
puis plus tard dans le code, vous pouvez appeler la méthode via Invoquer.

un peu de code pour démontrer (écrit ceci à partir de la mémoire si la syntaxe est peut-être éteint)

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);
}

Penser à déléguer à propos d'une mise en oeuvre simplifiée du modèle de Commande.

Ici, je vais vous expliquer les délégués, multidiffusion des délégués et de leur utilisation..
Déléguer est un type qui tient la ou les méthode(s) de référence à un objet. Il est également considéré comme un type sûr de pointeur de fonction. On peut dire qu'un délégué est un type qui définit une signature de la méthode.

Lorsque vous instanciez un délégué, vous pouvez associer son exemple avec la méthode, avec une signature compatible. Vous pouvez appeler la méthode à travers l'instance de délégué.
Les délégués sont utilisés pour passer des méthodes comme arguments à d'autres méthodes.
Les gestionnaires d'événements sont rien de plus que les méthodes qui sont appelées par l'intermédiaire de délégués.
Avantages de l'utilisation de délégués,
L'encapsulation de l'application de la méthode d'appel de l'appelant
L'utilisation efficace de déléguer améliore les performances de l'application
Utilisé pour appeler une méthode asynchrone.
Il y a quelques propriétés des 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.

public délégué type_of_delegate delegate_name() //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 String.

L'exemple suivant montre un délégué de l'opération:

    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 que Délégué Multicast?

Il est un délégué qui détient la référence de plus d'une méthode. Multidiffusion les délégués ne doit contenir que des méthodes qui retourne 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 Délégué est ajouté à l'aide de l'opérateur += et supprimés à l'aide de l'opérateur -=.

Délégué types sont dérivées de la Délégué de classe dans la .NET Framework. Délégué types sont scellées, elles ne peuvent être dérivées.
Parce que le instancié délégué est un objet, il peut être passé en paramètre, ou affecté à un bien. Cela permet à une méthode d'accepter un délégué en tant que paramètre, et appeler le délégué de quelque temps plus tard. Ceci est connu comme un rappel asynchrone.

En Cas de communication de l'expéditeur ne sait pas quel est l'objet qui gérera l'événement.
Délégué est le type qui maintiennent la référence de la méthode.
Le délégué a la signature et contient la référence à la méthode qui correspond à sa signature
donc, Délégué est comme sécurisée de type pointeur de fonction.

button1.Click += new System.EventHandler(button1_Click)
Système.Ce gestionnaire est déclaré en tant que délégué ici
Dans .net Événements de travailler sur la notion de Délégué (comme le Bouton de la souris)

Délégué est utilisé lorsque vous ne connaissez pas le code pour appeler au moment de l'exécution
Donc, à l'époque Délégué est utilisé pour gérer les Événements

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

Un délégué est un objet qui représente un pointeur à une fonction. Cependant, il n'est pas ordinaire pointeur de fonction en ce qu'il:

1) Est Orienté Objet

2) Est de type sécurisé, c'est à dire qu'il ne peut point d'une méthode et vous ne pouvez pas lire le raw adresse de mémoire il pointe vers

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

4) Peut-point de plus qu'une méthode à la fois.

Un délégué est quelque chose à laquelle une tâche est déléguée à. Le but principal de la délégation est de découpler le code et permettre une plus grande souplesse et à la réutilisation.

Dans la programmation, et plus précisément la programmation orientée objet, cela signifie que lorsqu'une méthode est appelée à faire un peu de travail, il passe le travail sur la méthode d'un autre objet qu'il a une référence à l'. La référence peut pointer vers n'importe quel objet que l'on souhaite, tant que l'objet est conforme à un ensemble prédéfini de méthodes. Nous l'appelons "la programmation d'une interface" (par rapport à la programmation d'une classe concrète de mise en œuvre). Une interface est essentiellement un modèle générique et n'a pas de mise en œuvre; elle signifie simplement une recette, un ensemble de méthodes, les préconditions et les postconditions (les 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 quel que soit mise en œuvre que je veux à tout moment sans changer le code dans SomeCaller parce que le type qui doIt() est passé n'est pas en béton mais plutôt abstraite, puisque c'est une interface. Dans le monde Java, ce qui est souvent exprimé dans le paradigme du service où vous appel à un service (un objet de la publicité elle-même comme un service via une interface spécifique) et le service d'appels à des délégués pour l'aider à faire son travail. Le service méthodes sont nommés en tant que gros grains de tâches (makePayment(), createNewUser(), etc.), alors qu'intérieurement il fait beaucoup si nitty-gritty de travail par délégation, avec les délégués types d'interfaces au lieu de le 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();
    }
}

(N. B.: Comment une œuvre est affectée est au-delà de la portée de ce fil. De recherche de l'inversion de contrôle et l'injection de dépendance.)