SMTP‑Client verwenden, um E‑Mails zu senden, Nachrichten weiterzuleiten und Seriendruck in C# durchzuführen

E‑Mails senden

E‑Mails mit der SmtpClient‑Klasse senden

Die SmtpClient Klasse ermöglicht Anwendungen das Senden von E‑Mails über das Simple Mail Transfer Protocol (SMTP).

Eine seiner wichtigsten Funktionen ist die Fähigkeit zu das Senden von Nachrichten in großen Mengen.

Es unterstützt auch vollständig synchronen und asynchronen Programmiermodelle nutzen. Um eine E‑Mail zu übertragen und den Hauptthread zu blockieren, bis der Vorgang abgeschlossen ist, können Entwickler eines der synchronen Senden Methoden. Alternativ können Entwickler das SendAsync Methode.

Zusätzlich, SmtpClient unterstützt das Senden von Nachrichten in Transport Neutral Encapsulation Format (TNEF).

E‑Mails synchron senden

Eine E‑Mail‑Nachricht kann synchron gesendet werden mit dem Senden Methode des SmtpClient Klasse. Sie sendet die angegebene E‑Mail‑Nachricht über einen SMTP‑Server zur Zustellung. Um eine E‑Mail‑Nachricht synchron zu senden, folgen Sie den unten genannten Schritten:

1. Erstellen Sie eine Instanz von MailMessage Klasse und setzen Sie ihre Eigenschaften.
2. Erstellen Sie eine Instanz von SmtpClient Klasse und geben Sie Host, Port, Benutzername & Passwort an.
3. Senden Sie die Nachricht mit dem Senden Methode des SmtpClient Klasse und übergeben Sie die MailMessage Instanz.

Das folgende C#‑Code‑Snippet zeigt, wie Outlook‑E‑Mails synchron gesendet werden.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Declare msg as MailMessage instance
MailMessage msg = new MailMessage();

// Create an instance of SmtpClient class
SmtpClient client = new SmtpClient();

// Specify your mailing host server, Username, Password, Port # and Security option
client.Host = "mail.server.com";
client.Username = "username";
client.Password = "password";
client.Port = 587;
client.SecurityOptions = SecurityOptions.SSLExplicit;

try
{
    // Client.Send will send this message
    client.Send(msg);
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    Trace.WriteLine(ex.ToString());
}

E‑Mails asynchron senden

Manchmal möchte man E‑Mails asynchron senden, damit das Programm andere Vorgänge weiter ausführen kann, während die E‑Mail im Hintergrund gesendet wird. Ab .NET Framework 4.5 können Sie asynchrone Methoden verwenden, die gemäß TAP Modell. Das folgende C#‑Code‑Snippet zeigt, wie Outlook‑E‑Mail‑Nachrichten mit den task‑basierten asynchronen Mustermethoden gesendet werden:

• SendAsync Sendet die angegebenen Nachrichten.

• IAsyncSmtpClient - Ermöglicht Anwendungen das Senden von Nachrichten über das Simple Mail Transfer Protocol (SMTP).

• SmtpClient.CreateAsync - Erstellt eine neue Instanz der Klasse Aspose.Email.Clients.Smtp.SmtpClient

• SmtpSend - Der Methodenparameter‑Satz von Aspose.Email.Clients.Smtp.IAsyncSmtpClient.SendAsync(Aspose.Email.Clients.Smtp.Models.SmtpSend).

• SmtpForward - Die Argumente der Methode Aspose.Email.Clients.Smtp.IAsyncSmtpClient.ForwardAsync(Aspose.Email.Clients.Smtp.Models.SmtpForward).

// Authenticate the client to obtain necessary permissions
static readonly string tenantId = "YOU_TENANT_ID";
static readonly string clientId = "YOU_CLIENT_ID";
static readonly string redirectUri = "http://localhost";
static readonly string username = "username";
static readonly string[] scopes = { "https://outlook.office.com/SMTP.Send" };

// Use the SmtpAsync method for asynchronous operations
static async Task Main(string[] args)
{
    await SmtpAsync();
    Console.ReadLine();
}

