REMARQUE: si vous avez accès à C # 5.0 Unleashed , lisez les "Limitations sur l'utilisation simple des délégués" dans le chapitre 18 intitulé "Événements" pour mieux comprendre les différences entre les deux.
Cela m'aide toujours à avoir un exemple simple et concret. Voici donc un pour la communauté. Je montre d'abord comment vous pouvez utiliser les délégués seuls pour faire ce que les événements font pour nous. Ensuite, je montre comment la même solution fonctionnerait avec une instance de EventHandler. Et puis j'explique pourquoi nous NE voulons PAS faire ce que j'explique dans le premier exemple. Ce billet est inspiré d' un article de John Skeet.
Exemple 1: utilisation d'un délégué public
Supposons que j'ai une application WinForms avec une seule liste déroulante. La liste déroulante est liée à un List<Person>. Où Personne a les propriétés Id, Name, NickName, HairColor. Sur le formulaire principal se trouve un contrôle utilisateur personnalisé qui affiche les propriétés de cette personne. Lorsque quelqu'un sélectionne une personne dans la liste déroulante, les étiquettes de la mise à jour du contrôle utilisateur affichent les propriétés de la personne sélectionnée.
Voici comment cela fonctionne. Nous avons trois fichiers qui nous aident à mettre cela ensemble:
- Mediator.cs - la classe statique détient les délégués
- Form1.cs - formulaire principal
- DetailView.cs - le contrôle utilisateur affiche tous les détails
Voici le code pertinent pour chacune des classes:
class Mediator
{
public delegate void PersonChangedDelegate(Person p); //delegate type definition
public static PersonChangedDelegate PersonChangedDel; //delegate instance. Detail view will "subscribe" to this.
public static void OnPersonChanged(Person p) //Form1 will call this when the drop-down changes.
{
if (PersonChangedDel != null)
{
PersonChangedDel(p);
}
}
}
Voici notre contrôle utilisateur:
public partial class DetailView : UserControl
{
public DetailView()
{
InitializeComponent();
Mediator.PersonChangedDel += DetailView_PersonChanged;
}
void DetailView_PersonChanged(Person p)
{
BindData(p);
}
public void BindData(Person p)
{
lblPersonHairColor.Text = p.HairColor;
lblPersonId.Text = p.IdPerson.ToString();
lblPersonName.Text = p.Name;
lblPersonNickName.Text = p.NickName;
}
}
Enfin, nous avons le code suivant dans notre Form1.cs. Ici, nous appelons OnPersonChanged, qui appelle tout code souscrit au délégué.
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
Mediator.OnPersonChanged((Person)comboBox1.SelectedItem); //Call the mediator's OnPersonChanged method. This will in turn call all the methods assigned (i.e. subscribed to) to the delegate -- in this case `DetailView_PersonChanged`.
}
D'accord. Voilà donc comment vous pourriez faire fonctionner cela sans utiliser d'événements et simplement utiliser des délégués . Nous venons de mettre un délégué public dans une classe - vous pouvez le rendre statique ou un singleton, ou autre chose. Génial.
MAIS, MAIS, MAIS, nous ne voulons pas faire ce que je viens de décrire ci-dessus. Parce que les champs publics sont mauvais pour de nombreuses raisons. Quelles sont nos options? Comme John Skeet le décrit, voici nos options:
- Une variable de délégué public (c'est ce que nous venons de faire ci-dessus. Ne faites pas cela. Je viens de vous dire ci-dessus pourquoi c'est mauvais)
- Mettez le délégué dans une propriété avec un get / set (le problème ici est que les abonnés pourraient se remplacer les uns les autres - nous pourrions donc souscrire un tas de méthodes au délégué et nous pourrions alors accidentellement dire
PersonChangedDel = null, effacer tous les autres abonnements. un autre problème qui reste ici est que puisque les utilisateurs ont accès au délégué, ils peuvent invoquer les cibles dans la liste d'invocation - nous ne voulons pas que les utilisateurs externes aient accès au moment de déclencher nos événements.
- Une variable déléguée avec les méthodes AddXXXHandler et RemoveXXXHandler
Cette troisième option est essentiellement ce que nous offre un événement. Lorsque nous déclarons un EventHandler, cela nous donne accès à un délégué - pas publiquement, pas en tant que propriété, mais comme cette chose, nous appelons un événement qui vient d'ajouter / supprimer des accesseurs.
Voyons à quoi ressemble le même programme, mais en utilisant maintenant un événement au lieu du délégué public (j'ai également changé notre médiateur en singleton):
Exemple 2: avec EventHandler au lieu d'un délégué public
Médiateur:
class Mediator
{
private static readonly Mediator _Instance = new Mediator();
private Mediator() { }
public static Mediator GetInstance()
{
return _Instance;
}
public event EventHandler<PersonChangedEventArgs> PersonChanged; //this is just a property we expose to add items to the delegate.
public void OnPersonChanged(object sender, Person p)
{
var personChangedDelegate = PersonChanged as EventHandler<PersonChangedEventArgs>;
if (personChangedDelegate != null)
{
personChangedDelegate(sender, new PersonChangedEventArgs() { Person = p });
}
}
}
Notez que si vous F12 sur le EventHandler, il vous montrera que la définition est juste un délégué générique-ified avec l'objet supplémentaire "expéditeur":
public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);
Le contrôle utilisateur:
public partial class DetailView : UserControl
{
public DetailView()
{
InitializeComponent();
Mediator.GetInstance().PersonChanged += DetailView_PersonChanged;
}
void DetailView_PersonChanged(object sender, PersonChangedEventArgs e)
{
BindData(e.Person);
}
public void BindData(Person p)
{
lblPersonHairColor.Text = p.HairColor;
lblPersonId.Text = p.IdPerson.ToString();
lblPersonName.Text = p.Name;
lblPersonNickName.Text = p.NickName;
}
}
Enfin, voici le code Form1.cs:
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
Mediator.GetInstance().OnPersonChanged(this, (Person)comboBox1.SelectedItem);
}
Parce que EventHandler veut et EventArgs comme paramètre, j'ai créé cette classe avec juste une seule propriété:
class PersonChangedEventArgs
{
public Person Person { get; set; }
}
J'espère que cela vous montre un peu pourquoi nous avons des événements et comment ils sont différents - mais fonctionnellement les mêmes - que les délégués.