<\/p>\n
Bereits einige Beiträge in Access im Unternehmen beschäftigt sich mit dem Im- und Export von Outlook-Objekten zwischen Access und Outlook. Dabei erfolgt das Synchronisieren immer zu einem vom Benutzer festgelegten Zeitpunkt. Was aber, wenn man in Access immer auf die aktuell in Outlook gespeicherten Daten zugreifen möchte, ohne die Daten manuell abzugleichen Ein Blick hinter die Kulissen des Outlook-Objektmodells bringt Lichts ins Dunkel.<\/b><\/p>\n<\/div>\n Kontakte, E-Mails, Termine und Aufgaben – den Abgleich all dieser Objekte zwischen Access und Outlook haben Sie als fleißiger Leser bereits kennen gelernt. Falls nicht, empfiehlt sich ein Blick auf die im Onlinearchiv gespeicherten Beiträge mit den Shortlinks 290 (E-Mails), 439 (Termine), 113 und 129 (Kontakte) sowie 498 (Aufgaben).<\/p>\n Diese Artikel beschreiben in der Regel, wie Sie die jeweiligen Objekte von Access nach Outlook und zurück bekommen – allerdings immer von Access aus gesteuert. Dementsprechend sollte es auch kein Problem sein, in Access eine Funktion zu implementieren, die neu angelegte oder geänderte Elemente direkt nach dem Anlegen oder ändern mit Outlook synchronisiert.<\/p>\n Dies funktioniert natürlich auch andersherum: Sie können ohne größeren Aufwand dafür sorgen, dass Outlook, wenn ein Benutzer ein neues Element wie etwa einen Kontakt anlegt, direkt den passenden in einer Datenbank gespeicherten Eintrag ändert.<\/p>\n Beispielhaft<\/p>\n Um die Beispiele nachvollziehen zu können, kopieren Sie einfach den Inhalt der Datei ThisOutlookSession.cls<\/b> in die gleichnamige Klasse im Outlook-VBA-Editor und passen die darin enthaltenen Pfadangaben an.<\/p>\n Outlook-Ereignisse<\/b><\/p>\n Zum Automatisieren von Outlook selbst bedarf es natürlich erstens eines kleinen Blickes in das Objektmodell und dort vor allem auf die Ereignisse, die beim Anlegen oder ändern von Outlook-Elementen ausgelöst werden – und es muss klar sein, dass Sie die notwendigen Prozeduren natürlich innerhalb von Outlook und nicht in einer Access-Anwendung anlegen. Der Ort für das Deklarieren ereignis-sensitiver Objekte in Outlook ist schnell gefunden: Es handelt sich dabei um ein standardmäßig vorhandenes Klassenmodul namens ThisOutlookSession<\/b>. Die Ereignisprozeduren des Application<\/b>-Objekts, also von Outlook selbst, werden hier, soweit vorhanden, automatisch ausgelöst. Das erkennen Sie ganz leicht, wenn Sie zum VBA-Editor wechseln (von Outlook aus am schnellsten per Strg + F11<\/b>), dort das Modul ThisOutlookSession <\/b>öffnen und im linken Kombinationsfeld des Codefensters Application <\/b>auswählen. Das rechte Kombinationsfeld liefert dann alle möglichen Ereignisse. Die leere Ereignisprozedur, die das öffnen einer Outlook-Instanz auslöst, sieht dann etwa so aus:<\/p>\n Ab jetzt kommt es darauf an, was Sie vorhaben: Soll eine Mail, ein Kontakt, ein Termin oder eine Aufgabe direkt nach dem Anlegen in einer Access-Tabelle gespeichert werden Oder muss dies auch bei änderungen geschehen<\/p>\n Aufgaben nach Access<\/b><\/p>\n Werfen Sie zunächst einen Blick auf das Anlegen einer neuen Aufgabe in Outlook. Diese soll direkt nach dem Erzeugen in eine Access-Tabelle wie die aus dem Beitrag Outlook-Aufgaben <\/b>(Shortlink 498) exportiert werden.<\/p>\n Was für ein Ereignis benötigen Sie hier Eines, das in Zusammenhang mit dem neuen Element (hier einer Aufgabe) selbst ausgelöst wird Nein! Das neue Element existiert ja zu dem Zeitpunkt, an dem Sie die Ereigniseigenschaft schreiben, die ein neues Aufgaben-Element nach Access schieben soll, noch gar nicht. Ein „New“- oder „Add“-Ereignis steht auch so gut wie nie für ein einzelnes Objekt zur Verfügung, sondern meist für die Auflistung, die das zu erzeugende Element einmal aufnehmen wird. Und das ist in diesem Falle die Items<\/b>-Auflistung des Aufgaben-Ordners.<\/p>\n Damit Sie die Ereignisse eines Elements durch entsprechende Ereignisprozeduren abfangen können, müssen Sie dieses – wenn es nicht wie das Application<\/b>-Element bereits vorhanden ist – zunächst deklarieren und instanzieren, wobei Sie beim Deklarieren das Schlüsselwort WithEvents <\/b>verwenden. Die folgende Anweisung deklariert zunächst einen handelsüblichen Outlook-Ordner:<\/p>\n Damit dieses Objekt explizit beim Anlegen eines bestimmten Outlook-Elements Ereignisse auslöst, instanzieren Sie es mit dem entsprechenden Typ, hier der Items<\/b>-Auflistung des Aufgaben-Ordners:<\/p>\n Im Gegensatz zum Verwenden einer Outlook-Instanz von Access aus benutzen Sie hier nicht die GetDefaultFolder<\/b>-Methode von Application.GetNamespace(„MAPI“)<\/b>, sondern von Application.Session<\/b>, was einen expliziten Zugriff auf die in der aktuellen Sitzung erzeugten und bearbeiteten Objekte zulässt.<\/p>\n Wenn Sie nun einen Blick auf die Ereignisse der oben deklarierten Auflistung objItems<\/b> werfen, finden Sie auch direkt etwas Passendes (siehe Bild 1).<\/p>\n Bild 1: Mit diesen Ereignissen lassen sich Outlook-Elemente nach dem Anlegen, ändern oder Entfernen mit einer passenden Access-Datenbank synchronisieren.<\/span><\/b><\/p>\n<\/p><\/div>\n Für einen Test verwenden Sie zunächst das ItemAdd<\/b>-Ereignis. Folgende Implementierung zeigt in einem Meldungsfenster den Betreff und den Inhalt einer frisch angelegten Aufgabe an, wobei der Parameter Item <\/b>einen Verweis auf das passende Element liefert:<\/p>\n <\/p>\n Um diese Routine zu testen, schließen Sie Outlook nach der Eingabe, bestätigen das Speichern des Moduls VbaProjekt.OTM <\/b>und öffnen Outlook erneut. Bereits beim öffnen instanziert Outlook die festgelegte Aufgaben-Auflistung und ist von nun an bereit, auf neu angelegte Elemente mit der oben beschriebenen Routine zu reagieren. Beachten Sie, dass Outlook die Ereignisse immer erst beim Speichern des neu angelegten oder geänderten Elements auslöst.<\/p>\n Die Methode ItemChange <\/b>können Sie genauso wie ItemAdd <\/b>verwenden, um geänderte Elemente mit der Datenbank zu synchronisieren.<\/p>\n Allein die ItemRemove<\/b>-Methode vermag ihre Aufgabe nicht recht zu lösen – das geht allein aus ihrer Deklaration hervor. Die Parameterliste ist nämlich leer, das heißt, dass die Routine keine Informationen über das gelöschte Element liefert, sondern allein über den Löschvorgang selbst informiert:<\/p>\n Löschsynchronisation<\/p>\n Um ein innerhalb von Outlook gelöschtes Element auch in der passenden Access-Tabelle zu löschen, müssen Sie zu anderen Mitteln greifen. Die richtige Methode namens Delete <\/b>liefert nämlich das TaskItem<\/b>-Objekt, für andere Elemente gibt es Objekte wie MailItem <\/b>(E-Mail), ContactItem <\/b>(Kontakt) oder AppointmentItem <\/b>(Termine).<\/p>\n Also deklarieren Sie zunächst im gleichen Modul eine Objektvariable mit Ereignisbehandlung zum Verweis auf das zu löschende Element:<\/p>\n Für andere Elemente deklarieren Sie dieses als eines der oben genannten Objekte. Nun müssen Sie allerdings noch einen Weg finden, einen Verweis auf das zu löschende Objekt zu erstellen. Was passiert den überhaupt im Verlauf eines Löschvorgangs Zunächst markiert man das zu löschende Objekt und initialisiert dann den Löschvorgang selbst, indem man beispielsweise auf die Entf<\/b>-Taste klickt oder den Löschen<\/b>-Eintrag aus dem Kontextmenü auswählt.<\/p>\n Interessant ist die Auswahl des zu löschenden Objekts: Forschen wir also nach einem Ereignis, das beim Auswählen eines Outlook-Elements ausgelöst wird, und fangen ganz oben an: bei den Ereignissen des Application<\/b>-Objekts. Mmmh … viel versprechend sieht das nicht aus; vielleicht hilft Application_ItemLoad <\/b>weiter.<\/p>\n Um dies zu testen, legen Sie einfach die passende Ereignisprozedur an und fügen eine simple Anweisung wie folgt hinzu:<\/p>\n Klicken Sie dann in eine der Listen (beispielsweise E-Mails, Kontakte etc.) und seien Sie erfreut: Die Auswahl eines der Einträge löst dieses Ereignis aus. Das ist perfekt, Sie müssen also nur noch prüfen, ob es sich beim ausgewählten Element um den richtigen Typ handelt (immerhin wollen wir hier erstmal nur Aufgaben behandeln) und diesen gegebenenfalls der Objektvariablen objTaskItem <\/b>zuweisen:<\/p>\n Zu beachten ist hier, dass das mit dem Parameter Item <\/b>referenzierte Objekt zu diesem Zeitpunkt nur zwei Eigenschaften liefert: Class <\/b>und MessageClass<\/b>, wobei in diesem Fall Class <\/b>die interessantere ist, weil sie Informationen über den Typ des Outlook-Elements liefert und wie in obiger Routine ausgewertet werden kann. Die möglichen Werte für die Class<\/b>-Eigenschaft finden Sie übrigens, indem Sie im Objektkatalog zunächst nach dem Begriff Class <\/b>suchen und, wenn möglich, die Zielbibliothek einschränken, womit in diesem Fall die Outlook-Bibliothek gemeint ist. Finden Sie dann das passende Objekt – hier das TaskItem<\/b>-Objekt – und klicken Sie in der Objektliste auf die Eigenschaft (Class<\/b>). Der Objektkatalog zeigt dann wie in Bild 2 den Datentyp dieser Eigenschaft an, in diesem Fall OlObjectClass<\/b>. Klicken Sie auf den grünen Link zu diesem Datentyp, zeigt der Objektkatalog eine Liste aller für diesen Datentyp verfügbaren Werte an (siehe Bild 3).<\/p>\n Bild 2: über die Eigenschaft …<\/span><\/b><\/p>\n<\/p><\/div>\n Bild 3: … finden sich meist auch ihre Konstanten.<\/span><\/b><\/p>\n<\/p><\/div>\n Wenn Sie nun wissen wollen, welcher dem TaskItem <\/b>entspricht, müssen Sie der LoadItem<\/b>-Ereignisprozedur nur eine Anweisung hinzufügen, die den Wert der Class<\/b>-Eigenschaft des aktuell geladenen Elements liefert:<\/p>\n Bei einer Aufgabe erscheint hier etwa der Wert 48<\/b>, bei einer E-Mail der Wert 43 <\/b>und so weiter. Beachtenswert ist, dass ItemLoad <\/b>in manchen Fällen nicht allein durch das Markieren ausgelöst wird, da Outlook nicht für all diese Aktionen Informationen über das jeweilige Element laden muss. Wenn Sie etwa auf einen Termin im Kalender klicken, wird dieser noch nicht geladen, wenn Sie ihn per Doppelklick öffnen oder auch nur das Kontextmenü anzeigen, dann schon.<\/p>\n Die zum Wert passende Konstante finden Sie nun im Objektkatalog, wenn Sie die vorhandenen Werte für die Class<\/b>-Eigenschaft durchlaufen.<\/p>\n Da Sie nun einen Verweis auf das zu löschende TaskItem<\/b>-Element besitzen, können Sie auch dessen Ereignisse nutzen: In diesem Fall hilft das BeforeDelete<\/b>-Ereignis weiter, das vor dem Löschen ausgelöst wird und diesen Vorgang noch abbrechen kann. Dazu müssen Sie innerhalb der Ereignisprozedur nur den Wert des Parameters Cancel <\/b>auf True <\/b>einstellen.<\/p>\n In diesem Fall wollen wir jedoch zunächst einen einfachen Hinweis auf das Löschen einer Outlook-Aufgabe erhalten, was sich mit folgender Routine bewerkstelligen lässt:<\/p>\n Synchronisieren geht über Studieren<\/p>\n Nachdem Sie alle Ereignisse beisammen haben, die beim Hinzufügen, Löschen und ändern von Outlook-Elementen ausgelöst werden, müssen Sie diese nur noch so mit Leben füllen, dass sie die vorgenommenen änderungen in die Access-Tabelle übertragen.<\/p>\n Das ist für einen Access-Entwickler nur noch Routinearbeit, wenn man einmal vom Instanzieren der Ziel-Datenbank absieht. Sie verwenden nämlich nicht einfach die folgenden Anweisungen:<\/p>\n Stattdessen kommt die OpenDatabase<\/b>-Methode zum Einsatz:<\/p>\n Natürlich müssen Sie dazu im Outlook-VBA-Projekt einen Verweis auf die DAO-Bibliothek oder, wenn Sie eine Datenbank im Format von Access 2007 (.accdb) verwenden, einen Verweis auf die Bibliothek Microsoft Office 12.0 Access Database Engine Object Library <\/b>hinzufügen.<\/p>\n Anschließend können Sie wie gewohnt auf die Tabellen der referenzierten Datenbank zugreifen. Aus Platzgründen soll dieser Artikel nicht alle Aktionen (anlegen, löschen, ändern) beschreiben, sondern beschränkt sich auf das Anlegen eines neuen TaskItem<\/b>-Elements in Outlook und dessen Pendant in der Access-Tabelle.<\/p>\n Wie dies funktioniert, zeigt Listing 1. Die Routine öffnet die Zieldatenbank, erzeugt ein Recordset auf Basis der Zieltabelle und schreibt die Eigenschaftswerte des neu erzeugten TaskItem<\/b>-Elements in diese Tabelle. Schließlich fragt sie noch den Primärschlüsselwert dieser Tabelle ab und schreibt ihn in die Eigenschaft BillingInformation<\/b> der neuen Aufgabe.<\/p>\n Listing 1: Diese Ereignisprozedur schreibt eine in Outlook frisch angelegte Aufgabe in die passende Access-Tabelle.<\/p>\n Dies dient dem späteren Synchronisieren von Aufgaben zwischen Outlook und Access; weitere Informationen dazu finden Sie im Beitrag Outlook-Aufgaben (Shortlink 498).<\/p>\n Die übrigen Ereignisprozeduren, die beim ändern und Löschen für eine Synchronisation mit der Access-Tabelle sorgen, finden Sie im Beispielmodul.<\/p>\n Zusammenfassung und Ausblick<\/p>\n Outlook-Objekte lassen sich auch von Outlook aus beim Anlegen direkt mit den Daten in entsprechenden Access-Tabellen synchronisieren.<\/p>\n Sie haben die dazu notwendigen Techniken kennen gelernt und einen kleinen Einblick in das Objektmodell von Outlook und seine Ereignisse erhalten.<\/p>\n Was hier am Beispiel von Aufgaben exemplarisch gezeigt wurde, lässt sich leicht auf Basis anderer Objekte wie E-Mails, Kontakte oder Termine nachstellen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n Outlookaufgaben.accdb<\/p>\n Outlookaufgaben.mdb<\/p>\n ThisOutlookSession.cls<\/p>\n\nPrivate Sub Application_Startup()\r\nEnd Sub<\/pre>\n
Dim WithEvents objItems As Outlook.Items<\/pre>\n
Private Sub Application_Startup()\r\n Set objItems = Application.Session.GetDefaultFolder(olFolderTasks).Items\r\nEnd Sub<\/pre>\n
\n ![\"pic001.tif\"](\"OutlookobjekteInAccessSpeichern-web-images\/pic001_opt.jpeg\")
\n <\/div>\n\nPrivate Sub objItems_ItemAdd(ByVal Item As _
Object)\r\n Dim objTaskItem As Outlook.TaskItem\r\n Set objTaskItem = Item\r\n With objTaskItem\r\n MsgBox .Subject & \" \" & .Body\r\n End With\r\nEnd Sub<\/pre>\nPrivate Sub objItems_ItemRemove()\r\nEnd Sub<\/pre>\n
Dim WithEvents objTaskItem As Outlook.TaskItem<\/pre>\n
Private Sub Application_ItemLoad(ByVal _
Item As Object)\r\n MsgBox \"ItemLoad aufgerufen\"\r\nEnd Sub<\/pre>\nPrivate Sub Application_ItemLoad(ByVal _
Item As Object)\r\n If Item.Class = olTask Then\r\n Set objTaskItem = Item\r\n End If\r\nEnd Sub<\/pre>\n\n ![\"pic002.tif\"](\"..\/fileadmin\/_temp_\/2007_05\/OutlookobjekteInAccessSpeichern-web-images\/pic002_opt.jpeg\")
\n <\/div>\n\n\n ![\"pic003.tif\"](\"..\/fileadmin\/_temp_\/2007_05\/OutlookobjekteInAccessSpeichern-web-images\/pic003_opt.jpeg\")
\n <\/div>\n\nPrivate Sub Application_ItemLoad(ByVal _
Item As Object)\r\n MsgBox Item.Class\r\nEnd Sub<\/pre>\nPrivate Sub objTaskItem_BeforeDelete(ByVal _
Item As Object, Cancel As Boolean)\r\n MsgBox \"Delete \" & objTaskItem.Subject _
& \" \" & objTaskItem.Body\r\nEnd Sub<\/pre>\nDim db As DAO.Database\r\nSet db = CurrentDB<\/pre>\n
Dim db As DAO.Database\r\nSet db = DBEngine.OpenDatabase(\"<Pfad>\\<Datei>\")<\/pre>\n
\nPrivate Sub objItems_ItemAdd(ByVal Item As Object)
\r\n Dim db As DAO.Database\r\n Dim objTaskItem As Outlook.TaskItem\r\n Dim rst As DAO.Recordset\r\n Set db = DBEngine.OpenDatabase(\"<Pfad>\\<Datei>\")\r\n Set objTaskItem = Item\r\n Set rst = db.OpenRecordset(\"SELECT * FROM tblAufgaben WHERE 1=2\", _
dbOpenDynaset)\r\n With objTaskItem\r\n rst.AddNew\r\n With rst\r\n !Subject = objTaskItem.Subject\r\n !Body = objTaskItem.Body\r\n !StartDate = objTaskItem.StartDate\r\n !DueDate = objTaskItem.DueDate\r\n !DateCompleted = objTaskItem.DateCompleted\r\n !PercentComplete = objTaskItem.PercentComplete\r\n !Importance = objTaskItem.Importance\r\n End With\r\n If objTaskItem.BillingInformation = \"\" Then\r\n objTaskItem.BillingInformation = rst!ID\r\n End If\r\n rst.Update\r\n End With
\r\n Set db = Nothing
\r\nEnd Sub<\/pre>\n<\/p><\/div>\nDownloads zu diesem Beitrag<\/h3>\n