HINWEIS: Wenn Sie Zugriff auf C # 5.0 Unleashed haben , lesen Sie die "Einschränkungen für die einfache Verwendung von Delegaten" in Kapitel 18 mit dem Titel "Ereignisse", um die Unterschiede zwischen den beiden besser zu verstehen.
Es hilft mir immer, ein einfaches, konkretes Beispiel zu haben. Also hier ist eine für die Community. Zuerst zeige ich, wie Sie Delegierte alleine verwenden können, um das zu tun, was Events für uns tun. Dann zeige ich, wie dieselbe Lösung mit einer Instanz von funktionieren würde EventHandler. Und dann erkläre ich, warum wir NICHT das tun wollen, was ich im ersten Beispiel erkläre. Dieser Beitrag wurde von einem Artikel von John Skeet inspiriert .
Beispiel 1: Verwenden eines öffentlichen Delegaten
Angenommen, ich habe eine WinForms-App mit einer einzelnen Dropdown-Box. Das Dropdown ist an ein gebunden List<Person>. Wobei Person Eigenschaften von ID, Name, Spitzname, Haarfarbe hat. Auf dem Hauptformular befindet sich ein benutzerdefiniertes Benutzersteuerelement, das die Eigenschaften dieser Person anzeigt. Wenn jemand eine Person in der Dropdown-Liste auswählt, werden die Beschriftungen im Benutzersteuerelement aktualisiert, um die Eigenschaften der ausgewählten Person anzuzeigen.
So funktioniert das Wir haben drei Dateien, die uns dabei helfen, dies zusammenzustellen:
- Mediator.cs - statische Klasse enthält die Delegaten
- Form1.cs - Hauptformular
- DetailView.cs - Benutzersteuerung zeigt alle Details
Hier ist der relevante Code für jede der Klassen:
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);
}
}
}
Hier ist unsere Benutzersteuerung:
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;
}
}
Schließlich haben wir den folgenden Code in unserer Form1.cs. Hier rufen wir OnPersonChanged auf, das jeden Code aufruft, der den Delegaten abonniert hat.
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`.
}
OK. So würden Sie dies zum Laufen bringen, ohne Ereignisse und nur Delegierte zu verwenden . Wir haben nur einen öffentlichen Delegierten in eine Klasse eingefügt - Sie können ihn statisch oder als Singleton oder was auch immer erstellen. Großartig.
ABER, ABER, ABER wir wollen nicht das tun, was ich gerade oben beschrieben habe. Weil öffentliche Felder aus vielen, vielen Gründen schlecht sind . Welche Möglichkeiten haben wir? Wie John Skeet beschreibt, sind hier unsere Optionen:
- Eine öffentliche Delegatenvariable (das haben wir gerade oben gemacht. Tu das nicht. Ich habe dir oben nur gesagt, warum es schlecht ist.)
- Fügen Sie den Delegaten in eine Eigenschaft mit einem get / set ein (Problem hierbei ist, dass Abonnenten sich gegenseitig überschreiben können - wir könnten also eine Reihe von Methoden für den Delegaten abonnieren und dann versehentlich sagen
PersonChangedDel = null, dass alle anderen Abonnements gelöscht werden Ein weiteres Problem besteht darin, dass die Benutzer, da sie Zugriff auf den Delegaten haben, die Ziele in der Aufrufliste aufrufen können. Wir möchten nicht, dass externe Benutzer Zugriff darauf haben, wann unsere Ereignisse ausgelöst werden.
- Eine Delegatvariable mit den Methoden AddXXXHandler und RemoveXXXHandler
Diese dritte Option ist im Wesentlichen das, was uns ein Ereignis bietet. Wenn wir einen EventHandler deklarieren, erhalten wir Zugriff auf einen Delegaten - nicht öffentlich, nicht als Eigenschaft, sondern als Ereignis, das nur Accessors hinzufügt / entfernt.
Mal sehen, wie das gleiche Programm aussieht, aber jetzt ein Ereignis anstelle des öffentlichen Delegaten verwendet (ich habe auch unseren Mediator in einen Singleton geändert):
Beispiel 2: Mit EventHandler anstelle eines öffentlichen Delegaten
Vermittler:
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 });
}
}
}
Beachten Sie, dass wenn Sie F12 im EventHandler verwenden, angezeigt wird, dass es sich bei der Definition nur um einen generischen Delegierten mit dem zusätzlichen Objekt "Absender" handelt:
public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);
Die Benutzersteuerung:
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;
}
}
Zum Schluss noch der Form1.cs-Code:
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
Mediator.GetInstance().OnPersonChanged(this, (Person)comboBox1.SelectedItem);
}
Da der EventHandler und EventArgs als Parameter benötigt, habe ich diese Klasse mit nur einer einzigen Eigenschaft erstellt:
class PersonChangedEventArgs
{
public Person Person { get; set; }
}
Hoffentlich zeigt Ihnen das ein wenig, warum wir Ereignisse haben und wie sie sich von den Delegierten unterscheiden - aber funktional gleich sind.