{"id":55000340,"date":"2022-12-01T00:00:00","date_gmt":"2023-03-02T16:58:51","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=340"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Outlook_Ordner_per_VBA_im_Griff","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Outlook_Ordner_per_VBA_im_Griff\/","title":{"rendered":"Outlook: Ordner per VBA im Griff"},"content":{"rendered":"

\"Outlook-Ordner<\/p>\n

Bild 1: Outlook-Ordner für E-Mails<\/span><\/b><\/p>\n

Bei einer frischen Outlook-Installation ist die Ordner-Hierarchie recht übersichtlich. Je mehr E-Mails man mit Outlook erhält oder je mehr man mit den übrigen Objekten arbeitet, umso mehr Ordner legt man in den bereits vorhandenen Ordnern als Unterordner an. Für uns ist natürlich vor allem interessant, wie wir per VBA auf die einzelnen Ordner zugreifen, Ordner ermitteln, anlegen, bearbeiten oder auch löschen. Interessant ist auch, gezielt nach einem Ordner zu suchen und diesen zu referenzieren. Gegebenenfalls möchten wir auch einmal alle vorhandenen Ordner durchlaufen, um die enthaltenen Elemente zu verarbeiten. Wie all dies funktioniert, zeigen wir im vorliegenden Artikel!<\/b><\/p>\n

Wer eine neue Outlook-Installation öffnet und ein erstes E-Mail-Konto angelegt hat, findet erst einmal nur die Standardordner im linken Bereich des Outlook-Fensters vor. Dazu gehören der Posteingang, der Postausgang, Ordner für gelöschte Elemente, Entwürfe, gesendete Elemente und für Junk-E-Mail (siehe Bild 1).<\/p>\n

\"Outlook-Ordner<\/p>\n

Bild 1: Outlook-Ordner für E-Mails<\/span><\/b><\/p>\n

Wechseln wir über die Schaltflächen unten links zu einem der anderen Bereiche wie beispielsweise dem Kalender, den Kontakten oder den Aufgaben, finden wir im linken Bereich wiederum verschiedene Ordner für die jeweilige Kategorie vor. Wer immer alle Ordner aus den verschiedenen Bereichen im Überblick sehen möchte, kann über die Schaltfläche mit den drei Punkten weitere Befehle anzeigen (sofern diese noch nicht sichtbar sind) und über den Befehl Ordner <\/b>eine Übersicht aller Ordner einblenden. Diese liefert schließlich alle Ordner der verschiedenen Kategorien in einer Liste (siehe Bild 2).<\/p>\n

\"Alle<\/p>\n

Bild 2: Alle Outlook-Ordner im Überblick<\/span><\/b><\/p>\n

Zugriff von innen und außen<\/h2>\n

Die Beispiele zu diesem Artikel haben wir so programmiert, dass Du sie sowohl direkt in den Modulen des VBA-Projekts von Outlook verwenden kannst, aber auch in anderen Anwendungen wie Access, Excel oder Word.<\/p>\n

Wir greifen also nicht einfach über die Klasse Application auf die davon bereitgestellten Objekte, Eigenschaften, Methoden und Ereignisse zu, sondern über eine Objektvariable namens objOutlook<\/b>, die wir zuvor deklarieren und füllen.<\/p>\n

Außerdem wollen wir per Early Binding auf die Klassen zugreifen, damit wir IntelliSense beim Programmieren nutzen können. Wenn Du nicht vom VBA-Projekt von Outlook aus auf die Outlook-Objekte zugreifen möchtest, musst Du dazu noch einen Verweis auf die Objektbibliothek von Outlook hinzufügen.<\/p>\n

Dazu öffnest Du den VBA-Editor von der jeweiligen Anwendung aus und wählst dort den Menübefehl Extras|Verweise <\/b>aus.<\/p>\n

Es erscheint der Verweise<\/b>-Dialog, wo Du in der Liste den Eintrag Microsoft Outlook 16.0 Object Library <\/b>auswählst (siehe Bild 3). Danach schließt Du den Dialog wieder.<\/p>\n

\"Hinzufügen<\/p>\n

Bild 3: Hinzufügen eines Verweises auf die Outlook-Objektbibliothek<\/span><\/b><\/p>\n

Auf die Outlook-Anwendung greifen wir dann mit den folgenden beiden Befehlen zu:<\/p>\n

Dim <\/span>objOutlook As <\/span>Outlook.Application\r\nSet<\/span> objOutlook = New<\/span> Outlook.Application<\/pre>\n
Auf diese Weise können wir auch beispielsweise vom VBA-Projekt einer Excel-Datei oder von anderen Anwendungen darauf zugreifen.<\/p>\n
Mutter aller Ordner: Der MAPI-Namespace<\/h2>\n
Wenn wir direkt auf die Ordner von Outlook zugreifen wollen, können wir nicht direkt irgendeine Folders<\/b>-Auflistung des Application<\/b>-Objekts von Outlook nutzen, sondern es gibt noch eine Zwischenschicht. Diese ist das Namespace<\/b>-Objekt, das wir allerdings nicht mit dem New<\/b>-Schlüsselwort erzeugen, sondern mit der Methode GetNamespace <\/b>holen.<\/p>\n
Für diese übergeben wir den Wert MAPI <\/b>als Parameter. Das Namespace-Objekt deklarieren wir beispielsweise als objMAPI <\/b>oder objNamespace <\/b>und weisen es dann wie folgt zu:<\/p>\n
Dim <\/span>objMAPI As <\/span>Outlook.NameSpace\r\nSet<\/span> objMAPI = objOutlook.GetNamespace(\"MAPI\")<\/pre>\n
Zugriff über die Folders-Auflistung<\/h2>\n
Die einfachste Methode, auf ein Folder<\/b>-Element zuzugreifen ist die Folders<\/b>-Auflistung des NameSpace<\/b>-Objekts. Mit seiner Count<\/b>-Eigenschaft können wir die Anzahl der Folder<\/b>-Objekte ermitteln, allerdings nur für die der ersten Ebene.<\/p>\n
Was im Neuzustand einer Outlook-Datei noch nicht zu erkennen ist: Wir können den vorhandenen Ordnern durchaus Unterordner hinzufügen. Genaugenommen ist das auch schon der Fall, wie der erste Aufruf der Count<\/b>-Eigenschaft der Folders<\/b>-Auflistung zeigt:<\/p>\n
Debug.Print<\/span> objMAPI.Folders.Count\r\n1<\/pre>\n
Folder-Element referenzieren<\/h2>\n
Wir erhalten nämlich genau ein Folder<\/b>-Element. Auf dieses wollen wir nun zugreifen und seinen Namen ermitteln. Dazu referenzieren wir es, was auf verschiedene Arten gelingt. Die erste ist die über den Index. Damit greifen wir wie folgt auf das Element zu:<\/p>\n
Debug.Print<\/span> objMAPI.Folders(1).Name\r\nandre@minhorst.com<\/pre>\n
Als Ergebnis erhalten wir den Namen des Hauptordners, in diesem Fall nach der E-Mail-Adresse benannt, für die wir Outlook eingerichtet haben. Je nach Einrichtung kann dieser Ordner auch Outlook <\/b>heißen. Eine weitere wichtige Information hieraus ist: Der Index der Folders<\/b>-Auflistung ist 1<\/b>-basiert.<\/p>\n
Die zweite Möglichkeit, ein Folder<\/b>-Element über die Folders<\/b>-Auflistung zu referenzieren, ist die Angabe des Namens, sofern dieser bekannt ist.<\/p>\n
Debug.Print<\/span> objMAPI.Folders(\"andre@minhorst.com\").Name<\/pre>\n
Was die Eigenschaften und Methoden der Folder<\/b>-Klasse angeht, tappen wir hier etwas im Dunkeln, denn wenn wir ein Element über die Auflistung ansprechen, werden diese nicht per IntelliSense bereitgestellt. Dazu benötigen wir eine entsprechende Objektvariable.<\/p>\n
Variable für Folder-Element<\/h2>\n
Deshalb referenzieren wir als Nächstes ein Folder<\/b>-Element mit einer Variablen. Diese deklarieren wir beispielsweise wie folgt:<\/p>\n
Dim <\/span>objFolder As <\/span>Outlook.Folder<\/pre>\n
Dieser Variablen weisen wir nun das Folder<\/b>-Element hinzu:<\/p>\n
Set<\/span> objFolder = objMAPI.Folders(1)<\/pre>\n
Danach können wir leicht per IntelliSense auf die einzelnen Eigenschaften des Folder<\/b>-Elements zugreifen. Wie das gelingt, sehen wir in Bild 4.<\/p>\n
\"Eigenschaften<\/p>\n
Bild 4: Eigenschaften des Folder-Elements per IntelliSense nutzen<\/span><\/b><\/p>\n
Folders-Auflistung durchlaufen<\/h2>\n
Wenn wir für das Root-Folder-Element die Anzahl der untergeordneten Folder<\/b>-Elemente ermitteln, erhalten wir für unsere frisch installierte Outlook-Anwendung bereits einige Unterordner:<\/p>\n
Debug.Print<\/span> objFolder.Folders.Count\r\n14<\/pre>\n
Damit können wir schon eher etwas anfangen und wollen diese nun per Schleife durchlaufen.<\/p>\n
Das gelingt sowohl in einer For…Next<\/b>-Schleife als auch in einer For Each<\/b>-Schleife.<\/p>\n
Mit der For…Next<\/b>-Schleife durchlaufen wir die Elemente von 1 <\/b>bis zur Anzahl der Elemente:<\/p>\n
Dim <\/span>i As Long<\/span>\r\nFor i = 1 To objFolder.Folders.Count\r\n     Debug.Print<\/span> i, objFolder.Folders(i).Name\r\nNext<\/span> i<\/pre>\n
Das Ergebnis sieht wie folgt aus:<\/p>\n
  1            Gelöschte Elemente\r\n  2            Posteingang\r\n  3            Postausgang\r\n  4            Gesendete Elemente\r\n  5            Kalender\r\n  6            Kontakte\r\n  7            Journal\r\n  8            Notizen\r\n  9            Aufgaben\r\n  10           Entwürfe\r\n  11           RSS-Feeds\r\n  12           Einstellungen für Unterhaltungsaktionen\r\n  13           Einstellungen für QuickSteps\r\n  14           Junk-E-Mail<\/pre>\n
Mit einer For Each<\/b>-Schleife durchlaufen wir die Folder<\/b>-Elemente wie folgt:<\/p>\n
Dim <\/span>objSubfolder As <\/span>Folder\r\nFor Each objSubfolder In objFolder.Folders\r\n     Debug.Print<\/span> objSubfolder.Name\r\nNext<\/span> objSubfolder<\/pre>\n
Das Ergebnis ist identisch – mit Ausnahme der fehlenden Werte der Laufvariablen.<\/p>\n
Standardordner mit GetDefaultFolder referenzieren<\/h2>\n
Bevor wir uns die Eigenschaften der Folder<\/b>-Klasse ansehen, wollen wir noch weitere Möglichkeiten zum Referenzieren von Folder<\/b>-Elementen betrachten. Wenn wir die Eigenschaften und Methoden des MAPI-Namespaces per IntelliSense anzeigen, finden wir hier beispielsweise noch die Methode GetDefaultFolder<\/b> (siehe Bild 5).<\/p>\n
\"Weitere<\/p>\n
Bild 5: Weitere Methoden zum Referenzieren von Folder-Elementen<\/span><\/b><\/p>\n
Wählen wir diese aus und tippen noch eine öffnende Klammer ein, erhalten wir eine Auflistung der möglichen Ordner. Diese lauten:<\/p>\n