Gebruik SMTP-client om e‑mails te verzenden, berichten door te sturen en mail merge uit te voeren in C#

E‑mails verzenden

E‑mails verzenden met de SmtpClient‑klasse

De SmtpClient klasse maakt het mogelijk voor toepassingen om e‑mails te verzenden via het Simple Mail Transfer Protocol (SMTP).

Een van de belangrijkste kenmerken is de mogelijkheid om het verzenden van berichten in bulk.

Het ondersteunt ook volledig synchroon en asynchroon programmeer­modellen. Om een e‑mail te verzenden waarbij de hoofdthread wordt geblokkeerd tot de bewerking voltooid is, kunnen ontwikkelaars een van de synchronische Verzenden methoden. Alternatief, om de hoofdthread te laten doorgaan terwijl de e‑mail wordt verzonden, kunnen ontwikkelaars de SendAsync methode.

Bovendien, SmtpClient ondersteunt het verzenden van berichten in Transport Neutral Encapsulation Format (TNEF).

E‑mails synchroon verzenden

Een e‑mailbericht kan synchronisch worden verzonden met behulp van de Verzenden methode van de SmtpClient klasse. Het verzendt het opgegeven e‑mailbericht via een SMTP‑server voor levering. Om een e‑mailbericht synchronisch te verzenden, volgt u de onderstaande stappen:

1. Maak een instantie van MailMessage klasse en stel de eigenschappen in.
2. Maak een instantie van SmtpClient klasse en specificeer de host, poort, gebruikersnaam & wachtwoord.
3. Verzend het bericht met behulp van de Verzenden methode van de SmtpClient klasse en geef de MailMessage instantie.

Het onderstaande C#‑codefragment laat zien hoe u Outlook‑e‑mails synchronisch kunt verzenden.

// 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 asynchroon verzenden

Soms wilt u e‑mail asynchroon verzenden zodat het programma andere bewerkingen kan blijven uitvoeren terwijl de e‑mail op de achtergrond wordt verzonden. Vanaf .NET Framework 4.5 kunt u asynchrone methoden gebruiken die zijn geïmplementeerd volgens TAP model. Het onderstaande C#‑codefragment laat zien hoe u Outlook‑e‑mailberichten kunt verzenden met behulp van taakgebaseerde asynchrone patroonmethoden:

• SendAsync Verstuurt de opgegeven berichten.

• IAsyncSmtpClient - Stelt toepassingen in staat om berichten te verzenden met behulp van het Simple Mail Transfer Protocol (SMTP).

• SmtpClient.CreateAsync - Maakt een nieuwe instantie van de klasse Aspose.Email.Clients.Smtp.SmtpClient aan

• SmtpSend - De parameterinstelling van de methode Aspose.Email.Clients.Smtp.IAsyncSmtpClient.SendAsync(Aspose.Email.Clients.Smtp.Models.SmtpSend).

• SmtpForward - De argumenten van 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()
    {

    }
}

Berichten van schijf verzenden

EML‑bestanden bevatten een header, berichtbody en bijlagen. Aspose.Email stelt ontwikkelaars in staat om met EML‑bestanden op verschillende manieren te werken. Deze sectie laat zien hoe u EML‑bestanden van schijf laadt en ze als e‑mails verzendt met SMTP. U kunt .eml‑bestanden van schijf of stream laden in de MailMessage klasse en verzend het e‑mailbericht met de SmtpClient klasse. De MailMessage klasse is de hoofdklasse voor het maken van nieuwe e‑mailberichten, het laden van e‑mailberichtbestanden van schijf of stream en het opslaan van de berichten. Het onderstaande C#‑codefragment laat zien hoe u opgeslagen berichten van de schijf verzendt.

// 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 verzenden in platte tekst

De Body eigenschap, een eigenschap van de MailMessage klasse, wordt gebruikt om de platte‑tekstinhoud van het berichtgedeelte te specificeren. Volg de onderstaande stappen om een platte‑tekst‑e‑mail te verzenden:

• Maak een instantie van de MailMessage klasse.
• Specificeer afzender‑ en ontvanger‑e‑mailadressen in de MailMessage instantie.
• Specificeer de Body inhoud, gebruikt voor het platte‑tekstbericht.
• Maak een instantie van de SmtpClient klasse en verzend de e‑mail.

