{"id":55000859,"date":"2012-12-01T00:00:00","date_gmt":"2020-05-22T21:49:08","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=859"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"OutlookMails_mit_Klasse","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/OutlookMails_mit_Klasse\/","title":{"rendered":"Outlook-Mails mit Klasse"},"content":{"rendered":"

\"\"<\/p>\n

Das Versenden von E-Mails mit Access ist eines der besten Beispiele für die Interaktion von Access mit anderen Office-Komponenten. Es gibt zahlreiche Anwendungsfälle für das Versenden von E-Mails von einer Datenbank-Anwendung aus – egal, ob es sich nun um Anschreiben an Kunden, an Serien-E-Mails oder auch an E-Mails zum Versenden von Fehlermeldungen handelt. Grund genug, diese Funktion einmal in eine eigene Klasse auszulagern, die Sie dann ganz einfach in die Zielanwendung importieren und direkt einsetzen können.<\/b><\/p>\n

Diese Klasse umfasst einige Funktionen, die erst mit neueren Outlook-Versionen verfügbar sind. Wir weisen an entsprechender Stelle darauf hin und stellen auch eine Version der Klasse zur Verfügung, die mit älteren Outlook-Versionen arbeitet. Um die hier vorgestellte Klasse einsetzen zu können, müssen Sie lediglich die Klasse in Ihre Anwendung importieren und einen Verweis auf die Bibliothek Microsoft Outlook x.0 Object Library <\/b>zum VBA-Projekt der aktuellen Datenbank hinzufügen. Die Klasse finden in der Beispieldatenbank zu diesem Beitrag, den Verweis fügen Sie über den Verweise<\/b>-Dialog (VBA-Editor, Menü-Eintrag Extras|Verweise<\/b>) hinzu.<\/p>\n

Einfacher Versand<\/b><\/p>\n

Wenn Sie beispielsweise einen Kundendatensatz samt E-Mail-Adresse des Kunden in einem Formular anzeigen, können Sie diesem eine einfache Schaltfläche zum Erstellen einer E-Mail an diesen Kunden hinzufügen (s. Bild 1).<\/p>\n

\"pic001.png\"<\/p>\n

Bild 1: Einfacher Mailversand an einen Kunden<\/span><\/b><\/p>\n

Ein Klick auf diese Schaltfläche soll eine neue E-Mail anlegen und öffnen, damit der Betreff und der Inhalt eingefügt werden können. Der dazu notwendige Code sieht schlicht wie folgt aus:<\/p>\n

Private Sub cmdEMailSenden_Click()\r\n    Dim objMail As clsMail\r\n    Set objMail = New clsMail\r\n    With objMail\r\n        .AnHinzufuegen Me.EMail\r\n        .Betreff = "Beispielbetreff"\r\n        .Inhalt = "Dies ist eine Beispiel-E-Mail."\r\n        .Senden\r\n    End With\r\nEnd Sub<\/pre>\n
Sie erstellen hier ein neues Objekt auf Basis der Klasse clsMail <\/b>und legen dann die Eigenschaften der zu erstellenden E-Mail fest. Als Betreff und Inhalt weisen Sie entsprechende Platzhaltertexte zu, den Empfänger hingegen als Parameter der Methode ToHinzufuegen<\/b>. Warum das Wir hätten auch einfach eine Eigenschaft namens An <\/b>verwenden können, aber daraus wäre nicht ersichtlich geworden, dass Sie damit nicht nur einen Empfänger, sondern gleich mehrere einfügen können.<\/p>\n
Die Methode Senden <\/b>führt schließlich zum Versand der E-Mail.<\/p>\n
E-Mail vor dem Versenden anzeigen<\/b><\/p>\n
Fügen Sie dem gleichen Formular nun eine zweite Schaltfläche mit dem Text E-Mail erstellen <\/b>hinzu und nennen diese cmdMailErstellen<\/b>. Hinterlegen Sie dafür den folgenden Code:<\/p>\n
Private Sub cmdMailErstellen_Click()\r\n    Dim objMail As clsMail\r\n    Set objMail = New clsMail\r\n    With objMail\r\n        .AnHinzufuegen Me.EMail\r\n        .Betreff = "[Betreff]"\r\n        .Inhalt = "[Inhalt]"\r\n        .Anzeigen\r\n    End With\r\nEnd Sub<\/pre>\n
Diese Prozedur legt ebenfalls eine neue E-Mail an und weist einen Empfänger zu. Allerdings werden Betreff und Inhalt jeweils mit Platzhaltern gefüllt, die vom Benutzer noch durch den gewünschten Text ersetzt werden sollen.<\/p>\n
Damit die Klasse die E-Mail nicht gleich versendet, sondern zuerst anzeigt, rufen Sie diesmal nicht die Senden<\/b>-Methode, sondern die Anzeigen<\/b>-Methode auf.<\/p>\n
Dies öffnet die E-Mail im entsprechenden Editor von Outlook und ermöglicht das manuelle ändern und das anschließende Versenden der E-Mail. Das Ergebnis finden Sie in Bild 2, dort sind auch die Platzhalter für Betreff und Inhalt zu erkennen.<\/p>\n
\"pic002.png\"<\/p>\n
Bild 2: Per VBA erzeugte E-Mail<\/span><\/b><\/p>\n
E-Mails speichern<\/b><\/p>\n
Einen Schritt weiter geht die nächste Anwendung. Die Tabelle tblEMails <\/b>soll Informationen über alle versendeten E-Mails erfassen. Wenn die E-Mails mit der ersten Schaltfläche versendet werden, stehen Betreff und Inhalt bereits fest und können direkt in der Tabelle gespeichert werden.<\/p>\n
Dazu fügen Sie einfach hinter dem Aufruf der Senden-Methode eine entsprechende Anfügeabfrage ein:<\/p>\n
db.Execute ("INSERT INTO tblEMails(KundeID, EMail, Betreff, Inhalt, Versanddatum) VALUES(" _\r\n    & Me!KundeID & ", ''" & Me!EMail & "'', ''" & .Betreff & "'', ''" & .Inhalt & "'', " & IsoDatum(Date) & ")")<\/pre>\n
Wenn der Benutzer die zu versendende E-Mail aber erst anzeigen lässt, danach den Betreff und den Inhalt manuell anpasst und die E-Mail erst dann versendet, wie landen die Daten dann in der Tabelle Immerhin trägt der Benutzer diese Daten nur in der E-Mail ein, nicht in der Datenbank.<\/p>\n
Auch dies ermöglicht die Klasse: Sie trägt die geänderten Inhalte für den Betreff und den Inhalt der E-Mail mit dem Versenden in die entsprechenden Eigenschaften der Klasse clsMail <\/b>ein, sodass Sie diese gleich nach dem Versenden weiterverarbeiten können.<\/p>\n
Wie das aussehen kann, zeigt der Beispielcode aus Listing 1<\/a><\/span>. Der Aufruf der Methode Anzeigen <\/b>hält den Code an, bis der Benutzer die angezeigte Mail versendet (siehe weiter unten). Klickt der Benutzer auf die Senden-Schaltfläche der E-Mail, werden die Inhalte an die Klasse übergeben und können mit den Eigenschaften Betreff <\/b>und Inhalt <\/b>wieder ausgelesen werden. Hier erfolgt die Ausgabe im Direktfenster, bevor die E-Mail-Informationen in der Tabelle tblEMails <\/b>gespeichert werden.<\/p>\n
Listing 1: Weiterverarbeiten der geänderten Inhalte einer E-Mail nach dem Versenden<\/p>\n
Private Sub cmdMailErstellen_Click()\r\n    Dim objMail As clsMail\r\n    Dim db As DAO.Database\r\n    Set objMail = New clsMail\r\n    Set db = CurrentDb\r\n    With objMail\r\n        .AnHinzufuegen Me.EMail\r\n        .Betreff = "[Betreff]"\r\n        .Inhalt = "[Inhalt]"\r\n        .Anzeigen\r\n        Debug.Print .Betreff\r\n        Debug.Print .Inhalt\r\n        db.Execute ("INSERT INTO tblEMails(KundeID, EMail, Betreff, Inhalt, Versanddatum) VALUES(" _\r\n            & Me!KundeID & ", ''" & Me!EMail & "'', ''" & .Betreff & "'', ''" & .Inhalt & "'', " _\r\n            & ISODatum(Date) & ")"), dbFailOnError\r\n    End With\r\n    Set db = Nothing\r\nEnd Sub<\/pre>\n
Versenden mehrerer E-Mails<\/p>\n
Sie können diese Klasse auch nutzen, um E-Mails gleich an mehrere Empfänger zu versenden. Ein Beispiel hierzu finden Sie in Listing 2<\/a><\/span>.<\/p>\n
Listing 2: Versenden mehrerer E-Mails<\/p>\n
Public Function Serienmail()\r\n    Dim db As DAO.Database\r\n    Dim rst As DAO.Recordset\r\n    Dim objMail As clsMail\r\n    Set db = CurrentDb\r\n    Set rst = db.OpenRecordset("SELECT * FROM tblKunden", dbOpenDynaset)\r\n    Set objMail = New clsMail\r\n    Do While Not rst.EOF\r\n        With objMail\r\n            .AnHinzufuegen rst!EMail\r\n            .Betreff = "Betreff"\r\n            .Inhalt = "Inhalt"\r\n            .Senden\r\n            .NeueMail\r\n        End With\r\n        rst.MoveNext\r\n    Loop\r\n    Set objMail = Nothing\r\n    rst.Close\r\n    Set rst = Nothing\r\n    Set db = Nothing\r\nEnd Function<\/pre>\n
Diese Prozedur verwendet die Tabelle tblKunden <\/b>als Datenherkunft für ein Recordset<\/b>-Objekt.<\/p>\n
In einer Do While<\/b>-Schleife durchläuft die Prozedur alle Datensätze dieses Recordsets und versendet darin jeweils eine E-Mail für den aktuellen Datensatz.<\/p>\n
Im Gegensatz zum Versenden einer einzelnen E-Mail müssen Sie nur einen kleinen Unterschied beachten: Nach dem Versenden einer Mail und vor dem dem Versenden der nächsten E-Mail müssen Sie mit der Methode NeueMail eine neue E-Mail erstellen.<\/p>\n
Alternativ können Sie auch das Erstellen der E-Mail mit Set objMail = New clsMail <\/b>in die Schleife verlegen.<\/p>\n
Dies würde jedoch dazu führen, dass für jede E-Mail erneut eine Outlook-Instanz erstellt beziehungsweise eine bestehende Instanz referenziert werden muss – und dies wirkt sich bei vielen E-Mails sicher auf die Performance aus.<\/p>\n
E-Mail blind an mehrere Empfänger<\/b><\/p>\n
Natürlich können Sie auch eine einzige E-Mail gleichzeitig an mehrere verschiedene Empfänger versenden.<\/p>\n
Dazu strukturieren Sie einfach die Befehle der zuvor vorgestellten Prozedur so um, dass nur noch die Zuweisung der BCC<\/b>-Empfängeradressen innerhalb der Schleife liegt:<\/p>\n
Public Function MailAnMehrereBlindeEmpfaenger()\r\n    ...\r\n    Set rst = db.OpenRecordset("SELECT * FROM tblKunden", dbOpenDynaset)\r\n    Set objMail = New clsMail\r\n    With objMail\r\n        .AnHinzufuegen "info@access-basics.de"\r\n        Do While Not rst.EOF\r\n            .BCCHinzufuegen rst!EMail\r\n            rst.MoveNext\r\n        Loop\r\n        .Betreff = "Betreff"\r\n        .Inhalt = "Inhalt"\r\n        .Anzeigen\r\n        .NeueMail\r\n    End With\r\n    ...\r\nEnd Function<\/pre>\n
<\/p>\n
Das Erstellen der E-Mail, das Hinzufügen der übrigen Informationen sowie das Versenden erfolgen außerhalb der Do…While<\/b>-Schleife. Das Ergebnis sieht dann etwa wie in Bild 3 aus.<\/p>\n
\"pic003.png\"<\/p>\n
Bild 3: E-Mail mit mehreren BCC-Empfängern<\/span><\/b><\/p>\n
Absender ändern<\/b><\/p>\n
Gegebenenfalls möchten Sie in einer Anwendung E-Mails mit verschiedenen Absenderadressen versenden.<\/p>\n
In diesem Fall verwenden Sie die Eigenschaft Von <\/b>der Klasse clsEMail<\/b>, um eine alternative Absenderadresse anzugeben.<\/p>\n
Bedenken Sie, dass Sie nur solche Absenderadressen angeben können, für die in Outlook entsprechende Konten angelegt sind.<\/p>\n
Gesendete E-Mail in bestimmten Ordner verschieben<\/p>\n
Gegebenenfalls möchsten Sie eine E-Mail nach dem Versenden nicht im Standardordner Gesendete Objekte speichern, sondern in einem benutzerdefinierten Ordner unterhalb dieses Ordners.<\/p>\n
Dann geben Sie einfach für die Eigenschaft Zielordner <\/b>des Objekts objMail <\/b>den Namen des Ordners an – beispielsweise wie in folgendem Beispiel:<\/p>\n
Public Function MailInBestimmtenOrdner()\r\n    Dim objMail As clsMail\r\n    Set objMail = New clsMail\r\n    With objMail\r\n        .AnHinzufuegen "info@access-im-unternehmen.de"\r\n        .Betreff = "Betreff"\r\n        .Inhalt = "Inhalt"\r\n        .Zielordner = "test"\r\n        .Senden\r\n    End With\r\n    Set objMail = Nothing\r\nEnd Function<\/pre>\n
Wenn sich der gewünschte Zielordner nicht direkt unter dem Gesendete Objekt<\/b>-Ordner befindet, trennen Sie die Unterordner durch Schrägstriche:<\/p>\n
.Zielordner = "test\/test\/test"<\/pre>\n
Dies legt dann, soweit noch keiner der Ordner vorhanden ist, gleich drei verschachtelte Ordner an.<\/p>\n
Aufbau der Klasse clsMail<\/b><\/p>\n
Schauen wir uns nun an, wie die Klasse clsEMail <\/b>aufgebaut ist und wie diese funktioniert. Wenn Sie die Klasse selbst nachbauen möchten, erstellen Sie zunächst ein entsprechendes Klassenmodul mit dem Befehl Einfügen|Klassenmodul <\/b>des VBA-Editors und speichern Sie dieses unter dem Namen clsMail<\/b>.<\/p>\n
Beim Initialisieren der Klasse etwa mit der Anweisung <\/p>\n
Set objMail = New clsMail<\/pre>\n
wird in dieser Klasse gleich das Initialize<\/b>-Ereignis ausgelöst, das mit folgender Ereignisprozedur implementiert wurde:<\/p>\n
Private Sub Class_Initialize()\r\n    Set objOutlook = New Outlook.Application\r\n    Set objMail = objOutlook.CreateItem(olMailitem)\r\nEnd Sub<\/pre>\n
Diese Prozedur erzeugt zunächst eine neue Instanz von Outlook beziehungsweise referenziert eine bestehende Instanz mit der Objektvariablen objOutlook<\/b>, die wie folgt im Kopf des Klassenmoduls deklariert wird:<\/p>\n
Private objOutlook As Outlook.Application<\/pre>\n
Das ebenfalls in dieser Prozedur erzeugte MailItem-Objekt wird wie folgt deklariert:<\/p>\n
Private WithEvents objMail As Outlook.MailItem<\/pre>\n
Das Schlüsselwort WithEvents <\/b>sorgt dafür, dass Sie die Ereignisse des MailItem<\/b>-Objekts im vorliegenden Klassenmodul implementieren können. Wozu dies nötig ist, erfahren Sie weiter unten.<\/p>\n
E-Mail mit Daten füllen<\/b><\/p>\n
Für eine E-Mail gibt es verschiedene Arten von Informationen. Betreff und Inhalt etwa nehmen einfache Texte auf, die einfach einer entsprechenden Eigenschaft der Klasse clsMail <\/b>zugewiesen werden sollen.<\/p>\n
Dazu legen Sie für die beiden Eigenschaften Betreff <\/b>und Inhalt <\/b>die folgenden Public Property Let<\/b>-Prozeduren an:<\/p>\n
Public Property Let Inhalt(strBody As String)\r\n    objMail.Body = strBody\r\nEnd Property\r\nPublic Property Let Betreff(strSubject As String)\r\n    objMail.Subject = strSubject\r\nEnd Property<\/pre>\n
Beim Absender sieht dies ähnlich aus. Allerdings wird dieser nicht einfach einer Eigenschaft zugewiesen wir der Empfänger.<\/p>\n
Stattdessen muss die dazu vorgesehene Property Let<\/b>-Prozedur die in Outlook verfügbaren Accounts dahingehend prüfen, ob einer der Accounts mit der übergebenen E-Mail-Adresse ausgestattet ist.<\/p>\n
Dies geschieht durch Durchlaufen aller vorhandenen Account<\/b>-Objekte und der Prüfung, ob deren Eigenschaft SmtpAdress <\/b>mit der übergebenen E-Mail-Adresse übereinstimmt.<\/p>\n
Ist dies der Fall, wird die Eigenschaft SendUsingAccount <\/b>für das MailItem<\/b>-Objekt auf das entsprechende Account<\/b>-Objekt eingestellt:<\/p>\n
Public Property Let Von(strFrom As String)\r\n    Dim objAccount As Outlook.Account\r\n    For Each objAccount In _\r\n         objOutlook.Session.Accounts\r\n        If objAccount.SmtpAddress = strFrom Then\r\n            objMail.SendUsingAccount = objAccount\r\n            Exit Property\r\n        End If\r\n    Next objAccount\r\n    m_Von = strFrom\r\n    MsgBox "Outlook-Account mit der Mailadresse ''" & strFrom & "'' nicht gefunden."<\/pre>\n
End Property <\/p>\n
Absender, Empfänger und Attachments hinzufügen<\/b><\/p>\n
Bei Absender und Empfänger (To<\/b>, CC<\/b>, BCC<\/b>) sollte man meinen, dass dies ebenso abläuft. Allerdings kann man ja für jede dieser Eigenschaften mehrerer Empfänger zuweisen.<\/p>\n
Damit dies nicht zu Problemen führt, weil die Daten mit dem falschen Trennzeichen übergeben werden, sollen die drei Methoden AnHinzufuegen<\/b>, CCHinzufuegen <\/b>und BCCHinzufuegen <\/b>jeweils eine Adresse entgegennehmen und diese per Semikolon getrennt an die gegebenenfalls bereits vorhandenen in den Eigenschaften To<\/b>, CC <\/b>und BCC <\/b>gespeicherten Werte anhängen:<\/p>\n
Public Sub AnHinzufuegen(strTo As String)\r\n    objMail.To = objMail.To & ";" & strTo\r\nEnd Sub\r\nPublic Sub CCHinzufuegen(strCC As String)\r\n    objMail.CC = objMail.CC & ";" & strCC\r\nEnd Sub\r\nPublic Sub BCCHinzufuegen(strBCC As String)\r\n    objMail.BCC = objMail.BCC & ";" & strBCC\r\nEnd Sub<\/pre>\n
Anhang hinzufügen<\/b><\/p>\n
Auch Anhänge müssen separat hinzugefügt werden. Dies gelingt mit der Methode AnhangHinzufuegen<\/b>, die schlicht den Dateinamen der hinzuzufügenden Datei erwartet und diesen der Add<\/b>-Methode der Attachments<\/b>-Auflistung des MailItem<\/b>-Objekts übergibt:<\/p>\n
Public Sub AnhangHinzufuegen(strAttachment As String)\r\n    objMail.Attachments.Add strAttachment\r\nEnd Sub<\/pre>\n
Empfangsbestätigung und Priorität<\/b><\/p>\n
Die beiden Eigenschaften Empfangsbestaetigung<\/b> und Wichtigkeit <\/b>hingegen werden durch einfache Property Let<\/b>-Prozeduren implementiert. Empfangsbestaetigung <\/b>erwartet einen Boolean<\/b>-Wert, der angibt, ob eine Empfangsbestätigung angefordert werden soll. Dieser Wert wird an die Eigenschaft ReadReceiptRequested <\/b>des MailItem<\/b>-Objekts übergeben:<\/p>\n
Public Property Let Empfangsbestaetigung(bolReadReceiptRequested As Boolean)\r\n    objMail.ReadReceiptRequested = bolReadReceiptRequested\r\nEnd Property<\/pre>\n
Bei der Priorität wird hingegen ein Integer<\/b>-Wert übergeben, der einem der Werte der Enumeration olImportance <\/b>entspricht (mit den Werten olImportanceHigh<\/b>, olImportanceLow<\/b>, olImportanceNormal<\/b>). Dieser landet in der Eigenschaft Importance<\/b>:<\/p>\n
Public Property Let Wichtigkeit(intImportance As OlImportance)\r\n    objMail.Importance = intImportance\r\nEnd Property<\/pre>\n
Zielordner für gesendete E-Mails festlegen<\/b><\/p>\n
Mit der Public Property Let<\/b>-Prozedur Zielordner <\/b>können Sie den Ordner festlegen, in dem die gesendete Nachricht gespeichert werden soll. Normalerweise landen diese ja einfach im Gesendete Objekte-Ordner. Wer ein wenig Ordnung liebt, speichert etwa alle E-Mails, die an Kunden versendet wurden, gleich in einem anderen Ordner unter Outlook.<\/p>\n
Die Prozedur aus Listing 3<\/a><\/span> erwartet den Namen des Zielordners als Parameter. Sie stellt zunächst das Folder<\/b>-Objekt objOrdnerGesendet <\/b>auf den Standardordner für gesendete E-Mails ein.<\/p>\n
Listing 3: Festlegen des Zielordners für gesendete Objekte<\/p>\n
Public Property Let Zielordner(strFolder As String)\r\n    Dim objOrdnerGesendet As Outlook.Folder\r\n    Dim objOrdnerZiel As Outlook.Folder\r\n    Dim i As Integer\r\n    Set objOrdnerGesendet = objOutlook.Session.GetDefaultFolder(olFolderSentMail)\r\n    On Error Resume Next\r\n    Set objOrdnerZiel = objOrdnerGesendet.Folders(strFolder)\r\n    If objOrdnerZiel Is Nothing Then\r\n         Set objOrdnerZiel = objOrdnerGesendet\r\n        For i = LBound(Split(strFolder, "\/")) To UBound(Split(strFolder, "\/"))\r\n            Set objOrdnerZiel = objOrdnerZiel.Folders.Add(Split(strFolder, "\/")(i))\r\n            Set objOrdnerZiel = objOrdnerZiel.Folders(Split(strFolder, "\/")(i))\r\n        Next i\r\n    End If\r\n    On Error GoTo 0\r\n    Set objMail.SaveSentMessageFolder = objOrdnerZiel\r\nEnd Property<\/pre>\n
Danach versucht sie, den angegebenen Unterordner direkt zu referenzieren. Gelingt dies nicht, löst dies normalerweise einen Fehler aus, der aber durch das vorherige Deaktivieren der Fehlerbehandlung ausbleibt.<\/p>\n
Dafür bleibt dann zumindest die Variable objOrdnerZiel <\/b>leer, welcher der gesuchte Ordner zugewiesen werden sollte.<\/p>\n
Ist der Ordner noch nicht vorhanden, legt die Prozedur alle Unterordner an – oder versucht es zumindest.<\/p>\n
Wenn etwa der Ordner test\/test\/test <\/b>erzeugt werden soll, legt die ermittelt die Prozedur zunächst den obersten anzulegenden Ordner in der Hierarchie und erzeugt diesen.<\/p>\n
Ob dies scheitert, weil der Ordner bereits vorhanden ist, spielt keine Rolle – in diesem Fall wird der bereits vorhandene Ordner referenziert.<\/p>\n
Weitere E-Mail anlegen<\/b><\/p>\n
Wie bereits in den Beispielen gezeigt, können Sie mit der Klasse auch mehrere E-Mails versenden, ohne die Klasse jedes Mal neu zu instanzieren und somit auch die Outlook-Instanz erneut zu instanzieren beziehungsweise eine vorhandene Instanz zu referenzieren. Dazu müssen Sie nur die Methode NeueMail <\/b>der aktiven Instanz der Klasse clsMail <\/b>aufrufen, die wie folgt aussieht und schlicht ein neues MailItem<\/b>-Objekt erstellt:<\/p>\n
Public Sub NeueMail()\r\n    Set objMail = Nothing\r\n    Set objMail = objOutlook.CreateItem(olMailitem)\r\nEnd Sub<\/pre>\n
E-Mail senden oder anzeigen<\/b><\/p>\n
Normalerweise werden Sie eine E-Mail gleich versenden wollen. Dies erledigen Sie mit der Senden-Methode, die wie folgt implementiert ist:<\/p>\n
Public Sub Senden()\r\n    objMail.Send\r\n    m_Gesendet = True\r\nEnd Sub<\/pre>\n
Diese Methode stellt nach dem Versenden die in der privat deklarierten Variablen gespeicherte Eigenschaft Gesendet <\/b>auf den Wert True <\/b>ein.<\/p>\n
Manchmal möchsten Sie sich aber vielleicht nur die Arbeit vereinfachen und eine E-Mail aus der Anwendung heraus mit dem passenden Adressaten und gegebenenfalls einer Betreff\/Inhaltsvorlage versehen, um diese vor dem Versenden noch zu bearbeiten. Dann zeigen Sie die E-Mail einfach nur an, und zwar mit der Anzeigen<\/b>-Methode:<\/p>\n
Public Sub Anzeigen()\r\n    objMail.Display True\r\nEnd Sub<\/pre>\n
Die E-Mail wird in Outlook geöffnet und angezeigt, der Code wird solange angehalten, bis die E-Mail durch Anklicken der Senden<\/b>-Schaltfläche auf den Weg gebracht wurde.<\/p>\n
Schließlich löst die Klasse beim Zerstören (beispielsweise mit Set objMail = Nothing<\/b>) noch die folgende Ereignisprozedur aus:<\/p>\n
Private Sub Class_Terminate()\r\n    Set objMail = Nothing\r\n    Set objOutlook = Nothing\r\nEnd Sub<\/pre>\n
Dies leert schlicht die Objektvariablen objMail <\/b>und objOutlook<\/b>.<\/p>\n
Maildaten nach dem Versenden speichern<\/b><\/p>\n
Die mit den Eigenschaften beziehungsweise Methoden der Klasse clsMail <\/b>zugewiesenen Daten werden immer direkt an das durch die Klasse erzeugte MailItem<\/b>-Objekt weitergeleitet. Dennoch benötigen wir einige privat deklarierte Variablen. Wozu Nun: Die Klasse soll die gegebenenfalls nach dem Anzeigen und vor dem Versenden geänderten Inhalte der E-Mail für die weitere Verwendung bereithalten.<\/p>\n
Da wir nach dem Versenden keinen Zugriff mehr auf die E-Mail mehr haben, speichern wir diese vor dem Versenden in den folgenden Variablen:<\/p>\n
Private m_Subject As String\r\nPrivate m_Body As String\r\nPrivate m_Von As String\r\nPrivate m_To As String\r\nPrivate m_CC As String\r\nPrivate m_BCC As String\r\nPrivate m_EntryID As String\r\nPrivate m_Gesendet As Boolean<\/pre>\n
Die entsprechenden, für die Abfrage der Werte dieser privat deklarierten Variablen vorgesehenen Property Get<\/b>-Prozeduren sehen wie folgt aus:<\/p>\n
Public Property Get Gesendet() As Boolean\r\n    Gesendet = m_Gesendet\r\nEnd Property\r\nPublic Property Get An() As String\r\n    An = m_To\r\nEnd Property\r\nPublic Property Get BCC() As String\r\n    BCC = m_BCC\r\nEnd Property\r\nPublic Property Get MailItem() As MailItem\r\n    Set MailItem = objMail\r\nEnd Property\r\nPublic Property Get Inhalt() As String\r\n    Inhalt = m_Body\r\nEnd Property\r\nPublic Property Get Betreff() As String\r\n    Betreff = m_Subject\r\nEnd Property\r\nPublic Property Get MailID() As String\r\n    MailID = m_EntryID\r\nEnd Property\r\nPublic Property Get Von() As String\r\n    Von = m_Von\r\nEnd Property\r\nPublic Property Get CC() As String\r\n    CC = m_CC\r\nEnd Property<\/pre>\n
Wie aber können Sie dafür sorgen, dass die Daten genau beim Versenden der E-Mail in diese Variablen geschrieben werden Dies erledigen Sie mit einer Ereignisprozedur, die durch das Ereignis Send des MailItem<\/b>-Objekts ausgelöst wird:<\/p>\n
Private Sub objMail_Send(Cancel As Boolean)\r\n    m_Body = objMail.Body\r\n    m_Subject = objMail.Subject\r\n    m_EntryID = objMail.EntryID\r\n    m_Von = objMail.Recipients.Item(1).Address\r\n    m_To = objMail.To\r\n    m_CC = objMail.CC\r\n    m_BCC = objMail.BCC\r\n    m_Gesendet = True\r\nEnd Sub<\/pre>\n
Einschränkungen mit älteren Outlook-Versionen<\/b><\/p>\n
Zwischen den einzelnen Outlook-Versionen gibt es einige Unterschiede, die dafür sorgen, dass die Klasse in Access-Versionen älter als 2010 nicht wie hier beschrieben eingesetzt werden kann.<\/p>\n
Sie erhalten jedoch Informationen, welche änderungen nötig sind, damit die Klasse auch in Access 2007 und älter funktioniert.<\/p>\n