{"id":55000020,"date":"2016-02-01T00:00:00","date_gmt":"2020-03-27T19:17:02","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=20"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Von_VBA_zu_C_ObjektEreignisse","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Von_VBA_zu_C_ObjektEreignisse\/","title":{"rendered":"Von VBA zu C#: Objekt-Ereignisse"},"content":{"rendered":"

Nicht nur Fenster und Steuerelemente, sondern auch Objekte, die nicht Bestandteil der Benutzeroberfläche sind, können Ereignisse auslösen. Schließlich können Sie auch selbst Klassen programmieren und diese mit Ereignishandlern versehen. Wie Sie unter C# mit diesen Möglichkeiten umgehen, zeigt dieser Artikel. Dabei schauen wir uns zunächst an, wie Sie Ereignisse für Objekte auf Basis etwa der OpenFileDialog-Klasse implementieren und erstellen dann eine benutzerdefinierte Klasse mit einem Ereignishandler.<\/b><\/p>\n

Ereignisse von Klassen implementieren<\/h2>\n

Neben Formularen und Steuerelementen bieten unter Access auch verschiedene Klassen beziehungsweise Objekte Ereignisse an, die Sie selbst implementieren können. Als Beispiel sei etwa die Klasse Application <\/b>anderer Office-Anwendungen wie Outlook,Word oder Excel genannt. Sie deklarieren dabei eine entsprechende Objektvariable wie etwa objWord <\/b>mit dem Typ Word.Application <\/b>und instanzieren Word dann mit der New<\/b>-Methode. Wenn Sie die Deklaration mit dem Schlüsselwort WithEvents <\/b>durchführen, können Sie anschließend nicht nur Methoden oder Eigenschaften von Word aufrufen, sondern auch noch die Ereignisse von Word durch entsprechende Ereignisprozeduren implementieren – beispielsweise, wenn ein Dokument geöffnet oder geschlossen wird:<\/p>\n

Dim <\/span>WithEvents objWord As <\/span>Word.Application\r\nSet<\/span> objWord = New<\/span> Word.Application<\/pre>\n
Dazu wählen Sie dann im linken Kombinationsfeld des VBA-Fensters, in der die Variable objWord <\/b>definiert ist, den Eintrag objWord <\/b>aus und können dann mit dem rechten Kombinationsfeld die zur Verfügung stehenden Ereignisse selektieren – beispielsweise das Quit<\/b>-Ereignis. Im Beispiel aus Bild 1 haben wir etwa eine Word-Instanz erstellt und unter objWord <\/b>gespeichert. Die für das Quit<\/b>-Ereignis erstellte Ereignisprozedur haben wir mit einer Anweisung gefüllt, die ein Meldungsfenster liefert, wenn die Word-Instanz wieder geschlossen wird.<\/p>\n
\"Implementieren<\/p>\n
Bild 1: Implementieren eines Ereignisses eines Objekts<\/span><\/b><\/p>\n
Ereignis unter C# implementieren<\/h2>\n
Unter C# läuft dies etwas anders, aber nicht viel. Im folgenden Beispiel wollen wir die Timer<\/b>-Klasse verwenden (der Zugriff auf Word ist von C#-Projekten aus etwas aufwändiger – dies schauen wir uns in einem späteren Beitrag an …). Die Timer<\/b>-Klasse erlaubt es, ein Zeitgeber-Intervall festzulegen, nach dem das Ereignis Elapsed <\/b>ausgelöst wird.<\/p>\n
Die Objektvariable für das Objekt, das ein Ereignis auslösen soll, deklarieren wir unter C# nicht mit einem speziellen Schlüsselwort wie WithEvents <\/b>unter VBA, sondern einfach als private, statische Variable:<\/p>\n
private static Timer timer;<\/pre>\n
In der gleichen Klasse legen wir unsere Methode an, welche das Objekt auf Basis der Klasse Timer <\/b>instanziert, stellen das Zeitgeber-Intervall ein und starten den Zeitgeber. Außerdem, und das ist der wichtigste Punkt, legen wir fest, dass beim Eintreten des Ereignisses Elapsed <\/b>der Timer<\/b>-Klasse die Methode Timer_Elapsed <\/b>ausgeführt werden soll. Dies erreichen wir durch die folgende Zeile:<\/p>\n
timer.Elapsed += Timer_Elapsed;<\/pre>\n
Die komplette Prozedur zum Erstellen des Timer<\/b>-Objekts und zum Starten des Zeitgebers sieht nun wie folgt aus:<\/p>\n
public static void TimerEreignis() {\r\n     Console.WriteLine(\"Start Timer. Intervall: eine Sekunde.\");\r\n     timer = new Timer();\r\n     timer.Elapsed += Timer_Elapsed;\r\n     timer.Interval = 1000;\r\n     timer.Start();\r\n}<\/pre>\n
Nun benötigen wir noch die Methode, die beim Eintreten des Elapsed<\/b>-Ereignisses ausgelöst wird – unter VBA haben wir diese Ereignisprozedur genannt. Diese erhält die ähnliche Signatur wie auch die Ereignisprozeduren etwa von Steuerelementen, also mit zwei Parametern namens sender <\/b>und e<\/b>:<\/p>\n
private static void Timer_Elapsed(object sender, \r\n         ElapsedEventArgs e) {\r\n     timer.Stop();\r\n     Console.WriteLine(\"Zeit abgelaufen.\");\r\n     Console.ReadLine();\r\n}<\/pre>\n
e<\/b> hat hier allerdings den Typ ElapsedEventArgs<\/b>. Dieses Objekt liefert neben den Standardelementen mit der Eigenschaft SignalTime <\/b>die Zeit, zu der das Ereignis ausgelöst wurde. Dieses nehmen wir noch zur Ausgabe hinzu:<\/p>\n
Console.WriteLine(\"Zeit abgelaufen. {0}\", e.SignalTime);<\/pre>\n
Eigene Ereignisse programmieren<\/h2>\n
Nun wollen wir eine Klasse mit einem eigenen Ereignis programmieren. Ausgangspunkt ist die folgende einfache Klasse namens Person <\/b>mit einer einzigen Eigenschaft namens Vorname<\/b> sowie den entsprechenden get<\/b>– und set<\/b>-Methoden:<\/p>\n
public class Person {\r\n     private string vorname;\r\n     public string Vorname {\r\n         get {\r\n             return this.vorname;\r\n         }\r\n         set {\r\n             this.vorname = value;\r\n         }\r\n     }\r\n}<\/pre>\n
Die folgende Methode erstellt ein neues Objekt auf Basis dieser Klasse und füllt die Eigenschaft Vorname <\/b>mit dem Wert André<\/b>:<\/p>\n
public static void KundeErstellen() {\r\n     Person person = new Person();\r\n     person.Vorname = \"André\";\r\n     Console.WriteLine(\"Vorname: {0}\", person.Vorname);\r\n     Console.ReadLine();\r\n}<\/pre>\n
Diese Klasse soll nun beim Ändern des Wertes der Eigenschaft Vorname ein Ereignis auslösen, das wir wiederum in der Klasse mit der Methode implementieren wollen. Dazu sind auf Seite der Klasse Person<\/b> die folgenden Schritte nötig:<\/p>\n