Het volgende codefragment toont hoe u een platte‑tekst‑e‑mail kunt verzenden.

// 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 verzenden met HTML‑body

De programmeervoorbeelden hieronder laten zien hoe u een simpel HTML‑e‑mailbericht kunt verzenden. De HtmlBody, een eigenschap van de MailMessage klasse, wordt gebruikt om de HTML‑inhoud van het berichtgedeelte te specificeren. Volg de onderstaande stappen om een eenvoudige HTML‑e‑mail te verzenden:

• Maak een instantie van de MailMessage klasse.
• Specificeer afzender‑ en ontvanger‑e‑mailadres in de MailMessage instantie.
• Specificeer de HtmlBody inhoud.
• Maak een instantie van de SmtpClient klasse en verzend de e‑mail met de Verzenden methode.

Voor de doeleinden van dit artikel is de HTML‑inhoud van de e‑mail rudimentair: This is the HTML body De meeste HTML‑e‑mails zijn complexer. Het onderstaande codefragment laat zien hoe u een e‑mail met een HTML‑body kunt verzenden.

// 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 verzenden met alternatieve tekst

Gebruik de AlternateView klasse om kopieën van een e‑mailbericht in verschillende formaten te specificeren. Bijvoorbeeld, als u een bericht in HTML verstuurt, wilt u wellicht ook een platte‑tekstversie aanbieden voor ontvangers die e‑mailclients gebruiken die geen HTML kunnen weergeven. Of, als u een nieuwsbrief verstuurt, wilt u mogelijk een platte‑tekstkopie van de tekst bieden voor ontvangers die ervoor gekozen hebben een platte‑tekstversie te ontvangen. Volg deze stappen om een e‑mail met alternatieve tekst te verzenden:

1. Maak een instantie van de MailMessage klasse.
2. Specificeer afzender‑ en ontvanger‑e‑mailadressen in de MailMessage instantie.
3. Maak een instantie van de AlternateView klasse.

Dit creëert een alternatieve weergave van een e‑mailbericht met de in de string gespecificeerde inhoud.

1. Voeg de instantie van de AlternateView klasse naar de MailMessage object.
2. Maak een instantie van de SmtpClient klasse en verzend de e‑mail met de Verzenden methode.

Het volgende codefragment toont hoe u een e‑mail met alternatieve tekst kunt verzenden.

// 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);

Bulk‑e‑mails verzenden

We kunnen een batch e‑mails verzenden met behulp van de SmtpClient klasse van de Verzenden method overload die een MailMessageCollection:

1. Maak een instantie van SmtpClient klasse.
2. Specificeer de SmtpClient klasse‑eigenschappen.
3. Maak een instantie van de MailMessage klasse.
4. Specificeer afzender, ontvanger, onderwerp en bericht in de instantie van de MailMessage klasse.
5. Herhaal de bovenstaande twee stappen opnieuw als u een e‑mail naar een andere persoon wilt sturen.
6. Maak een instantie van MailMessageCollection klasse.
7. Voeg een instantie toe van MailMessage klasse in het object van de MailMessageCollection klasse.
8. Verstuur nu uw e‑mail met de SmtpClient klasse Verzenden methode door de instantie van MailMessageCollection klasse daarin.

Het volgende codefragment toont hoe u bulk‑e‑mails kunt verzenden.

// 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());
}

Succes van bulk‑e‑mail bijhouden

Wanneer u berichten in bulk verzendt, kunt u informatie krijgen over het aantal succesvol verzonden berichten en zelfs een lijst van deze berichten ontvangen. De SucceededSending gebeurtenis is hiervoor bedoeld.

Code‑voorbeeld:

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 verzenden met MultiConnection

De UseMultiConnection eigenschap kan worden gebruikt om meerdere verbindingen te maken voor zware bewerkingen. U kunt ook het aantal verbindingen dat tijdens de multiconnectiemodus wordt gebruikt instellen met behulp van SmtpClient.ConnectionsQuantity. Het volgende codefragment demonstreert het gebruik van de multiverbindingsmodus voor het verzenden van meerdere berichten.

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);

Let op dat het gebruik van multiconnectiemodus geen prestatieverbetering garandeert.

