![\"Verweis](\"..\/fileadmin\/_temp_\/2022_03\/pic_1364_001.png\")
<\/p>\nZum Verwenden von Serienmails nutzt man meist Outlook und schreibt eine Mail an sich selbst, w\u00e4hrend man die Empf\u00e4nger dann m\u00f6glichst dem Feld BCC hinzuf\u00fcgt. Auf diese Weise bleibt der Datenschutz gewahrt, denn Sie wollen ja nicht jedem Empf\u00e4nger die E-Mail-Adressen aller anderen Empf\u00e4nger der Serienmail mitteilen. Der Nachteil ist, dass Sie so noch nicht einmal einfache Individualisierungen realisieren k\u00f6nnen wie etwa eine pers\u00f6nliche Anrede. Wenn Sie das erledigen wollen, versenden Sie per Automation aus einer Datenbank Nachrichten \u00fcber Outlook. Falls das nicht in Frage kommt, weil beispielsweise Outlook nicht auf dem Rechner installiert ist, k\u00f6nnen Sie noch eine Alternative nutzen, n\u00e4mlich die Bibliothek CDO. Im Beitrag „E-Mails versenden mit CDO“ haben wir bereits die grundlegenden Techniken zum E-Mail-Versand mit dieser Bibliothek vorgestellt. Nun gehen wir einen Schritt weiter und zeigen, wie das auch noch f\u00fcr Serienmails gelingt.<\/b><\/p>\nVorbereitung f\u00fcr den Einsatz der CDO-Bibliothek<\/h2>\n
Damit Sie die CDO-Bibliothek mit den Objekten und Methoden zum Versenden von E-Mails nutzen k\u00f6nnen, ben\u00f6tigen Sie einen Verweis auf diese Bibliothek. Diesen f\u00fcgen Sie \u00fcber den Verweise<\/b>-Dialog hinzu, den Sie vom VBA-Editor aus \u00f6ffnen. Hier w\u00e4hlen Sie den Men\u00fceintrag Extras|Verweise <\/b>und w\u00e4hlen dann im erscheinenden Dialog Verweise<\/b> den Eintrag Microsoft CDO for Windows 2000 Library <\/b>aus (siehe Bild 1).<\/p>\n
<\/p>\n
Bild 1: Verweis auf die CDO-Bibliothek<\/span><\/b><\/p>\n Um die hier vorgestellten Techniken nutzen zu k\u00f6nnen, ben\u00f6tigen Sie zumindest eine Tabelle mit den Daten der E-Mail-Empf\u00e4nger. Diese sollte im besten Fall die Felder Anrede<\/b>, Vorname<\/b>, Nachname <\/b>und E-Mail-Adresse<\/b> enthalten.<\/p>\n Wir haben eine solche Tabelle wie in Bild 2 definiert. Das dortige Feld AnredeID<\/b> ist ein Fremdschl\u00fcsselfeld, mit dem Sie die Datens\u00e4tze der Tabelle tblAnreden <\/b>ausw\u00e4hlen k\u00f6nnen. Diese enth\u00e4lt neben dem Prim\u00e4rschl\u00fcsselfeld AnredeID<\/b> noch das Feld Anrede <\/b>mit der Bezeichnung der Anrede sowie ein weiteres Feld namens Mailanrede, das wir mit einer Anrede speziell f\u00fcr die E-Mails gef\u00fcllt haben.<\/p>\n Bild 2: Beispieltabelle f\u00fcr Kundendaten im Entwurf<\/span><\/b><\/p>\n Diese Tabelle sieht mit den Daten f\u00fcr die Anreden Herr<\/b> und Frau <\/b>wie in Bild 3 aus.<\/p>\n Bild 3: Tabelle mit den Anreden<\/span><\/b><\/p>\n Die Tabelle tblKunden <\/b>haben wir mit den Techniken aus dem Beitrag Beispieldaten generieren mit .NET und Bogus <\/b>(www.access-im-unternehmen.de\/1359<\/b>) gef\u00fcllt. Die Tabelle sieht anschlie\u00dfend wie in Bild 4 aus. Wir werden sp\u00e4ter nur die ersten zwei, drei Datens\u00e4tze, um testweise E-Mails zu versenden. Diesen f\u00fcgen wir daher tats\u00e4chlich vorhandene E-Mail-Adressen hinzu, bei denen wir auch pr\u00fcfen k\u00f6nnen, ob diese angekommen sind.<\/p>\n Bild 4: Tabelle mit den aufgef\u00fcllten Datens\u00e4tzen<\/span><\/b><\/p>\n Im Beitrag E-Mails versenden mit CDO <\/b>(www.access-im-unternehmen.de\/1363<\/b>) haben wir die Daten f\u00fcr den Zugriff auf den SMTP-Server, der f\u00fcr den Mailversand verwendet werden soll, direkt in den Code geschrieben.<\/p>\n Das wollen wir in diesem Beitrag direkt ein wenig professioneller gestalten und die Daten in einer Tabelle unterbringen, deren Inhalte wir dann \u00fcber ein Formular anpassen k\u00f6nnen.<\/p>\n Die Tabelle finden Sie in der Entwurfsansicht in Bild 5. Sie nimmt neben dem Prim\u00e4rschl\u00fcsselfeld zun\u00e4chst ein Feld zum Speichern der Bezeichnung eines Satzes von SMTP-Server-Daten auf. Danach folgen die Felder f\u00fcr die Adresse des SMTP-Servers, f\u00fcr den Benutzernamen und das Kennwort, unter dem die Anmeldung erfolgen soll, sowie gegebenenfalls der Port.<\/p>\n Bild 5: Tabelle zum Speichern der SMTP-Konfiguration<\/span><\/b><\/p>\n Zus\u00e4tzlich programmieren wir eine Funktion, der wir nur noch den Prim\u00e4rschl\u00fcsselwert der zu liefernden Konfiguration \u00fcbergeben. Diese soll dann ein fertiges Configuration<\/b>-Objekt auf Basis der Daten aus dem entsprechenden Datensatz der Tabelle zur\u00fcckliefern.<\/p>\n Diese Funktion sieht wie in Listing 1 aus. Sie erwartet den Parameter lngConfigurationID <\/b>und liefert ein Objekt des Typs Configuration <\/b>zur\u00fcck. Sie erzeugt ein Database<\/b>-Objekt auf Basis der aktuellen Datenbank und ein Recordset mit dem Datensatz der Tabelle tblConfigurations<\/b>, dessen Wert im Feld ConfigurationID <\/b>dem mit lngConfiguration-ID <\/b>\u00fcbergebenen Parameter entspricht.<\/p>\n Listing 1: Funktion zum Ermitteln eines Configuration-Objekts<\/span><\/b><\/p>\n Aus diesem Recordset liest die Funktion die einzelnen Feldwerte aus und schreibt diese in die Variablen strSMTPServer<\/b>, strPort<\/b>, strUsername <\/b>und strPassword<\/b>. Dann erstellt sie ein neues Objekt des Typs CDO.Configuration <\/b>und weist den Eigenschaften dieses Objekts die Werte aus den Textfeldern zu – neben einigen Werten f\u00fcr Eigenschaften, die immer gleich sind wie etwa f\u00fcr cboSendUsingMethode<\/b>, cdoSMTPUserSSL <\/b>oder cdoSMTP-Authenticate<\/b>. Nachdem alle relevanten Eigenschaften gef\u00fcllt sind, gibt die Funktion das mit objConfiguration <\/b>referenzierte Objekt als Ergebnis zur\u00fcck.<\/p>\n In der L\u00f6sung aus dem Beitrag E-Mails senden mit CDO <\/b>(www.access-im-unternehmen.de\/1363<\/b>) haben wir das Zusammenstellen des Configuration<\/b>-Objekts und des Message<\/b>-Objekts, das zum Versenden einer E-Mail dient, in einer Prozedur erstellt. Das ist beim Versand einer Serienmail nicht sinnvoll – wenn immer der gleiche SMTP-Server mit den gleichen Anmeldedaten zum Einsatz kommt, brauchen wir nicht f\u00fcr jede E-Mail erneut ein Configuration<\/b>-Objekt zu erstellen. Wenn wir also gleich eine Prozedur programmieren, mit der wir die Empf\u00e4nger der E-Mail durchlaufen, wird dies ber\u00fccksichtigen werden. Diese Daten speichern wir in der Tabelle tblMailings <\/b>aus Bild 6. Neben den genannten Daten nimmt diese Tabelle nur noch ein Prim\u00e4rschl\u00fcsselfeld auf sowie ein Feld f\u00fcr die Bezeichnung des Mailings. F\u00fcr das Feld Mailingname<\/b> haben wir einen eindeutigen Index festgelegt, damit wir die Mailings danach unterscheiden k\u00f6nnen.<\/p>\n Bild 6: Tabelle zum Speichern der Daten eines Mailings<\/span><\/b><\/p>\n Sie k\u00f6nnen der Tabelle noch beliebige weitere Felder hinzuf\u00fcgen – beispielsweise f\u00fcr das Datum, an dem das Mailing verschickt werden soll oder Sie speichern darin Informationen dar\u00fcber, welche Tabelle f\u00fcr das Zusammenstellen der Empf\u00e4nger verwendet wurde und nach welchen Kriterien diese Zusammenstellung erfolgte.<\/p>\n Ein Beispiel f\u00fcr die allgemeinen Daten eines Mailing k\u00f6nnen Sie Bild 7 entnehmen.<\/p>\n Bild 7: Tabelle zum Speichern der Daten eines Mailings mit Beispieldaten<\/span><\/b><\/p>\n Die Prozedur aus Listing 2 \u00fcbernimmt die Steuerung des Mailversands. Sie erwartet die folgenden Parameter:<\/p>\n Listing 2: Prozedur zum Steuern des Mailversands<\/span><\/b><\/p>\n Die Prozedur erstellt ein Database<\/b>-Objekt namens db <\/b>mit einem Verweis auf die aktuelle Datenbank. Dann holt sie mit der bereits vorgestellten Funktion GetConfiguration <\/b>das Configuration<\/b>-Objekt f\u00fcr die ID aus lngConfiguration-ID<\/b>.<\/p>\n Dann f\u00fcllt sie ein Recordset namens rstMailing <\/b>mit den Daten des Datensatzes der Tabelle tblMailings<\/b>, dessen Prim\u00e4rschl\u00fcsselwert mit lngMailingID <\/b>\u00fcbereinstimmt. Aus diesem liest sie die Daten f\u00fcr die Variablen strFrom<\/b>, strSubject<\/b>, strTextBody <\/b>und strAttachments <\/b>aus.<\/p>\n Dann \u00f6ffnet sie ein weiteres Recordset auf Basis der mit strSQLTo <\/b>\u00fcbermittelten Abfrage. Diese k\u00f6nnte beispielsweise wie folgt lauten:<\/p>\n In diesem Fall liefert das Recordset nur einen einzigen Datensatz, was zu Testzwecken aber ausreicht. Die Datens\u00e4tze dieses Recordsets durchl\u00e4uft die Prozedur dann in einer Do While<\/b>-Schleife. Innerhalb dieser Schleife liest die Prozedur die E-Mail-Adresse des Empf\u00e4ngers der E-Mail aus dem Feld aus strMailfield <\/b>in die Variable strTo <\/b>ein.<\/p>\n Damit hat die Prozedur alle Informationen zusammen, um eine weitere Prozedur namens SendMailing <\/b>aufzurufen, welche die eigentliche Arbeit erledigt – n\u00e4mlich den Versand der E-Mail.<\/p>\n Auf diese Weise werden E-Mails an alle Eintr\u00e4ge der Empf\u00e4ngerliste verschickt.<\/p>\n Die Prozedur SendMailing <\/b>erwartet die folgenden Parameter (siehe Listing 3):<\/p>\n Listing 3: Prozedur zum Versenden einer E-Mail<\/span><\/b><\/p>\n Die Prozedur erstellt ein neues Objekt des Typs CDO.Message <\/b>und referenziert dieses mit der Variablen objMessage<\/b>. Danach stellt es einige Eigenschaften f\u00fcr dieses Objekt ein. Das Objekt aus dem Parameter objConfiguration <\/b>landet in der Eigenschaft Configuration<\/b>, strTo <\/b>in der Eigenschaft To<\/b>, strFrom <\/b>in der Eigenschaft From <\/b>sowie strSubject <\/b>und strTextbody <\/b>in den Eigenschaften Subject <\/b>und Textbody<\/b>.<\/p>\n Sollte beim Aufruf ein Wert f\u00fcr strBCC <\/b>\u00fcbergeben worden sein, landet dieser in der Eigenschaft BCC<\/b>.<\/p>\n Hat strAttachments <\/b>nicht die L\u00e4nge 0<\/b>, teilen wir die durch Semikola getrennten Abschnitte mit der Split<\/b>-Funktion in ein Array auf und durchlaufen dieses in einer For Each<\/b>-Schleife. Darin weist sie die einzelnen Elemente mit der AddAttachment<\/b>-Methode dem Message<\/b>-Objekt zu.<\/p>\n Schlie\u00dflich sendet die Prozedur die E-Mail mit der Send<\/b>-Methode ab und pr\u00fcft bei deaktivierter Fehlerbehandlung noch, ob dabei ein Fehler aufgetreten ist.<\/p>\n Den Aufruf der Prozedur SendMailing <\/b>haben wir, wie oben beschrieben, in die Prozedur Serienmail <\/b>untergebracht. Diese rufen wir beispielsweise wie folgt auf:<\/p>\n Das bedeutet, dass wir die Konfiguration mit dem Wert 1 <\/b>im Feld ConfigurationID <\/b>aus der Tabelle tblConfigurations <\/b>verwenden, um das Mailing mit dem Wert 1 <\/b>im Feld MailingID <\/b>aus der Tabelle tblMailings <\/b>zu versenden. Als Empf\u00e4nger verwenden wir die Daten aus der mit SELECT * FROM tblKunden WHERE KundeID = 1 <\/b>angegebenen Datenquelle, wobei wir dem Feld EMail <\/b>die Empf\u00e4ngeradressen entnehmen.<\/p>\n Das gelingt auch, wie die anschlie\u00dfend empfangene E-Mail aus Bild 8 best\u00e4tigt.<\/p>\n Bild 8: Eine versendete Beispiel-E-Mail<\/span><\/b><\/p>\n Allerdings sehen wir hier noch eine offene Aufgabe. Wir haben im Feld TextBody <\/b>der Tabelle einen Inhalt mit Platzhaltern gespeichert:<\/p>\n Diese sollten nat\u00fcrlich noch durch entsprechende Daten ersetzt werden – in der soeben versendeten E-Mail finden wir noch den Platzhaltertext vor. Dazu legen wir eine weitere Funktion namens ReplacePlaceholders <\/b>mit den folgenden Parametern an:<\/p>\n Den Aufruf dieser Funktion platzieren wir in der Prozedur Serienmail innerhalb der For…Next<\/b>-Schleife, welche die Eintr\u00e4ge der Kundentabelle mit den Empf\u00e4ngerdaten durchl\u00e4uft. Dort rufen wir die Funktion ReplacePlaceholders <\/b>auf und \u00fcbergeben den Inhalt aus strTextBody <\/b>sowie das Recordset rstTo<\/b>, dessen Datensatzzeiger auf den aktuell zu verwendenden Kundendatensatz verweist (siehe Listing 4).<\/p>\n Listing 4: Erweiterung der Prozedur Serienmail<\/span><\/b><\/p>\n Die Funktion ReplacePlaceholders <\/b>finden Sie schlie\u00dflich in Listing 5. Die Funktion deklariert eine Field<\/b>-Variable namens fld<\/b>. Diese nutzen wir, um alle Field<\/b>-Elemente der Fields<\/b>-Auflistung des mit rst <\/b>\u00fcbergebenen Recordsets zu durchlaufen. \u00dcber die Field<\/b>-Elemente haben wir Zugriff auf zwei wichtige Eigenschaften f\u00fcr den aktuellen Datensatz: Wir k\u00f6nnen mit der Name<\/b>-Eigenschaft den Namen des Feldes ermitteln und mit der Value<\/b>-Eigenschaft den Inhalt des jeweiligen Feldes. In der For Each<\/b>-Schleife durchlaufen wir also alle Felder des \u00fcbergebenen Recordsets wie Vorname<\/b>, Nachname<\/b>, EMail <\/b>und so weiter.<\/p>\n Listing 5: Funktion zum Ersetzen von Platzhaltern<\/span><\/b><\/p>\n Innerhalb der For Each<\/b>-Schleife ersetzen wir mit der Replace<\/b>-Funktion in strTextbody<\/b> eine Zeichenkette, die aus einer \u00f6ffnenden eckigen Klammer, dem Feldnamen und und einer schlie\u00dfenden eckigen Klammer besteht, durch den Wert des Feldes f\u00fcr diesen Datensatz. Wir suchen also beispielsweise nach der Zeichenkette [Nachname<\/b>] und ersetzen diese durch den tats\u00e4chlichen Nachnamen des aktuellen Datensatzes. Auf diese Weise ersetzen wir alle Platzhalter, deren Bezeichnung einem der Felder des Recordsets entspricht.<\/p>\n Im ersten Versuch mit dem obigen Aufruf gelingt das noch nicht vollst\u00e4ndig, denn hier wird nur der Platzhalter [Nachname] <\/b>ersetzt. Das ist leicht nachvollziehbar, denn unser \u00fcbergebener SQL-Ausdruck enth\u00e4lt gar kein Feld namens Mailanrede<\/b>. Diese finden wir erst in der mit der Tabelle tblKunden <\/b>verkn\u00fcpften Tabelle tblAnreden<\/b>. Wir m\u00fcssen also schlicht die Datenquelle f\u00fcr die Serienmail erweitern, indem wir die Tabelle tblAnreden <\/b>hinzunehmen. Der Aufruf sieht dann wie folgt aus:<\/p>\nVorbereiten der Datenbank<\/h2>\n
![\"Beispieltabelle](\"..\/fileadmin\/_temp_\/2022_03\/pic_1364_002.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2022_03\/pic_1364_003.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2022_03\/pic_1364_004.png\")
<\/p>\nSpeichern der SMTP-Konfiguration<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2022_03\/pic_1364_005.png\")
<\/p>\nAuslesen der Konfiguration und Erstellen eines Configuration-Objekts<\/h2>\n
Public Function <\/span>GetConfiguration(lngConfigurationID As Long<\/span>) As <\/span>CDO.Configuration\r\n Dim <\/span>objConfiguration As <\/span>CDO.Configuration\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strSMTPServer As String<\/span>\r\n Dim <\/span>strPort As String<\/span>\r\n Dim <\/span>strUsername As String<\/span>\r\n Dim <\/span>strPassword As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblConfigurations WHERE ConfigurationID = \" & lngConfigurationID, _\r\n dbOpenDynaset)\r\n strSMTPServer = rst!SMTPServer\r\n strPort = Nz(rst!Port, \"\")\r\n strUsername = rst!UserName\r\n strPassword = rst!Password\r\n Set<\/span> objConfiguration = New<\/span> CDO.Configuration\r\n With<\/span> objConfiguration\r\n .Fields(cdoSendUsingMethod).Value = cdoSendUsingPort\r\n .Fields(cdoSMTPServer).Value = strSMTPServer\r\n Debug.Print<\/span> .Fields(cdoSMTPServerPort)\r\n If <\/span>Not<\/span> Len<\/span>(strPort) = 0 Then<\/span>\r\n .Fields(cdoSMTPServerPort).Value = strPort\r\n End If<\/span>\r\n .Fields(cdoSMTPUseSSL).Value = \"true\"\r\n .Fields(cdoSMTPAuthenticate).Value = cdoBasic\r\n .Fields(cdoSendUserName).Value = strUsername\r\n .Fields(cdoSendPassword).Value = strPassword\r\n .Fields.Update\r\n End With<\/span>\r\n Set<\/span> GetConfiguration = objConfiguration\r\nEnd Function<\/span><\/pre>\nSerien-E-Mails verschicken<\/h2>\n
\nF\u00fcr das Versenden einer Serienmail ben\u00f6tigen wir noch einige Daten, die wir am Besten auch direkt in einer eigenen Tabelle speichern. Dabei handelt es sich um die Daten, die f\u00fcr jede Mail eines Mailings gleich sind, also:<\/p>\n\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2022_03\/pic_1364_006.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2022_03\/pic_1364_007.png\")
<\/p>\nProzedur zum Steuern des Mailversands<\/h2>\n
Public Sub <\/span>Serienmail(lngConfigurationID As Long<\/span>, lngMailingID As Long<\/span>, strSQLTo As String<\/span>, strMailfield As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstMailing As <\/span>DAO.Recordset\r\n Dim <\/span>rstTo As <\/span>DAO.Recordset\r\n Dim <\/span>strTo As String<\/span>\r\n Dim <\/span>strFrom As String<\/span>\r\n Dim <\/span>strSubject As String<\/span>\r\n Dim <\/span>strTextbody As String<\/span>\r\n Dim <\/span>strAttachments As String<\/span>\r\n Dim <\/span>objConfiguration As <\/span>CDO.Configuration\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> objConfiguration = GetConfiguration(lngConfigurationID)\r\n Set<\/span> rstMailing = db.OpenRecordset(\"SELECT * FROM tblMailings WHERE MailingID = \" & lngMailingID, dbOpenDynaset)\r\n strFrom = rstMailing!Sender\r\n strSubject = rstMailing!Subject\r\n strTextbody = rstMailing!Textbody\r\n strAttachments = Nz(rstMailing!Attachments, \"\")\r\n Set<\/span> rstTo = db.OpenRecordset(strSQLTo, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstTo.EOF\r\n strTo = rstTo.Fields(strMailfield)\r\n SendMailing objConfiguration, strTo, strFrom, strSubject, strTextbody, \"\", strAttachments\r\n rstTo.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
SELECT * FROM tblKunden WHERE KundeID = 1<\/pre>\n
Prozedur zum Verwenden der E-Mails<\/h2>\n
Public Sub <\/span>SendMailing(objConfiguration As <\/span>CDO.Configuration, strTo As String<\/span>, strFrom As String<\/span>, _\r\n strSubject As String<\/span>, strTextbody As String<\/span>, Optional<\/span> strBCC As String<\/span>, Optional<\/span> strAttachments As String<\/span>)\r\n Dim <\/span>objMessage As <\/span>CDO.Message\r\n Dim <\/span>varAttachment As Variant<\/span>\r\n Set<\/span> objMessage = New<\/span> CDO.Message\r\n With<\/span> objMessage\r\n Set<\/span> .Configuration = objConfiguration\r\n .To = strTo\r\n .From = strFrom\r\n .Subject = strSubject\r\n .Textbody = strTextbody\r\n If <\/span>Not<\/span> Len<\/span>(strBCC) = 0 Then<\/span>\r\n .BCC = strBCC\r\n End If<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strAttachments) = 0 Then<\/span>\r\n For Each varAttachment In Split<\/span>(strAttachments, \";\")\r\n .AddAttachment varAttachment\r\n Next<\/span> varAttachment\r\n End If<\/span>\r\n On Error Resume Next<\/span>\r\n .Send\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n Debug.Print<\/span> Err.Number, Err.Description\r\n End If<\/span>\r\n End With<\/span>\r\n Set<\/span> objMessage = Nothing\r\nEnd Sub<\/span><\/pre>\n\n
Beispielaufruf zum Versenden von Mailings<\/h2>\n
Serienmail 1, 1, \"SELECT * FROM tblKunden WHERE KundeID = 1\", \"EMail\"<\/pre>\n
![\"Eine](\"..\/fileadmin\/_temp_\/2022_03\/pic_1364_008.png\")
<\/p>\nPlatzhalter ersetzen<\/h2>\n
[Mailanrede] [Nachname],\r\ndies ist eine Testserienmail.\r\nViele Gr\u00fc\u00dfe\r\nAndr\u00e9 Minhorst<\/pre>\n
\n
Public Sub <\/span>Serienmail(lngConfiguration As Long<\/span>, lngMailingID As Long<\/span>, strSQLTo As String<\/span>, strMailfield As String<\/span>)\r\n ...\r\n Do While<\/span> Not<\/span> rstTo.EOF\r\n strTo = rstTo.Fields(strMailfield)\r\n strTextbody = ReplacePlaceholders(strTextbody, rstTo)\r\n SendMailing objConfiguration, strTo, strFrom, strSubject, strTextbody, \"\", strAttachments\r\n rstTo.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>ReplacePlaceholders(ByVal strTextbody As String<\/span>, ByVal rst As <\/span>DAO.Recordset) As String<\/span>\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n For Each fld In rst.Fields\r\n strTextbody = Replace<\/span>(strTextbody, \"[\" & fld.Name & \"]\", fld.Value)\r\n Next<\/span> fld\r\n ReplacePlaceholders = strTextbody\r\nEnd Function<\/span><\/pre>\nSerienmail 1, 1, \"SELECT * FROM tblKunden INNER JOIN tblAnreden ON tblKunden.AnredeID = tblAnreden.AnredeID WHERE KundeID = 1\", \"EMail\"<\/pre>\n