static async Task SmtpAsync()
{
    // Create token provider and get access token
    var tokenProvider = new TokenProvider(clientId, tenantId, redirectUri, scopes);
    var client = SmtpClient.CreateAsync("outlook.office365.com", username, tokenProvider, 587).GetAwaiter().GetResult();

    // Create a message to send
    var eml = new MailMessage("[e-mail]", "[e-mail]", "test subj async", "test body async");
    
    // send message
    var sendOptions = SmtpSend.Create();
    sendOptions.AddMessage(eml);
    await client.SendAsync(sendOptions);
    Console.WriteLine("message was sent");

    // forward message
    var fwdOptions = SmtpForward.Create();
    fwdOptions.SetMessage(eml);
    fwdOptions.AddRecipient("[e-mail]");
    await client.ForwardAsync(fwdOptions);
    Console.WriteLine("message was forwarded");
}

// Token provider implementation
public class TokenProvider : IAsyncTokenProvider
{
    private readonly PublicClientApplicationOptions _pcaOptions;
    private readonly string[] _scopes;

    public TokenProvider(string clientId, string tenantId, string redirectUri, string[] scopes)
    {
        _pcaOptions = new PublicClientApplicationOptions
        {
            ClientId = clientId,
            TenantId = tenantId,
            RedirectUri = redirectUri
        };

        _scopes = scopes;
    }

    public async Task<OAuthToken> GetAccessTokenAsync(bool ignoreExistingToken = false, CancellationToken cancellationToken = default)
    {

        var pca = PublicClientApplicationBuilder
            .CreateWithApplicationOptions(_pcaOptions).Build();

        try
        {
            var result = await pca.AcquireTokenInteractive(_scopes)
                .WithUseEmbeddedWebView(false)
                .ExecuteAsync(cancellationToken);

            return new OAuthToken(result.AccessToken);
        }
        catch (MsalException ex)
        {
            Console.WriteLine($"Error acquiring access token: {ex}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error: {ex}");
        }

        return null;
    }

    public void Dispose()
    {

    }
}

Nachrichten von der Festplatte senden

EML‑Dateien enthalten einen Header, den Nachrichtentext und Anhänge. Aspose.Email ermöglicht Entwicklern die Arbeit mit EML‑Dateien auf verschiedene Weise. Dieser Abschnitt zeigt, wie EML‑Dateien von der Festplatte geladen und als E‑Mails mit SMTP gesendet werden. Sie können .eml‑Dateien von der Festplatte oder aus einem Stream in die MailMessage Klasse und senden Sie die E‑Mail‑Nachricht mittels der SmtpClient Klasse. Die MailMessage Klasse ist die Hauptklasse zum Erstellen neuer E‑Mail‑Nachrichten, zum Laden von E‑Mail‑Nachrichtendateien von Festplatte oder Stream und zum Speichern der Nachrichten. Das folgende C#‑Code‑Snippet zeigt, wie gespeicherte Nachrichten von der Festplatte gesendet werden.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Load an EML file in MailMessage class
var message = MailMessage.Load(dataDir + "test.eml");

// Send this message using SmtpClient
var client = new SmtpClient("host", "username", "password");
            
try
{
    client.Send(message);
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}            

E‑Mails im Nur‑Text‑Format senden

Die Body Eigenschaft, eine Eigenschaft der MailMessage Klasse, die verwendet wird, um den Nur‑Text‑Inhalt des Nachrichtenkörpers festzulegen. Um eine Nur‑Text‑E‑Mail zu senden, gehen Sie wie folgt vor:

• Erstellen Sie eine Instanz von dem MailMessage Klasse.
• Geben Sie Absender‑ und Empfänger‑E‑Mail‑Adressen ein in der MailMessage Instanz.
• Geben Sie das Body Inhalt, verwendet für die Nur‑Text‑Nachricht.
• Erstellen Sie eine Instanz von dem SmtpClient Klasse und senden Sie die E‑Mail.

Das folgende Code‑Snippet zeigt, wie Sie eine Nur‑Text‑E‑Mail senden.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
//Create an instance of the MailMessage class
var message = new MailMessage();

// Set From field, To field and Plain text body
message.From = "[e-mail]";
message.To.Add("[e-mail]");
message.Body = "This is Plain Text Body";

// Create an instance of the SmtpClient class
var client = new SmtpClient();

// And Specify your mailing host server, Username, Password and Port
client.Host = "smtp.server.com";
client.Username = "Username";
client.Password = "Password";
client.Port = 25;

try
{
    //Client.Send will send this message
    client.Send(message);
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    System.Diagnostics.Trace.WriteLine(ex.ToString());
}

E‑Mails mit HTML‑Body senden

