Avantages de l'utilisation de délégués?

Quand vous pouvez directement appeler une méthode, vous ne pas besoin d'un délégué.

Un délégué est utile lorsque le code de l'appel de la méthode ne sais pas/soin de ce que la méthode qu'il appelle est -- par exemple, vous pouvez invoquer un travail de longue haleine et lui passer un délégué à une méthode de rappel que la tâche peut utiliser pour envoyer des notifications à propos de son statut.

Voici un (très bête) exemple de code:

enum TaskStatus
{
   Started,
   StillProcessing,
   Finished
}

delegate void CallbackDelegate(Task t, TaskStatus status);

class Task
{
    public void Start(CallbackDelegate callback)
    {
        callback(this, TaskStatus.Started);

        //calculate PI to 1 billion digits
        for (...)
        {
            callback(this, TaskStatus.StillProcessing);
        }

        callback(this, TaskStatus.Finished);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Task t = new Task();
        t.Start(new CallbackDelegate(MyCallbackMethod));
    }

    static void MyCallbackMethod(Task t, TaskStatus status)
    {
        Console.WriteLine("The task status is {0}", status);
    }
}

Comme vous pouvez le voir, le Task classe ne sais pas ou des soins -- dans ce cas, le délégué est une méthode qui imprime l'état de la tâche de la console. La méthode pourrait tout aussi bien envoyer l'état d'une connexion réseau à un autre ordinateur. Etc.

OriginalL'auteur Ben M

Techniquement, vous n'avez pas à utiliser des délégués (sauf lors de l'utilisation de les gestionnaires d'événements, il est alors nécessaire). Vous pouvez vous en tirer sans eux. Vraiment, ils sont juste un autre outil dans la boîte à outils.

La première chose qui vient à l'esprit à propos de l'utilisation, est L'Inversion De Contrôle. Chaque fois que vous voulez contrôler la façon dont une fonction se comporte de l'extérieur, la meilleure façon de le faire est de placer un délégué en tant que paramètre, et exécuter le délégué.

OriginalL'auteur kemiller2002

Il y a deux endroits que vous pouvez utiliser délégués dans le pattern observer. Depuis que je ne suis pas sûr que l'on vous parle, je vais essayer de répondre à deux.

La première consiste à utiliser des délégués dans le sujet au lieu d'une liste de IObservers. Cette approche semble beaucoup plus propre à la gestion de la multidiffusion depuis en gros, vous avez

private delegate void UpdateHandler(string message);
private UpdateHandler Update;

public void Register(IObserver observer)
{
    Update+=observer.Update;
}

public void Unregister(IObserver observer)
{
    Update-=observer.Update;
}

public void Notify(string message)
{
    Update(message);
}

au lieu de

public Subject()
{
    observers = new List<IObserver>();
}

public void Register(IObserver observer)
{
    observers.Add(observer);
}

public void Unregister(IObserver observer)
{
    observers.Remove(observer);
}

public void Notify(string message)
{
    //call update method for every observer
    foreach (IObserver observer in observers)
    {
        observer.Update(message);
    }
}

Sauf si vous avez besoin de faire quelque chose de spécial et qui nécessitent une référence à l'ensemble de la IObserver objet, je pense que les délégués serait plus propre.

Le deuxième cas consiste à utiliser le pass délégués au lieu de IObervers par exemple

public delegate void UpdateHandler(string message);
private UpdateHandler Update;

public void Register(UpdateHandler observerRoutine)
{
    Update+=observerRoutine;
}

public void Unregister(UpdateHandler observerRoutine)
{
    Update-=observerRoutine;
}

public void Notify(string message)
{
    Update(message);
}

Avec cela, les Observateurs n'ont pas besoin d'implémenter une interface. Vous pouvez même passer dans une expression lambda. Cette des changements dans le niveau de contrôle est à peu près la différence. Si c'est bon ou mauvais est à vous.

OriginalL'auteur Jacob Adams

Je suis à la répétition d'une réponse que j'ai donné à cette question.

J'ai toujours comme la Station de Radio métaphore.

Lorsqu'une station de radio souhaite diffuser de quelque chose, c'est juste qu'il dirige. Il n'a pas besoin de savoir si il est en fait il ya quelqu'un à l'écoute. Votre radio est en mesure de s'enregistrer avec la station de radio (par le réglage avec la molette), et toutes les émissions de radio (les événements dans notre petite métaphore) sont reçus par la radio qui se traduit en sons.

Sans cette inscription (ou un événement). La station de radio ont à communiquer avec chaque radio à son tour et lui demander s'il voulait l'émission, si votre radio a dit oui, puis envoyer le signal directement.

Votre code peut très proche de paradigme, où une classe effectue une action, mais cette classe ne peut pas savoir, ou ne pas vouloir savoir qui ne se soucient, ou d'agir sur cette action. Il fournit un moyen pour n'importe quel objet à enregistrer ou annuler l'enregistrement lui-même pour la notification que l'action a eu lieu.

OriginalL'auteur Matthew Vines

J'ai entendu dire que certains événements "évangélistes" parler de cela et ils disent que comme de plus en plus découplées événements sont, mieux c'est.

De préférence, la source de l'événement ne doit jamais savoir sur les écouteurs d'événement et l'écouteur d'événement ne devrait jamais se soucient qui est à l'origine de l'événement. Ce n'est pas la façon dont les choses sont aujourd'hui parce que dans l'écouteur d'événement vous recevez normalement l'objet source de l'événement.

Avec cela dit, les délégués sont l'outil parfait pour ce travail. Ils permettent le découplage entre la source de l'événement et l'événement observateur parce que la source de l'événement n'a pas besoin de garder une liste de tous les observateurs objets. Il ne conserve qu'une liste de pointeurs de fonction" (délégués) des observateurs.
De ce fait, je pense que c'est un grand avantage sur les Interfaces.

OriginalL'auteur bruno conde

En fait il y avait un va-et-vient entre Sun et Microsoft sur les délégués. Alors que le Soleil fait une assez forte position contre les délégués, j'ai l'impression que Microsoft a fait une encore plus fort point pour l'utilisation de délégués. Voici les messages:

http://java.sun.com/docs/white/delegates.html

http://msdn.microsoft.com/en-us/vjsharp/bb188664.aspx

Je pense que vous trouverez ces lecture intéressante...

OriginalL'auteur code4life

Ici est quelque chose que je peux écrire comme une raison de l'utilisation de délégué.
Le code suivant est écrit en C# Et suivez les commentaires.

public delegate string TestDelegate();
protected void Page_Load(object sender, EventArgs e)
{
    TestDelegate TD1 = new TestDelegate(DiaplayMethodD1);
    TestDelegate TD2 = new TestDelegate(DiaplayMethodD2);
    TD2 = TD1 + TD2; //Make TD2 as multi-cast delegate
    lblDisplay.Text =  TD1(); //invoke delegate
    lblAnotherDisplay.Text = TD2();


    //Note: Using a delegate allows the programmer to encapsulate a reference 
    //      to a method inside a delegate object. Its like the function pointer
    //      in C or C++.    
}
//the Signature has to be same.
public string DiaplayMethodD1()
{
    //lblDisplay.Text = "Multi-Cast Delegate on EXECUTION"; //Enable on multi-cast 
    return "This is returned from the first method of delegate explanation";
}
//The Method can be static also
public static string DiaplayMethodD2()
{
    return " Extra words from second method";
}

Meilleures Salutations,
Pritom Nandy,
Bangladesh

OriginalL'auteur Pritom Nandy