{"id":55000065,"date":"2016-12-01T00:00:00","date_gmt":"2020-03-27T19:23:39","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=65"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Events_in_der_Praxis","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Events_in_der_Praxis\/","title":{"rendered":"Events in der Praxis"},"content":{"rendered":"

Im Artikel “Von VBA zu C#: Objekt-Ereignisse” haben wir bereits die Grundlagen zur Programmierung und Implementierung benutzerdefinierter Ereignisse gelegt. Dies wollen wir nun ausbauen, indem wir uns zwei praktische Beispiele ansehen. Dabei wollen wir von einem Hauptfenster aus verschiedene Ansichten in einem Frame anzeigen, da-runter eine Kundenübersicht und eine Kundendetailansicht. Beim Anzeigen sollen verschiedene Dinge geschehen, die wir über die Implementierung von Ereignissen lösen wollen – und zwar über eingebaute sowie über benutzerdefinierte Ereignisse.<\/b><\/p>\n

Beispielprojekt<\/h2>\n

Im Beispiel geht es um ein Hauptfenster, das über zwei Ribbon-Buttons verschiedene Page<\/b>-Elemente in einem Frame anzeigen soll. Die Schaltfläche Kundenübersicht <\/b>zeigt das Page<\/b>-Objekt Kundenuebersicht <\/b>an, die Schaltlfäche Neuer Kunde <\/b>das Page<\/b>-Objekt Kundendetails<\/b>. Diese Seite wird ebenfalls aufgerufen, wenn der Benutzer doppelt auf einen der Einträge der Kundenübersicht klickt (siehe Bild 1).<\/p>\n

\"Interaktion<\/p>\n

Bild 1: Interaktion zwischen den einzelnen Seiten<\/span><\/b><\/p>\n

Im ersten Beispiel wollen wir dafür sorgen, dass eine dritte Ribbon-Schaltfläche zum Löschen von Elementen der Kundenübersicht nur aktiviert wird, wenn die Kundenübersicht angezeigt wird. Das heißt, dass diese Schaltfläche deaktiviert werden soll, wenn eine andere Ansicht als die Kundenübersicht erscheint. Dazu wollen wir ein Ereignis implementieren, das beim Seitenwechseln im Frame-Element ausgelöst wird.<\/p>\n

Im zweiten Beispiel wollen wir zwei eigene Events programmieren und implementieren. Die Kundenübersicht soll nicht jedes Mal, wenn der Benutzer von einer anderen Seite zurück auf diese Seite wechselt, neu erstellt werden beziehungsweise ihre Daten neu aus der Datenbank einlesen. Dies soll nur geschehen, wenn entweder einer der angezeigten Einträge auf der Seite Kundendetails <\/b>geändert oder ein neuer Eintrag hinzugefügt wurde. Dazu wollen wir ein Ereignis in der Code behind-Klasse der Seite Kundendetails<\/b> programmieren, die wir dann in der Code behind-Klasse des MainWindow<\/b>-Objekts implementieren.<\/p>\n

So können wir dann direkt im MainWindow<\/b> den relevanten Code ausführen und müssen nicht von der untergeordneten Seite mit den Kundendetails auf das übergeordnete Fenster zugreifen – den Hintergrund erläutern wir weiter unten.<\/p>\n

Eingebaute Events nutzen<\/h2>\n

Im ersten Beispiel wollen wir also ein Ribbon<\/b>-Steuerelement im MainWindow <\/b>aktivieren oder deaktivieren, je nachdem welches Page<\/b>-Element das Frame<\/b>-Element anzeigt. Wenn es die Seite Kundenuebersicht<\/b> anzeigt, soll die Schaltfläche btnKundeLoeschen <\/b>aktiviert werden, wenn es eine andere Seite anzeigt, soll der Benutzer diese Schaltfläche nicht anklicken können.<\/p>\n

Dazu legen wir für das Frame-Element im XAML-Code, also in der Klasse MainWindow.xaml<\/b>, das Attribut Navigated <\/b>an und füllen es mit dem Wert WorkZone_Navigated<\/b>:<\/p>\n

<Window x:Class=\"Bestellverwaltung.MainWindow\" ...\r\n         Title=\"MainWindow\" Height=\"450\" Width=\"525\">\r\n     <Grid>\r\n         ...\r\n         <Frame x:Name=\"WorkZone\" Grid.Row=\"1\" \r\n             Navigated=\"WorkZone_Navigated\"><\/Frame>\r\n     <\/Grid>\r\n<\/Window><\/pre>\n
Für dieses Ereignis hinterlegen wir die folgende Methode in der Code behind-Datei von MainWindow<\/b>:<\/p>\n
private void WorkZone_Navigated(object sender, \r\n         System.Windows.Navigation.NavigationEventArgs e) {\r\n     switch (WorkZone.Content.ToString()) {\r\n         case \"Bestellverwaltung.Kundenuebersicht\":\r\n             btnKundeLoeschen.IsEnabled = true;\r\n             break;\r\n         default:\r\n             btnKundeLoeschen.IsEnabled = false;\r\n             break;\r\n     }\r\n}<\/pre>\n
Diese Methode wird nun beim Wechseln des im Frame-Objekts angezeigten Objekts ausgelöst. Mit einer switch<\/b>-Bedingung prüfen wir den Namen des angezeigten Elements, hier mit der Eigenschaft Content <\/b>ermittelt. Hat diese den Wert Bestellverwaltung.Kundenuebersicht<\/b>, stellt die Methode den Wert der Eigenschaft IsEnabled <\/b>des Elements btnKundeLoeschen <\/b>auf true <\/b>ein. Für jeden anderen Inhalt erhält IsEnabled <\/b>den Wert false<\/b>.<\/p>\n
Was ist nun der Unterschied zu den Ereignissen etwa einer Schaltfläche, die wir nun schon in vielen Beispielen implementiert haben In den bisherigen Beispielen haben wir meist selbst die Ereignisse ausgelöst, zum Beispiel durch einen Mausklick auf eine Schaltfläche. Diesmal wurde das Ereignis indirekt durch unsere Aktion ausgelöst, nämlich durch einen Klick auf eine Ribbon-Schaltfläche, die wiede-rum den Inhalt des Frame<\/b>-Objekts geändert hat. Und das hat dann unser hier implementiertes Ereignis hervorgerufen.<\/p>\n
Benutzerdefinierte Events<\/h2>\n
Wie oben gezeigt, gibt es eine große Anzahl eingebauter Ereignisse, die Sie für Ihre Zwecke nutzen können. Nicht immer jedoch werden Ereignisse zum gewünschten Zeitpunkt ausgelöst. Ein Beispiel ist das Speichern eines Kunden, der neu angelegt oder geändert wurde. Unter Access, wo alles auf die Anzeige und Bearbeitung von Daten ausgelegt ist, finden Sie entsprechende Ereignisse zuhauf – zum Beispiel das Ereignis Nach Aktualisierung<\/b>. Unter WPF\/C# sorgen wir selbst dafür, dass die Änderungen an den angezeigten Daten auch in die Datenbank geschrieben werden. Dementsprechend müssen wir auch selbst Ereignisse definieren, die zu einem solchen Zeitpunkt ausgelöst werden.<\/p>\n
In unserem Fall wollen wir ein solches Ereignis nutzen, um festzulegen, ob eine Änderung oder eine Neuanlage eines Kunden erfolgt ist. Abhängig davon soll die Kundenübersicht, wenn sie das nächste Mal eingeblendet wird, entweder neu erzeugt werden (falls Änderungen vorliegen) oder mit den alten Daten eingeblendet werden.<\/p>\n
Dazu soll das Hauptfenster eine Variable namens KundenChanged <\/b>vorhalten, die lesend und schreibend zugreibar ist und wie folgt in der Klasse MainWindow <\/b>deklariert wird:<\/p>\n
public bool KundeChanged { get; set; }<\/pre>\n
Die einfache Variante<\/h2>\n
Nun könnten wir im Page<\/b>-Objekt Kundendetails <\/b>die Schaltfläche Speichern <\/b>mit einer Anweisung ausstatten, welche die Eigenschaft KundeChanged<\/b> einfach auf den Wert true <\/b>einstellt, wenn der Benutzer die Schaltfläche betätigt hat (siehe Bild 2).<\/p>\n
\"Ein<\/p>\n
Bild 2: Ein Klick auf Speichern stellt die Eigenschaft KundeChanged im MainWindow auf true ein.<\/span><\/b><\/p>\n
In diesem einfachen Fall sieht die Methode, die beim Anklicken der Speichern<\/b>-Schaltfläche ausgelöst wird, wie in Listing 1 aus. Die erste Anweisung prüft, ob es sich um einen neuen Kunden handelt (in diesem Fall ist die ID <\/b>noch 0<\/b>, da noch nicht vom Datenbanksystem vergeben). Ist der Kunde neu, wird er im ersten Teil der If<\/b>-Bedingung hinzugefügt und in der Datenbank gespeichert. Außerdem referenzieren wir das MainWindow<\/b>-Objekt über Window.GetWindow(this) <\/b>und stellen anschließend seine Eigenschaft KundeChanged<\/b>, die wir weiter oben als öffentliche Variable des Fensters MainWindow <\/b>deklariert haben, auf den Wert True <\/b>ein. Handelt es sich um einen vorhandenen Kunden, der geändert wurde, speichern wir ebenfalls die Änderungen in der Datenbank und stellen dann wie oben den Wert der Eigenschaft KundeChanged <\/b>auf True <\/b>ein.<\/p>\n
private void btnSpeichern_Click(object sender, RoutedEventArgs e) {\r\n     bool kundeCreated = kundeTemp.ID == 0;\r\n     if (kundeCreated) {\r\n         dbContext.Kunden.Add(kundeTemp);\r\n         dbContext.SaveChanges();\r\n         MainWindow wnd = \r\n             (MainWindow)Window.GetWindow(this);\r\n         wnd.KundeChanged = true;\r\n     }\r\n     else {\r\n         dbContext.SaveChanges();\r\n         MainWindow wnd = \r\n             (MainWindow)Window.GetWindow(this);\r\n         wnd.KundeChanged = true;\r\n     }\r\n}<\/pre>\n
Listing 1: Beispiel für das Aktualisieren einer Variablen durch direkten Zugriff<\/span><\/b><\/p>\n
Neu erstellen oder nicht<\/h2>\n
Wenn der Benutzer nun im MainWindow <\/b>auf die Ribbon-Schaltfläche btnKunden-uebersicht<\/b> klickt, löst er die Ereignismethode btnKundenuebersicht_Click<\/b> aus Listing 2 aus. Diese prüft im ersten Teil der if<\/b>-Bedingung vor dem Oder-Zeichen (|<\/b>), ob kundenuebersicht <\/b>überhaupt schon existiert, also nicht den Wert null <\/b>enthält – in diesem Fall wird dieses Page<\/b>-Objekt auf jeden Fall neu erstellt. Der Teil hinter dem Oder-Zeichen prüft, ob die Boolean-Variable KundeChanged <\/b>den Wert true <\/b>enthält.<\/p>\n
private void btnKundenuebersicht_Click(object sender, RoutedEventArgs e) {\r\n     if (kundenuebersicht == null | KundeChanged == true) {\r\n         kundenuebersicht = new Kundenuebersicht();\r\n         KundeChanged = false;\r\n     }\r\n     WorkZone.Content = kundenuebersicht;\r\n}<\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t