Die untenstehenden Programmbeispiele zeigen, wie Sie eine einfache HTML‑E‑Mail‑Nachricht senden können. Die HtmlBody, eine Eigenschaft der MailMessage Klasse, die verwendet wird, um den HTML‑Inhalt des Nachrichtenkörpers festzulegen. Um eine einfache HTML‑E‑Mail zu senden, gehen Sie wie folgt vor:

• Erstellen Sie eine Instanz von dem MailMessage Klasse.
• Geben Sie Absender‑ und Empfänger‑E‑Mail‑Adresse ein in der MailMessage Instanz.
• Geben Sie das HtmlBody Inhalt.
• Erstellen Sie eine Instanz von dem SmtpClient Klasse und senden Sie die E‑Mail mittels der Senden Methode.

Für die Zwecke dieses Artikels ist der HTML‑Inhalt der E‑Mail rudimentär: This is the HTML body Die meisten HTML‑E‑Mails sind komplexer. Das folgende Code‑Snippet zeigt, wie man eine E‑Mail mit HTML‑Body sendet.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
public static void Run()
{
    // Declare msg as MailMessage instance
    var msg = new MailMessage();

    // Use MailMessage properties like specify sender, recipient, message and HtmlBody
    msg.From = "[e-mail]";
    msg.To = "[e-mail]";
    msg.Subject = "Test subject";
    msg.HtmlBody = "<html><body>This is the HTML body</body></html>";

    var client = GetSmtpClient();

    try
    {
        // Client will send this message
        client.Send(msg);
        Console.WriteLine("Message sent");
    }
    catch (Exception ex)
    {
        Trace.WriteLine(ex.ToString());
    }

    Console.WriteLine(Environment.NewLine + "Email sent with HTML body.");
}

private static SmtpClient GetSmtpClient()
{
    var client = new SmtpClient("smtp.gmail.com", 587, "[e-mail]", "your.password");
    client.SecurityOptions = SecurityOptions.Auto;
    return client;
}

HTML‑E‑Mails mit Alternativtext senden

Verwenden Sie die AlternateView Klasse, um Kopien einer E‑Mail‑Nachricht in verschiedenen Formaten anzugeben. Zum Beispiel, wenn Sie eine Nachricht in HTML senden, möchten Sie möglicherweise auch eine Nur‑Text‑Version für Empfänger bereitstellen, die keinen HTML‑Inhalt anzeigen können. Oder, wenn Sie einen Newsletter versenden, möchten Sie eine Nur‑Text‑Kopie für Empfänger anbieten, die eine Nur‑Text‑Version bevorzugen. Um eine E‑Mail mit alternativem Text zu senden, gehen Sie wie folgt vor:

1. Erstellen Sie eine Instanz von dem MailMessage Klasse.
2. Geben Sie Absender‑ und Empfänger‑E‑Mail‑Adressen ein in der MailMessage Instanz.
3. Erstellen Sie eine Instanz von dem AlternateView Klasse.

Dies erzeugt eine alternative Ansicht für eine E‑Mail‑Nachricht mit dem im String angegebenen Inhalt.

1. Fügen Sie die Instanz der AlternateView Klasse zum MailMessage Objekt.
2. Erstellen Sie eine Instanz von dem SmtpClient Klasse und senden Sie die E‑Mail mittels der Senden Methode.

Das folgende Code‑Snippet zeigt, wie Sie eine E‑Mail mit alternativem Text senden.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Declare message as MailMessage instance
var message = new MailMessage();

// Creates AlternateView to view an email message using the content specified in the //string
var alternate = AlternateView.CreateAlternateViewFromString("Alternate Text");
            
// Adding alternate text
message.AlternateViews.Add(alternate);

Massen‑E‑Mails senden

Wir können einen Stapel E‑Mails senden mit dem SmtpClient Klasse von dem Senden Methoden‑Überladung, die einen MailMessageCollection:

1. Erstellen Sie eine Instanz von SmtpClient Klasse.
2. Geben Sie das SmtpClient Klassen‑Eigenschaften an.
3. Erstellen Sie eine Instanz von dem MailMessage Klasse.
4. Geben Sie Absender, Empfänger, Betreff und Nachricht in der Instanz der MailMessage Klasse.
5. Wiederholen Sie die beiden obigen Schritte, wenn Sie eine E‑Mail an eine andere Person senden möchten.
6. Erstellen Sie eine Instanz von MailMessageCollection Klasse.
7. Fügen Sie eine Instanz von MailMessage Klasse im Objekt von MailMessageCollection Klasse.
8. Senden Sie jetzt Ihre E‑Mail mit dem SmtpClient Klasse Senden Methode durch Übergeben der Instanz von MailMessageCollection Klasse darin.

