{"id":55000417,"date":"2024-02-01T00:00:00","date_gmt":"2024-02-24T18:01:14","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=417"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Outlook_Ereignisse_fuer_Termine_implementieren","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Outlook_Ereignisse_fuer_Termine_implementieren\/","title":{"rendered":"Outlook: Ereignisse für Termine implementieren"},"content":{"rendered":"

\"\"<\/p>\n

Wenn wir Aufgaben erledigen wollen, die in Zusammenhang mit dem Anlegen, Bearbeiten oder Löschen von Terminen zu tun haben, kommen wir nicht um die Programmierung der Ereignisse von Terminen herum. Die Ereignisse eines Termins selbst zu implementieren ist halbwegs intuitiv, aber wo finden wir zum Beispiel die Ereignisprozedur, die ausgelöst, wenn wir einen neuen Termin anlegen? Der Termin selbst kann dieses Ereignis noch nicht enthalten, denn es gibt ihn ja zu diesem Zeitpunkt noch nicht. Tatsächlich wollen wir auch erst auf das Speichern des neuen Termins reagieren. Dazu müssen wir diesen aber dennoch erst einmal mit einer geeigneten Objektvariablen referenzieren. Wie das gelingt und wie wir alle notwendigen Ereignisse bei der Nutzung eines Termins implementieren können, zeigen wir in diesem Artikel.<\/b><\/p>\n

Outlook bietet die Möglichkeit, auf verschiedene Ereignisse zu reagieren, die mit dem Erstellen, Verschieben, Löschen oder Ändern von Terminen zu tun haben. Das ist immer dann interessant, wenn wir auf irgendeine Weise auf eines dieser Ereignisse reagieren müssen – beispielsweise, wenn wir die Termine mit einem Google Calender oder einem anderen Kalender synchronisieren wollen, wie wir es in Termine von Outlook zum Google Calendar exportieren <\/b>(www.vbentwickler.de\/418<\/b>) beschreiben.<\/p>\n

Um diese Funktionen optimal zu nutzen, müssen wir jede Änderung an einem Termin von Outlook nach Google übertragen – und dabei handelt es sich um das Anlegen, Ändern und Löschen eines Termins.<\/p>\n

Die erste Aufgabe hierbei ist, überhaupt herauszufinden, welche Ereignisse wir dazu nutzen können.<\/p>\n

Die erste Anlaufstelle für solche Informationen ist immer der Objektkatalog des VBA-Editors (zu öffnen mit F2<\/b>).<\/p>\n

Hier suchen wir nach dem AppointmentItem<\/b>-Element und erhalten direkt einige Ereignisse – das sind die mit dem Blitz-Symbol versehenen Einträge in Bild 1.<\/p>\n

\"Ereignisse<\/p>\n

Bild 1: Ereignisse des Termins im Objektkatalog<\/span><\/b><\/p>\n

Ereignisse ausprobieren<\/h2>\n

Zum Annähern an brauchbare Ereignisse bietet es sich an, diese einmal zu implementieren und sie mit Haltepunkten oder der Stop<\/b>-Anweisung zu versehen. Dann sehen wir beim Arbeiten mit einem AppointmentItem<\/b>-Element direkt, wann welche Ereignisse ausgelöst werden.<\/p>\n

Um die Ereignisse zu implementieren, benötigen wir allerdings erst einmal eine Objektvariable, die wir mit einem Verweis auf das AppointmentItem<\/b>-Element füllen und für die wir die Ereignisse implementieren können. Diese deklarieren wir im Modul ThisOutlookSession <\/b>wie folgt:<\/p>\n

Public <\/span>WithEvents objAppointmentItem _\r\n     As <\/span>Outlook.AppointmentItem<\/pre>\n
Außerdem verwenden wir die im Artikel Outlook: Kalender und Termine programmieren <\/b>(www.vbentwickler.de\/415<\/b>) vorgestellte Funktion GetSelectedAppointmentItem<\/b>, mit der wir den aktuellen Termin referenzieren.<\/p>\n
Die folgende Funktion weist der Variablen objAppointmentItem <\/b>den aktuell markierten Termin zu:<\/p>\n
Public Sub <\/span>ReferenceSelectedAppointmentItem()\r\n     Set<\/span> objAppointmentItem = GetSelectedAppointmentItem\r\nEnd Sub<\/span><\/pre>\n
Danach können wir im VBA-Editor im linken Kombinationsfeld die Variable objAppointmentItem <\/b>auswählen und erhalten im rechten Kombinationsfeld alle verfügbaren Ereignisse (siehe Bild 2). Klicken wir eines davon an, wird die entsprechende Ereignisprozedur zum Modul hinzugefügt.<\/p>\n
\"Implementieren<\/p>\n
Bild 2: Implementieren einer Ereignisprozedur<\/span><\/b><\/p>\n
Wir haben zunächst einfach jeder dieser Ereignisprozeduren die Stop<\/b>-Anweisung hinzugefügt (siehe Bild 3). Beim Öffnen und beim Schließen werden diese beiden Ereignisprozeduren ausgelöst:<\/p>\n
\"Implementierte<\/p>\n
Bild 3: Implementierte Ereignisprozeduren eines AppointmentItem-Elements<\/span><\/b><\/p>\n
    \n
  • objAppointmentItem_Open<\/b><\/li>\n
  • objAppointmentItem_Close<\/b><\/li>\n<\/ul>\n
    Bei anderen Aktionen traten jedoch gleich mehrere Ereignisse auf, daher sind wir von der Stop<\/b>-Anweisung abgegangen und haben Debug.Print<\/b>-Anweisungen hinzufügt, mit denen wir teilweise noch die Parameter ausgeben – zum Beispiel so:<\/p>\n
    Private Sub <\/span>objAppointmentItem_PropertyChange(ByVal _\r\n         Name As String<\/span>)\r\n     Debug.Print<\/span> \"objAppointmentItem_PropertyChange\", Name\r\nEnd Sub<\/span><\/pre>\n
    Damit erhalten wir allein beim Ändern der Startzeit eines geöffneten Termins von 9:00 Uhr auf 9:30 Uhr wie in Bild 4 gleich sechs Ereignisse. Diese interessieren uns allerdings nicht, wenn wir beispielsweise die Änderungen an einen Google Calendar übertragen wollen. Dann benötigen wir nur zu einem bestimmten Zeitpunkt, beispielsweise beim Schließen, die Information, ob der Termin geändert wurde.<\/p>\n
    \"Ausgabe<\/p>\n
    Bild 4: Ausgabe der Ereignisse beim Ändern einer Eigenschaft<\/span><\/b><\/p>\n
    Und das ist allein mit dem AppointmentItem-Element nur schwer zu realisieren – wir müssten beim Öffnen alle Eigenschaften ermitteln und zwischenspeichern und beim Schließen des Termins prüfen, ob sich seit dem Öffnen die Werte mindestens einer Eigenschaft geändert haben. Zum Glück gibt es noch andere Möglichkeiten, die noch einen weiteren Vorteil bieten: Wir haben oben nun einen Termin referenziert und seine Ereignisse implementiert. Wenn wir das Erfassen von Änderungen auf diese Weise umsetzen wollten, müssten wir zunächst jeden Termin, den der Benutzer öffnet, referenzieren – oder gleich alle Elemente des Kalenders erfassen. Und über diesen Schritt kommen wir zu einer eleganteren Lösung.<\/p>\n
    Auflistung der AppointmentItems referenzieren<\/h2>\n
    Dabei wollen wir nicht nur einen Termin, sondern gleich die komplette Liste der Termine im Kalender referenzieren. Dazu benötigen wir zunächst einen Verweis auf den Kalender-Ordner.<\/p>\n
    Diesen holen wir wieder mit einer Funktion, die wir bereits im Artikel Outlook: Kalender und Termine programmieren <\/b>(www.vbentwickler.de\/415<\/b>) vorgestellt haben. Die Funktion heißt GetDefaultCalendar <\/b>und holt den Standardkalender des aktuellen Benutzers von Outlook.<\/p>\n
    Außerdem benötigen wir eine Variable des Typs Outlook.Items<\/b>. Diese deklarieren wir im Modul ThisOutlookSession <\/b>wieder mit dem Schlüsselwort WithEvents<\/b>:<\/p>\n
    Public <\/span>WithEvents objAppointmentItem _\r\n     As <\/span>Outlook.AppointmentItem<\/pre>\n
    Das Referenzieren erledigen wir mit der folgenden Prozedur:<\/p>\n
    Public Sub <\/span>ReferenceAppointmentItems()\r\n     Dim <\/span>objCalendar As <\/span>Outlook.Folder\r\n     Set<\/span> objCalendar = GetDefaultCalendar\r\n     Set<\/span> objAppointmentItems = objCalendar.Items\r\nEnd Sub<\/span><\/pre>\n
    Damit haben wir eine Auflistung referenziert, die alle AppointmentItem<\/b>-Elemente enthält. Und wenn wir das Element objAppointmentItems <\/b>im linken Kombinationsfeld des Codefensters auswählen, finden wir im rechten die folgenden drei Ereignisse vor (siehe Bild 5):<\/p>\n
    \"Die<\/p>\n
    Bild 5: Die Items-Auflistung liefert alle notwendigen Ereignisse.<\/span><\/b><\/p>\n