{"id":55000309,"date":"2022-04-01T00:00:00","date_gmt":"2023-08-30T13:11:53","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=309"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"EMails_per_VBA_erstellen_mit_CreateItem_","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/EMails_per_VBA_erstellen_mit_CreateItem_\/","title":{"rendered":"E-Mails per VBA erstellen mit CreateItem"},"content":{"rendered":"

\"\"<\/p>\n

Wie man mit Outlook eine E-Mail erstellt, diese mit Betreff, Inhalt, Anlagen, Empfänger und so weiter füllt und diese dann verschickt, weiß mittlerweile jeder. Aber was, wenn man das Erstellen von E-Mails automatisieren möchte und dazu VBA nutzen will? Beispielsweise, um auf Knopfdruck eine Standardmail an einen Empfänger zu schicken oder auch eine Mail an eine Liste von Kunden zu senden? Der vorliegende Artikel zeigt, wie Sie per VBA neue E-Mails erstellen und diese dann entweder zum Betrachten, Nachbearbeiten und zum manuellen Senden anzeigen oder diese sofort auf den Weg zum Empfänger bringen.<\/b><\/p>\n

Einfache E-Mails programmieren<\/h2>\n

Unabhängig von den vielen Anwendungsfällen, die wir uns für das VBA-gesteuerte Erstellen von E-Mails vorstellen können, schauen wir uns in diesem Artikel erst einmal die technische Seite an. Dabei wollen wir eine einfache E-Mail wie die aus Bild 1 erstellen – also den Empfänger festlegen und den Betreff und den Inhalt eintragen. Als Abschluss wollen wir noch ein Attachment hinzufügen.<\/p>\n

\"Zu<\/p>\n

Bild 1: Zu erstellende E-Mail<\/span><\/b><\/p>\n

Beispielcode in neuem Modul<\/h2>\n

Den Beispielcode zum Erstellen einer solchen E-Mail bringen wir in einem neuen Modul im VBA-Projekt des VBA-Editors unter, wo wir diesen leicht ausführen können. In weiteren Artikeln schauen wir uns an, wie wir solche und andere Prozeduren über das Ribbon starten können – entweder durch manuelle, benutzerdefinierte Anpassungen oder auch durch das Bereitstellen von Code und Ribbon-Anpassungen mit COM-Add-Ins.<\/p>\n

Dazu öffnest Du den VBA-Editor (am schnellsten mit der Tastenkombination Alt + F11<\/b>) und wählst den Menübefehl Einfügen|Modul <\/b>aus. Damit Du den gleich erstellten Code später schnell wiederfindest, ändern wir gleich den Namen des neuen Moduls. Dazu markieren wir das Modul im Projekt<\/b>-Explorer (Strg + R<\/b>) und passen dann den Namen im Eigenschaften<\/b>-Bereich an (F4<\/b>) und geben für die Eigenschaft (Name) <\/b>den Wert mdlEMailsErstellen <\/b>ein (siehe Bild 2).<\/p>\n

\"Umbenennen<\/p>\n

Bild 2: Umbenennen des VBA-Moduls<\/span><\/b><\/p>\n

Leere E-Mail erstellen<\/h2>\n

Danach beginnen wir mit dem Erstellen und Anzeigen einer neuen, leeren E-Mail. Dazu legen wir eine neue Prozedur namens LeereEMailErstellen <\/b>an.<\/p>\n

Hier kannst Du nun direkt mit dem Programmieren beginnen, und zwar mit der folgenden kleinen Prozedur. Diese deklariert eine Objektvariable des Typs MailItem <\/b>und füllt diese durch den Aufruf der Methode Create-Item<\/b>. Diese Methode können wir zum Erstellen aller in Outlook verwendeter Elemente wie E-Mails, Kontakte, Termine, Aufgaben, Notizen et cetera nutzen.<\/p>\n

Dazu müssen wir lediglich den Typ des zu erstellenden Elements in Form einer Konstanten für den einzigen Parameter der Methode CreateItem <\/b>übergeben. Im Falle einer E-Mail handelt es sich dabei um die Konstante olMailItem<\/b>. Damit haben wir, auch wenn wir diese noch nicht sehen, bereits eine neue E-Mail erstellt. Um diese sichtbar zu machen, rufen wir noch die Methode Display <\/b>der Objektvariablen mit der neuen E-Mail auf:<\/p>\n

Public Sub <\/span>LeereEMailErstellen()\r\n     Dim <\/span>objMailItem As <\/span>MailItem\r\n     Set<\/span> objMailItem = Application.CreateItem(olMailItem)\r\n     objMailItem.Display\r\nEnd Sub<\/span><\/pre>\n
Um diese Prozedur auszuführen, platzieren wir einfach die Einfügemarke innerhalb der Prozedur und betätigen die Taste F5<\/b>. Das funktioniert wie gewünscht: Es erscheint eine neue, leere E-Mail (siehe Bild 3).<\/p>\n
\"Eine<\/p>\n
Bild 3: Eine per VBA erstellte E-Mail<\/span><\/b><\/p>\n
Parameter der Display-Methode<\/h2>\n
Die Display<\/b>-Methode bietet einen Parameter namens Modal <\/b>an, der standardmäßig auf False <\/b>eingestellt ist. Wenn Sie diesen auf True einstellen, wird die E-Mail als modales Fenster geöffnet. Das heißt, dass der Benutzer erst mit Outlook weiterarbeiten kann, wenn er die E-Mail auf irgendeine Art geschlossen hat – entweder durch Versenden oder durch anderweitiges Schließen:<\/p>\n
objMailItem.Display True<\/span><\/pre>\n
Für Experimente mit den in diesem Artikel vorgestellten Beispielen ist die Einstellung des Parameters Modal <\/b>auf den Wert True<\/b> recht praktisch, da das VBA-Fenster immer den Fokus behält und gegebenenfalls geöffnete Inspector-Fenster mit E-Mails verdeckt.<\/p>\n
Eigenschaften der E-Mail einstellen<\/h2>\n
Nun wollen wir die Eigenschaften wie den Empfänger, den Betreff und den Inhalt der E-Mail einstellen. Dazu deklarieren wir in einer neuen Prozedur namens EMailErstellen <\/b>eine weitere Variable namens strBody<\/b> (siehe Listing 1). In dieser stellen wir den Inhalt der E-Mail zusammen, bevor wir ihn zuweisen. Zuvor jedoch weisen wir der Eigenschaft To <\/b>den Empfänger zu und der Eigenschaft Subject <\/b>den Betreff der E-Mail.<\/p>\n
Public Sub <\/span>EMailErstellen()\r\n     Dim <\/span>objMailItem As <\/span>MailItem\r\n     Dim <\/span>strBody As String<\/span>\r\n     Set<\/span> objMailItem = Application.CreateItem(olMailItem)\r\n     With<\/span> objMailItem\r\n         .To = \"andre@minhorst.com\"\r\n         .Subject = \"Beispielmail\"\r\n         strBody = \"Hallo André, \" & vbCrLf<\/span> & vbCrLf<\/span>\r\n         strBody = strBody & \"ich hoffe, es geht Dir gut! Anbei findest Du das gewünschte Bild.\" & vbCrLf<\/span> & vbCrLf<\/span>\r\n         strBody = strBody & \"Viele Grüße\" & vbCrLf<\/span>\r\n         strBody = strBody & \"Klaus\"\r\n         .Body = strBody\r\n         .Display\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Code zum Erstellen einer Mail mit Empfänger, Betreff und Inhalt<\/span><\/b><\/p>\n
Danach weisen wir der Variablen strBody <\/b>die erste Zeile des Inhalts zu und fügen dieser mit der Konstanten vbCrLf <\/b>zwei Zeilenumbrüche hinzu. Die nächste Anweisung greift den Inhalt von strBody <\/b>auf und fügt diesem eine weitere Zeile samt Zeilenumbrüchen hinzu – und so stellen wir den kompletten Inhalt der E-Mail zusammen. Ist der Inhalt in strBody <\/b>zusammengestellt, weisen wir diesen der Eigenschaft Body <\/b>des MailItem<\/b>-Elements zu. Schließlich zeigen wir die vollständige E-Mail wieder mit der Display<\/b>-Methode an.<\/p>\n
Da wir in dieser Prozedur oft auf Eigenschaften und Methoden des Elements objMailItem <\/b>zugreifen, haben wir diese mit dem With<\/b>-Schlüsselwort referenziert. Zwischen dieser Zeile und der Zeile End With <\/b>können wir dann über die Punkt-Syntax auf die Eigenschaften und Methoden zugreifen, ohne jedes Mal explizit das Element objMailItem <\/b>angeben zu müssen.<\/p>\n
Führen wir nun diese Prozedur mit F5 <\/b>aus, erscheint schon fast die eingangs beschriebene E-Mail – es fehlt lediglich noch die Anlage. Wir wollen der E-Mail noch eine Datei namens pic001.png <\/b>hinzufügen.<\/p>\n
Anlagen zu einer E-Mail hinzufügen<\/h2>\n
Für das Hinzufügen von Anlagen bietet das MailItem-Element die Auflistung Attachments <\/b>an. Um dieser eine Anlage hinzuzufügen, wählen wir dessen Methode Add <\/b>mit IntelliSense aus (siehe Bild 4).<\/p>\n
\"Methoden<\/p>\n
Bild 4: Methoden per IntelliSense auswählen<\/span><\/b><\/p>\n
Nachdem wir das getan haben, können wir als Parameter den Namen der hinzuzufügenden Datei angeben.  Diesen speichern wir in einer Variablen namens strAttachment<\/b>:<\/p>\n
Dim <\/span>strAttachment As String<\/span><\/pre>\n
Die Zuweisung erfolgt beispielsweise wie folgt (den Pfad haben wir abgekürzt):<\/p>\n
strAttachment = \"c:\\...\\pic001.png\"<\/pre>\n
Und schließlich weisen wir das Attachment der E-Mail zu. Diese zusätzliche Zeile fügen wir unmittelbar vor der Zeile mit der Display<\/b>-Anweisung zum Anzeigen der E-Mail ein:<\/p>\n
objMailitem.Attachments.Add strAttachment<\/pre>\n
Führen wir die neue Version der Prozedur aus, erhalten wir genau die eingangs beschriebene E-Mail<\/p>\n
E-Mail direkt nach dem Erstellen versenden<\/h2>\n
Wenn wir die neue E-Mail mit der Display<\/b>-Methode anzeigen, kann der Benutzer diese noch kontrollieren, gegebenenfalls anpassen und sie dann mit einem Klick auf die Senden<\/b>-Schaltfläche auf den Weg bringen. Vielleicht möchtest Du dies gar nicht tun, sondern die E-Mail direkt verschicken. Dann brauchst Du nur den Aufruf der Display<\/b>-Methode durch den der Send<\/b>-Methode zu ersetzen:<\/p>\n
Public Sub <\/span>EMailErstellen()\r\n     ...\r\n     Set<\/span> objMailItem = Application.CreateItem(olMailItem)\r\n     With<\/span> objMailItem\r\n         ...\r\n         .Send\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Dies verschickt die E-Mail wie andere E-Mails auch, die Du über die Benutzeroberfläche versendest. Genau wie diese E-Mails landen auch per VBA versendete E-Mails im Ordner Gesendete Elemente<\/b>.<\/p>\n
Mehrere Empfänger hinzufügen<\/h2>\n
Wenn die E-Mail im Feld To <\/b>mehrere Empfänger enthalten soll, gibt es zwei Möglichkeiten:<\/p>\n
    \n
  • Empfänger durch Semikola getrennt der Eigenschaft To <\/b>zuweisen<\/li>\n
  • Empfänger zur Auflistung Recipients <\/b>hinzufügen<\/li>\n<\/ul>\n
    Die erste Variante sieht wie folgt aus:<\/p>\n
    objMailitem.To = \"andre@minhorst.com;info@amvshop.de\"<\/pre>\n
    Bei der zweiten Variante ist etwas mehr Aufwand erforderlich – dafür muss man die Empfänger nicht zu einer semikola-separierten Liste zusammenstellen:<\/p>\n
    objMailitem.Recipients.Add \"andre@minhorst.com\"\r\nobjMailitem.Recipients.Add \"info@amvshop.de\"<\/pre>\n
    Dies wiederholt man für alle Empfänger, welche die E-Mail erhalten sollen – das Ergebnis ist das Gleiche wie zuvor.<\/p>\n
    Empfänger mit CC und BCC<\/h2>\n
    Möchtest Du der E-Mail weitere Empfänger hinzufügen, welche die E-Mail als CC <\/b>oder BCC <\/b>erhalten, kannst Du die gleichnamigen Eigenschaften dazu nutzen. Das sieht wie folgt aus:<\/p>\n
    objMailitem.CC = \"andre@minhorst.com\"\r\nobjMailitem.BCC = \"info@amvshop.de\"<\/pre>\n
    Das Ergebnis sehen wir in Bild 5.<\/p>\n
    \"Per<\/p>\n
    Bild 5: Per CC und BCC hinzugefügte Empfänger<\/span><\/b><\/p>\n
    Weitere Eigenschaften einstellen<\/h2>\n
    Eine weitere Eigenschaft, die der eine oder andere gern einstellt, um seinen E-Mails eine andere Priorität zu geben, finden wir rechts im Ribbon einer neuen E-Mail (siehe Bild 6). Die beiden markierten Schaltflächen stehen wir Wichtigkeit: hoch <\/b>und Wichtigkeit: niedrig<\/b>. Auch diese können wir beim Erstellen einer E-Mail per VBA einstellen. Dazu nutzen wir die Eigenschaft Importance<\/b>, der wir einen der folgenden Werte zuweisen können:<\/p>\n
    \"Weitere<\/p>\n
    Bild 6: Weitere Eigenschaften von E-Mails<\/span><\/b><\/p>\n
      \n
    • olImportanceHigh<\/b><\/li>\n
    • olImportanceLow<\/b><\/li>\n
    • olImportanceNormal<\/b><\/li>\n<\/ul>\n
      Dabei ist olImportanceNormal <\/b>der Standardwert. Um eine E-Mail mit hoher Priorität zu verschicken, weisen wir dieser über die Eigenschaft Importance <\/b>den Wert olImportanceHigh <\/b>zu:<\/p>\n
      objMailitem.Importance = olImportanceHigh<\/pre>\n
      Und auch das beliebte Anfordern einer Lesebestätigung (und auch einer Zustellbestätigung) können wir sowohl beim Erstellen einer E-Mail über die Benutzeroberfläche (siehe Bild 7) als auch per VBA realisieren.<\/p>\n
      \"Anforderung<\/p>\n
      Bild 7: Anforderung verschiedener Bestätigungen<\/span><\/b><\/p>\n
      Die für das Anfordern einer Lesebestätigung benötigte Eigenschaft heißt ReadReceiptRequested <\/b>und nimmt die Werte True <\/b>oder False <\/b>entgegen. Eine Zustellungsbestätigung liefert OriginatorReportRequested<\/b>:<\/p>\n
      objMailItem.ReadReceiptRequested = True<\/span>\r\nobjMailItem.OriginatorDeliveryReportRequested = True<\/span><\/pre>\n
      Textformatierung einstellen<\/h2>\n
      Während für die meisten E-Mails die Darstellung als reiner Text ausreichen dürfte, möchte man doch manchmal eine schicke Signatur mit Logo verwenden oder Bilder oder Screenshots in den Text einarbeiten. Gegebenenfalls ist auch die Formatierung des Textes erwünscht. Um das Format des Mailinhalts einzustellen, können wir die Eigenschaft BodyFormat <\/b>verwenden. Diese bietet die folgenden Werte an:<\/p>\n
        \n
      • olFormatHTML<\/b> (2<\/b>): Standardeinstellung. Hier stehen alle Formatierungsmöglichkeiten zur Verfügung. Die HTML-Variante des E-Mail-Inhalts steht über die Eigenschaft HTMLBody <\/b>zur Verfügung.<\/li>\n
      • olFormatPlain <\/b>(1<\/b>): Reines Textformat.<\/li>\n
      • olFormatRichText<\/b> (3): Hier stehen alle Formatierungsmöglichkeiten zur Verfügung. Die HTML-Variante des E-Mail-Inhalts steht über die Eigenschaft HTMLBody <\/b>zur Verfügung.<\/li>\n
      • olFormatUnspecified<\/b> (0): Kein Format angegeben.<\/li>\n<\/ul>\n
        Der Unterschied zwischen olFormatHTML <\/b>und olFormatRichText <\/b>liegt in der Verwendung etwas unterschiedlicher HTML-Auszeichnungen. <\/p>\n
        HTML-Text angeben<\/h2>\n
        Egal, welchen Wert wir für die Eigenschaft BodyFormat <\/b>einstellen: Wenn wir nur einen Text für die Eigenschaft Body hinterlegen, generiert Outlook automatisch eine HTML-formatierte Version. Diese können wir über die Eigenschaft HTMLBody <\/b>abrufen. Für unsere Beispielnachricht sieht dieser wie folgt aus:<\/p>\n
        <!DOCTYPE HTML PUBLIC \"-\/\/W3C\/\/DTD HTML 3.2\/\/EN\">\r\n<HTML>\r\n<HEAD>\r\n<META NAME=\"Generator\" CONTENT=\"MS Exchange Server version 16.0.15511.20000\">\r\n<TITLE><\/TITLE>\r\n<\/HEAD>\r\n<BODY>\r\n<!-- Converted from text\/plain format -->\r\n<P><FONT SIZE=2>Hallo André,<BR>\r\n<BR>\r\nich hoffe, es geht Dir gut! Anbei findest Du das gewünschte Bild.<BR>\r\n<BR>\r\nViele Grüße<BR>\r\nKlaus<\/FONT>\r\n<\/P>\r\n<\/BODY>\r\n<\/HTML><\/pre>\n
        Wenn wir den Text direkt beim Anlegen der E-Mail mit HTML-Auszeichnungen versehen wollen, können wir das ebenfalls per VBA erledigen. Dazu brauchen wir nur den entsprechenden HTML-Text zusammenzustellen und weisen diesen dann nicht der Eigenschaft Body <\/b>zu, sondern HTMLBody<\/b>. Im Beispiel aus Listing 2 haben wir einmal einige HTML-Tags zu unserem Beispielinhalt hinzugefügt, darunter auch eine fette Auszeichnung.<\/p>\n
        Public Sub <\/span>HTMLEMailErstellen()\r\n     Dim <\/span>objMailItem As <\/span>MailItem\r\n     Dim <\/span>strBody As String<\/span>\r\n     Dim <\/span>strAttachment As String<\/span>\r\n     Set<\/span> objMailItem = Application.CreateItem(olMailItem)\r\n     Dim <\/span>objRecipient As <\/span>Outlook.Recipient\r\n     With<\/span> objMailItem\r\n         .To = \"andre@minhorst.com\"\r\n         .BodyFormat = olFormatHTML\r\n         .Subject = \"Beispielmail\"\r\n         strBody = \"<p>Hallo André,<\/p>\" & vbCrLf<\/span> & vbCrLf<\/span>\r\n         strBody = strBody & \"<p>ich hoffe, <b>es geht Dir gut<\/b>! Anbei findest Du das gewünschte Bild.<\/p>\" & vbCrLf<\/span> & vbCrLf<\/span>\r\n         strBody = strBody & \"<p>Viele Grüße<\/p>\" & vbCrLf<\/span>\r\n         strBody = strBody & \"<p>Klaus<\/p>\"\r\n         .HTMLBody = strBody\r\n         Debug.Print<\/span> .HTMLBody\r\n         .Display\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
        Listing 2: Erstellen einer E-Mail mit HTML-Inhalt<\/span><\/b><\/p>\n
        Diese E-Mail sieht nach dem Erstellen wie in Bild 8 aus. Wenn Du eine solche E-Mail erstellst und versendest, wirst Du allerdings feststellen, dass Outlook hier noch einige Auszeichnungen hinzufügt.<\/p>\n
        \"E-Mail<\/p>\n
        Bild 8: E-Mail mit HTML-Body<\/span><\/b><\/p>\n
        Um sich davon zu überzeugen, braucht man nur die gesendete E-Mail im Postausgang zu öffnen und mit der rechten Maustaste auf den Inhalt zu klicken. Der Kontextmenü-Befehl Quelle anzeigen liefert dann den von Outlook erzeugten Quellcode, der nicht mehr viel mit dem von uns vorgesehenen Code zu tun hat …<\/p>\n
        Zusammenfassung und Ausblick<\/h2>\n
        Dieser Artikel zeigt, wie Du E-Mails per VBA erstellen und versenden kannst. Dabei stellen wir die wichtigsten Eigenschaften vor.<\/p>\n
        Es gibt noch viel mehr, was wir in Zusammenhang mit dem Versenden von E-Mails besprechen könnten – zum Beispiel kann man auch die Absenderadresse per VBA einstellen. Das ist allerdings nicht mit einem einfachen Einstellen einer Eigenschaft wie From getan, daher kümmern wir uns in einem späteren Artikel darum.<\/p>\n","protected":false},"excerpt":{"rendered":"
        Wie man mit Outlook eine E-Mail erstellt, diese mit Betreff, Inhalt, Anlagen, Empfänger und so weiter füllt und diese dann verschickt, weiß mittlerweile jeder. Aber was, wenn man das Erstellen von E-Mails automatisieren möchte und dazu VBA nutzen will? Beispielsweise, um auf Knopfdruck eine Standardmail an einen Empfänger zu schicken oder auch eine Mail an eine Liste von Kunden zu senden? Der vorliegende Artikel zeigt, wie Sie per VBA neue E-Mails erstellen und diese dann entweder zum Betrachten, Nachbearbeiten und zum manuellen Senden anzeigen oder diese sofort auf den Weg zum Empfänger bringen.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[66022022,662022,44000026,44000023],"tags":[],"yst_prominent_words":[],"class_list":["post-55000309","post","type-post","status-publish","format-standard","hentry","category-66022022","category-662022","category-Outlook_programmieren","category-PowerApps"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t