Das folgende Code‑Snippet zeigt, wie Sie Massen‑E‑Mails senden.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create SmtpClient as client and specify server, port, user name and password
var client = new SmtpClient("mail.server.com", 25, "Username", "Password");

// Create instances of MailMessage class and Specify To, From, Subject and Message
var message1 = new MailMessage("[e-mail]", "[e-mail]", "Subject1", "message1, how are you?");
var message2 = new MailMessage("[e-mail]", "[e-mail]", "Subject2", "message2, how are you?");
var message3 = new MailMessage("[e-mail]", "[e-mail]", "Subject3", "message3, how are you?");

// Create an instance of MailMessageCollection class
var manyMsg = new MailMessageCollection();
manyMsg.Add(message1);
manyMsg.Add(message2);
manyMsg.Add(message3);

try
{
    // Send Messages using Send method
    client.Send(manyMsg);                
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    Trace.WriteLine(ex.ToString());
}

Erfolg von Massen‑E‑Mails verfolgen

Wenn Sie Nachrichten massenhaft senden, erhalten Sie Informationen über die Anzahl der erfolgreich gesendeten Nachrichten und können sogar eine Liste dieser Nachrichten erhalten. Der SucceededSending Ereignis ist dafür gedacht.

Code‑Beispiel:

using (var client = new SmtpClient(host, SecurityOptions.Auto))
{
    int messageCount = 0;

    client.SucceededSending += (sender, eventArgs) =>
    {
        Console.WriteLine("The message '{0}' was successfully sent.", eventArgs.Message.Subject);
        messageCount++;
    };

    client.Send(messages);

    Console.WriteLine("{0} messages were successfully sent.", messageCount);
}

E‑Mails mit MultiConnection senden

Die UseMultiConnection Die Eigenschaft kann verwendet werden, um mehrere Verbindungen für aufwändige Vorgänge zu erstellen. Sie können außerdem die Anzahl der Verbindungen festlegen, die im Mehrfachverbindungs‑Modus verwendet werden sollen, indem Sie SmtpClient.ConnectionsQuantity. Das folgende Code‑Snippet demonstriert die Nutzung des Multi‑Connection‑Modus zum Senden mehrerer Nachrichten.

var smtpClient = new SmtpClient();
smtpClient.Host = "<HOST>";
smtpClient.Username = "<USERNAME>";
smtpClient.Password = "<PASSWORD>";
smtpClient.Port = 587;
smtpClient.SupportedEncryption = EncryptionProtocols.Tls;
smtpClient.SecurityOptions = SecurityOptions.SSLExplicit;

var messages = new List<MailMessage>();
for (int i = 0; i < 20; i++)
{
    MailMessage message = new MailMessage(
        "<EMAIL ADDRESS>",
        "<EMAIL ADDRESS>",
        "Test Message - " + Guid.NewGuid().ToString(),
        "SMTP Send Messages with MultiConnection");
    messages.Add(message);
}

smtpClient.ConnectionsQuantity = 5;
smtpClient.UseMultiConnection = MultiConnectionMode.Enable;
smtpClient.Send(messages);

Bitte beachten Sie, dass die Verwendung des Mehrfachverbindungs‑Modus keine Leistungssteigerung garantiert.

Nachrichten als TNEF senden

TNEF‑E‑Mails haben ein spezielles Format, das beim Versand über die Standard‑API verloren gehen kann. Das SmtpClient Klasse UseTnef Eigenschaft kann so gesetzt werden, dass die E‑Mail als TNEF gesendet wird. Das folgende Code‑Snippet zeigt, wie man eine Nachricht als TNEF sendet.

var emlFileName = RunExamples.GetDataDir_Email() + "Message.eml";     // A TNEF Email

// Load from eml
var eml1 = MailMessage.Load(emlFileName, new EmlLoadOptions());
eml1.From = "[e-mail]";
eml1.To.Clear();
eml1.To.Add(new MailAddress("[e-mail]"));
eml1.Subject = "With PreserveTnef flag during loading";
eml1.Date = DateTime.Now;

var client = new SmtpClient("smtp.gmail.com", 587, "somename", "password");
client.SecurityOptions = SecurityOptions.Auto;
client.UseTnef = true;     // Use this flag to send as TNEF
client.Send(eml1);

Besprechungsanfragen senden

Aspose.Email ermöglicht Entwicklern, Kalenderfunktionen zu Ihren E‑Mails hinzuzufügen.

