Aide à la compréhension des délégués, des événements et des gestionnaires d'événements .NET

Question

Au cours des derniers jours, j'ai posé quelques questions sur les délégués HERE et HERE. J'avoue ... Je ne comprends pas vraiment les délégués. Et je VRAIMENT VRAIMENT VRAIMENT vraiment les comprendre et les maîtriser. (Je peux les définir - type pointeurs de sécurité - mais comme j'ai peu d'expérience avec les langages de type C, ce n'est pas vraiment utile.)

Quelqu'un peut-il recommander des ressources en ligne qui expliqueront les délégués d'une manière cela ne présume rien?

C'est l'un de ces moments où je soupçonne que VB me handicape parce qu'il fait du câblage pour moi dans les coulisses. La ressource idéale expliquerait simplement ce que les délégués sont, sans référence à quoi que ce soit d'autre (events et eventhandlers), me montrerait comment tout est câblé, expliquer (comme je viens d'apprendre) que les délégués sont des types et ce qui fait leur unique en tant que type (peut-être en utilisant un peu de magie ildasm)). Cette fondation s'élargirait ensuite pour expliquer comment les délégués sont liés aux événements et aux manipulateurs d'événements, ce qui nécessiterait une bonne explication. Enfin, cette ressource peut lier tous ensemble en utilisant de vrais exemples et expliquer quel câblage est effectué automatiquement par le compilateur, comment les utiliser, etc. Et, oh oui, quand vous devriez et ne devriez pas utiliser de délégués, en d'autres termes, inconvénients et alternatives à l'aide de délégués.

Que dites-vous? Est-ce que l'un d'entre vous peut me pointer vers des ressources qui peuvent m'aider à commencer mon voyage vers la maîtrise?

EDIT Une dernière chose. La ressource idéale expliquera comment vous pouvez et ne pouvez pas utiliser des délégués dans une déclaration d'interface. C'est quelque chose qui m'a vraiment fait trébucher.

Merci pour votre aide.

Seth

Answer 1

Je commencerai par ceux-ci:

http://www.yoda.arachsys.com/csharp/events.html

http://msdn.microsoft.com/en-us/library/ms173171.aspx

Answer 2

Mon explication préférée vient de Chris Sells:

http://sellsbrothers.com/public/writing/delegates.htm

Answer 3

Jetez un oeil au guide de programmation C# - here est la section délégués.

Answer 4

L'explication la plus simple est que délègue vous permettent d'attribuer dynamiquement le « nom » d'une méthode à une variable ou passer autour en tant que paramètre (vous n'attribuez pas de nom de chaîne, il s'agit d'une référence à la méthode que vous affectez à la variable).

Un autre code peut alors regarder dans la variable et appeler la méthode stockée plus tard. Le délégué doit avoir une définition (comme une interface), et pour cela vous utilisez le mot-clé delegate. Disons que nous avons une définition délégué quelque part qui ressemble à ceci:

public delegate bool NotifyFriendsDelegate(int intensity); 

Cela dit fondamentalement juste que toute méthode (partout) qui retourne un booléen, et prend un seul paramètre de type int est une instance de ce délégué.Ainsi, la définition de délégué spécifie une forme, ou signature, que les méthodes doivent correspondre.

dire Ensuite, nous avons une classe comme ceci:

public class MyCar 
{ 

    public bool GoVisitMyFriends(NotifyFriendsDelegate thingToDoWhenWeGetThere) 
    { 
     var doOurFriendsLikeUs = false; 
     var driving = new DrivingClass(); 
     var didWeGetThere = driving.DoTheDrivingNowPlease(); 

     if(didWeGetThere) 
     { 
       doOurFriendsLikeUs = thingToDoWhenWeGetThere(11); 
     } 
     return doOurFriendsLikeUs; 
    } 
} 

Cette classe représente une voiture de fiction, et il a une méthode simple qui provoque la voiture pour se rendre à la maison de notre ami. Si la voiture arrive à la maison de nos amis, alors nous voudrions avertir nos amis que nous sommes arrivés ... mais la classe de voiture ne sait pas exactement comment avertir nos amis. Nous pourrions jouer la stéréo vraiment fort, nous pourrions souffler la corne, ou nous pourrions utiliser un mégaphone.

Étant donné que la méthode GoVisitMyFriends ne sait pas comment notifier à nos amis exactement, à la place, il faut que le code appelant transmette une référence à une méthode qui peut faire la partie de notification. GoVisitMyFriends ne se soucie pas de la méthode que vous lui donnez, tant que la méthode a la même forme que la définition de NotifyFriendsDelegate (elle doit renvoyer boolean et accepter un paramètre de type int).

permet maintenant de créer une classe simple qui utilise notre voiture fictive:

public class MyFunClass() 
{ 
    public bool NotifyFriendsByRammingTheirHouse(int howHard) 
    { 
     var rammingModule = new RammingModule(); 
     return rammingModule.RamFriendsHouse(howHard); 
    } 

    public bool DoSomethingFun() 
    { 
     var car = new MyCar(); 
     var areWeCool = car.GoVisitMyFriends(NotifyFriendsByRammingTheirHouse); 
     return areWeCool; 
    } 
} 

Cette classe contient une méthode qui est conforme à la signature du NotifyFriendsDelegate. Il contient une méthode appelée DoSomethingFun, qui crée une instance de MyCar puis invoque la méthode GoVisitMyFriends. Et cela passe dans la méthode NotifyFriendsByRammingTheirHouse pour que la classe MyCar sache comment nous voulons montrer notre amour pour nos amis quand nous y arrivons.

Et c'est la forme la plus simple d'utilisation de délégué que je peux penser. BTW: J'ai toujours trouvé utile de considérer les événements comme des variables spéciales qui contiennent une collection de méthodes déléguées. L'événement peut être assigné n'importe quel nombre (zéro à l'infini) des délégués, TOUT ce qui sera appelé quand l'événement est invoqué. Les événements sont juste des groupes de délégués qui peuvent être traités comme "une chose".