Berichten verzenden als TNEF

TNEF‑e‑mails hebben een speciale opmaak die verloren kan gaan wanneer ze met de standaard‑API worden verzonden. De SmtpClient klasse UseTnef eigenschap kan worden ingesteld om de e‑mail als TNEF te verzenden. Het volgende codefragment laat zien hoe u een bericht als TNEF verzendt.

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);

Vergaderverzoeken verzenden

Aspose.Email stelt ontwikkelaars in staat om agenda‑functies aan uw e‑mails toe te voegen.

Verzoeken via e‑mail verzenden

Om vergaderverzoeken via e‑mail te versturen, volg deze stappen:

• Maak een instantie van de MailMessage klasse.
• Specificeer afzender‑ en ontvangeradressen met een instantie van de MailMessage klasse.
• Initialiseer een instantie van de Appointment klasse en geef de waarden door.
• Specificeer samenvatting en beschrijving in de Calendar instantie.
• Voeg de toe Calendar naar de MailMessage instantie en geef het de Appointment instantie.

|iCalendar‑vergaderverzoek verzonden per e‑mail| | :- | || Het volgende codefragment laat zien hoe u verzoeken via e‑mail verzendt.

// 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());
}

Berichten doorsturen

Berichten doorsturen met SMTP‑client

Het doorsturen van een e‑mail is gebruikelijk. Een ontvangen e‑mail kan worden doorgestuurd naar specifieke ontvangers. De Doorsturen methode kan worden gebruikt om een ontvangen of opgeslagen e‑mail naar gewenste ontvangers door te sturen. Het onderstaande codefragment laat zien hoe u een e‑mail doorstuurt met SMTP‑client.

//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);

Berichten doorsturen zonder MailMessage

De API ondersteunt ook het doorsturen van EML‑berichten zonder deze eerst te laden in MailMessage. Dit is nuttig in gevallen waarin er beperkte bronnen zijn qua systeemgeheugen.

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

Berichten asynchroon doorsturen zonder 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

Hoe e‑mails te samenvoegen

Mail merges helpen u bij het maken en verzenden van een batch soortgelijke e‑mailberichten. De kern van de e‑mails is hetzelfde, maar de inhoud kan worden gepersonaliseerd. Typisch worden de contactgegevens van de ontvanger (voornaam, achternaam, bedrijf, enz.) gebruikt om de e‑mail te personaliseren.

|Illustratie van hoe een mail merge werkt:| | :- | || Aspose.Email stelt ontwikkelaars in staat mail merges op te zetten die gegevens uit verschillende bronnen bevatten.

Om een mailmerge uit te voeren met Aspose.Email, volg de volgende stappen:

1. Maak een functie met de naamhandtekening
2. Maak een instantie van de MailMessage klasse.
3. Specificeer afzender, ontvanger, onderwerp en inhoud.
4. Maak een handtekening voor het einde van de e‑mail.
5. Maak een instantie van de TemplateEngine klasse en geef het de MailMessage instantie.
6. Neem handtekening in de TemplateEngine instantie.
7. Maak een instantie van de DataTable‑klasse.
8. Voeg de kolommen Receipt, FirstName en LastName toe als gegevensbronnen in de DataTable‑klasse.
9. Maak een instantie van de DataRow‑klasse.
10. Geef het ontvangst‑adres, voor‑ en achternaam op in het DataRow‑object.
11. Maak een instantie van de MailMessageCollection klasse
12. Specificeer de TemplateEngine  en DataTable‑instanties in de MailMessageCollection instantie.
13. Maak een instantie van de SmtpClient klasse en specificeer de server, poort, gebruikersnaam en wachtwoord.
14. E‑mails verzenden met de SmtpClient klasse Verzenden methode.

In het onderstaande voorbeeld duidt #FirstName# op een DataTable‑kolom waarvan de waarde door de gebruiker wordt ingesteld. Het onderstaande codefragment laat zien hoe u Mail Merge uitvoert.

// 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();
}

Hoe rij‑gewijze mail‑merge uit te voeren

Gebruiker kan een individuele gegevensrij samenvoegen en tevens een complete en voorbereide MailMessage object. De TemplateEngine.Merge methode kan worden gebruikt om een rij‑gewijze mail merge uit te voeren.

// 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);