Anfragen per E‑Mail senden

Um Besprechungsanfragen per E‑Mail zu senden, folgen Sie diesen Schritten:

• Erstellen Sie eine Instanz von dem MailMessage Klasse.
• Geben Sie Absender‑ und Empfängeradressen mit einer Instanz von der MailMessage Klasse.
• Initialisieren Sie eine Instanz von der Appointment Klasse und übergeben Sie deren Werte.
• Geben Sie Zusammenfassung und Beschreibung im Calendar Instanz.
• Fügen Sie das Calendar zum MailMessage Instanz und übergeben Sie ihr die Appointment Instanz.

|iCalendar‑Besprechungsanfrage per E‑Mail gesendet| | :- | || Das folgende Code‑Snippet zeigt, wie man Anfragen per E‑Mail sendet.

// Create an instance of the MailMessage class
var msg = new MailMessage();

// Set the sender, recipient, who will receive the meeting request. Basically, the recipient is the same as the meeting attendees
msg.From = "[e-mail]";
msg.To = "[e-mail], [e-mail], [e-mail], [e-mail]";

// Create Appointment instance
var app = new Appointment("Room 112", new DateTime(2015, 7, 17, 13, 0, 0), new DateTime(2015, 7, 17, 14, 0, 0), msg.From, msg.To);
app.Summary = "Release Meetting";
app.Description = "Discuss for the next release";

// Add appointment to the message and Create an instance of SmtpClient class
msg.AddAlternateView(app.RequestApointment());
var client = GetSmtpClient();

try
{
    // Client.Send will send this message
    client.Send(msg);
    Console.WriteLine("Message sent");
}
catch (Exception ex)
{
    Trace.WriteLine(ex.ToString());
}

Nachrichten weiterleiten

Nachrichten mit dem SMTP‑Client weiterleiten

Das Weiterleiten einer E‑Mail ist gängige Praxis. Eine empfangene E‑Mail kann an bestimmte Empfänger weitergeleitet werden. Die Weiterleiten Methode kann verwendet werden, um eine empfangene oder gespeicherte E‑Mail an gewünschte Empfänger weiterzuleiten. Das folgende Code‑Snippet zeigt, wie man eine E‑Mail mit dem SMTP‑Client weiterleitet.

//Create an instance of SmtpClient class
var client = new SmtpClient();

// Specify your mailing host server, Username, Password, Port and SecurityOptions
client.Host = "mail.server.com";
client.Username = "username";
client.Password = "password";
client.Port = 587;
client.SecurityOptions = SecurityOptions.SSLExplicit;
var message = MailMessage.Load(dataDir + "Message.eml");
client.Forward("[e-mail]", "[e-mail]", message);

Nachrichten ohne MailMessage weiterleiten

Die API unterstützt außerdem das Weiterleiten von EML‑Nachrichten, ohne sie zuerst zu laden in MailMessage. Dies ist nützlich in Fällen, in denen nur begrenzte System‑Speicherressourcen verfügbar sind.

using (var client = new SmtpClient(host, smtpPort, username, password, SecurityOptions.Auto))
{
    using (var fs = File.OpenRead(@"test.eml"))
    {
        client.Forward(sender, recipients, fs);
    }
}

Nachrichten asynchron weiterleiten ohne MailMessage

using (var client = new SmtpClient(host, smtpPort, username, password))
{
    using (var fs = File.OpenRead(@"test.eml"))
    {
        await client.ForwardAsync(sender, recipients, fs);
    }
}

Mail‑Merge

Wie man E‑Mails zusammenführt

Seriendrucke helfen Ihnen, eine Charge ähnlicher E‑Mail‑Nachrichten zu erstellen und zu senden. Der Kern der E‑Mails ist gleich, aber der Inhalt kann personalisiert werden. Üblicherweise werden die Kontaktdaten des Empfängers (Vorname, Nachname, Unternehmen usw.) verwendet, um die E‑Mail zu personalisieren.

|Veranschaulichung, wie ein Mail‑Merge funktioniert:| | :- | || Aspose.Email ermöglicht Entwicklern das Einrichten von Mail‑Merges, die Daten aus verschiedenen Datenquellen einbeziehen.

Um einen Seriendruck mit Aspose.Email durchzuführen, befolgen Sie die folgenden Schritte:

1. Erstellen Sie eine Funktion mit der Namenssignatur
2. Erstellen Sie eine Instanz von dem MailMessage Klasse.
3. Geben Sie Absender, Empfänger, Betreff und Text an.
4. Erstellen Sie eine Signatur für das Ende der E‑Mail.
5. Erstellen Sie eine Instanz von dem TemplateEngine Klasse und übergeben Sie ihr die MailMessage Instanz.
6. Nehmen Sie die Signatur in der TemplateEngine Instanz.
7. Erstellen Sie eine Instanz der DataTable‑Klasse.
8. Fügen Sie die Spalten Receipt, FirstName und LastName als Datenquellen in der DataTable‑Klasse hinzu.
9. Erstellen Sie eine Instanz der DataRow‑Klasse.
10. Geben Sie die Empfängeradresse, den Vor‑ und Nachnamen im DataRow‑Objekt an.
11. Erstellen Sie eine Instanz von dem MailMessageCollection Klasse
12. Geben Sie das TemplateEngine  und DataTable‑Instanzen in der MailMessageCollection Instanz.
13. Erstellen Sie eine Instanz von dem SmtpClient Klasse und geben Sie Server, Port, Benutzername und Passwort an.
14. Senden Sie E‑Mails mit der SmtpClient Klasse Senden Methode.

Im nachstehenden Beispiel steht #FirstName# für eine DataTable‑Spalte, deren Wert vom Benutzer festgelegt wird. Das folgende Code‑Snippet zeigt, wie ein Mail‑Merge durchgeführt wird.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
public static void Run()
{
    // The path to the File directory.
    string dataDir = RunExamples.GetDataDir_SMTP();
    string dstEmail = dataDir + "EmbeddedImage.msg";

    // Create a new MailMessage instance
    MailMessage msg = new MailMessage();

    // Add subject and from address
    msg.Subject = "Hello, #FirstName#";
    msg.From = "[e-mail]";

    // Add email address to send email also Add mesage field to HTML body
    msg.To.Add("[e-mail]");
    msg.HtmlBody = "Your message here";
    msg.HtmlBody += "Thank you for your interest in <STRONG>Aspose.Email</STRONG>.";

    // Use GetSignment as the template routine, which will provide the same signature
    msg.HtmlBody += "<br><br>Have fun with it.<br><br>#GetSignature()#";

    // Create a new TemplateEngine with the MSG message,  Register GetSignature routine. It will be used in MSG.
    TemplateEngine engine = new TemplateEngine(msg);
    engine.RegisterRoutine("GetSignature", GetSignature);

    // Create an instance of DataTable and Fill a DataTable as data source
    DataTable dt = new DataTable();
    dt.Columns.Add("Receipt", typeof(string));
    dt.Columns.Add("FirstName", typeof(string));
    dt.Columns.Add("LastName", typeof(string));

    DataRow dr = dt.NewRow();
    dr["Receipt"] = "abc<[e-mail]>";
    dr["FirstName"] = "a";
    dr["LastName"] = "bc";
    dt.Rows.Add(dr);
    dr = dt.NewRow();
    dr["Receipt"] = "John<[e-mail]>";
    dr["FirstName"] = "John";
    dr["LastName"] = "Doe";
    dt.Rows.Add(dr);
    dr = dt.NewRow();
    dr["Receipt"] = "Third Recipient<[e-mail]>";
    dr["FirstName"] = "Third";
    dr["LastName"] = "Recipient";
    dt.Rows.Add(dr);

    MailMessageCollection messages;
    try
    {
        // Create messages from the message and datasource.
        messages = engine.Instantiate(dt);

        // Create an instance of SmtpClient and specify server, port, username and password
        SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "[e-mail]", "your.password");
        client.SecurityOptions = SecurityOptions.Auto;

        // Send messages in bulk
        client.Send(messages);
    }
    catch (MailException ex)
    {
        Debug.WriteLine(ex.ToString());
    }

    catch (SmtpException ex)
    {
        Debug.WriteLine(ex.ToString());
    }

    Console.WriteLine(Environment.NewLine + "Message sent after performing mail merge.");
}

// Template routine to provide signature
static object GetSignature(object[] args)
{
    return "Aspose.Email Team<br>Aspose Ltd.<br>" + DateTime.Now.ToShortDateString();
}

Zeilenweises Mail‑Merge durchführen

Benutzer können eine einzelne Datenzeile zusammenführen sowie ein vollständiges und vorbereitetes MailMessage Objekt. Der TemplateEngine.Merge Methode kann verwendet werden, um ein zeilenweises Mail‑Merge durchzuführen.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create message from the data in current row.
message = engine.Merge(currentRow);