Użyj klienta SMTP do wysyłania e‑maili, przekazywania wiadomości i wykonywania scalania list w C#

Wysyłanie e‑maili

Wysyłaj e‑maile przy użyciu klasy SmtpClient

Ten SmtpClient klasa umożliwia aplikacjom wysyłanie e‑maili przez Simple Mail Transfer Protocol (SMTP).

Jedną z kluczowych funkcji jest możliwość wysyłanie wiadomości hurtowo.

Obsługuje również w pełni synchroniczny i asynchroniczny modeli programistycznych. Aby przesłać e‑mail blokując główny wątek aż do zakończenia operacji, deweloperzy mogą użyć jednego z synchronicznych Wyślij metod. Alternatywnie, aby pozwolić głównemu wątkowi kontynuować wykonywanie podczas wysyłania e‑maila, deweloperzy mogą użyć SendAsync metoda.

Dodatkowo, SmtpClient obsługuje wysyłanie wiadomości w Transport Neutral Encapsulation Format (TNEF).

Wysyłanie e‑maili synchronicznie

Wiadomość e‑mail można wysłać synchronicznie przy użyciu Wyślij metoda SmtpClient klasa. Wysyła określoną wiadomość e‑mail poprzez serwer SMTP w celu dostarczenia. Aby wysłać wiadomość e‑mail synchronicznie, postępuj według poniższych kroków:

1. Utwórz instancję MailMessage klasę i ustaw jej właściwości.
2. Utwórz instancję SmtpClient klasę i określ host, port, nazwę użytkownika oraz hasło.
3. Wyślij wiadomość przy użyciu Wyślij metoda SmtpClient klasy i przekazać MailMessage instancję.

Poniższy fragment kodu C# pokazuje, jak wysłać e‑maile Outlook synchronicznie.

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

Wysyłaj e‑maile asynchronicznie

Czasami możesz chcieć wysyłać pocztę asynchronicznie, aby program mógł kontynuować wykonywanie innych operacji, podczas gdy e‑mail jest wysyłany w tle. Począwszy od .NET Framework 4.5, możesz używać metod asynchronicznych zaimplementowanych zgodnie z TAP modelu. Poniższy fragment kodu C# pokazuje, jak wysłać wiadomości e‑mail Outlook przy użyciu metod opartych na asynchronicznym wzorcu zadaniowym:

• SendAsync Wysyła określone wiadomości.

• IAsyncSmtpClient - Umożliwia aplikacjom wysyłanie wiadomości przy użyciu protokołu Simple Mail Transfer Protocol (SMTP).

• SmtpClient.CreateAsync - Tworzy nową instancję klasy Aspose.Email.Clients.Smtp.SmtpClient

• SmtpSend - Zestaw parametrów metody Aspose.Email.Clients.Smtp.IAsyncSmtpClient.SendAsync(Aspose.Email.Clients.Smtp.Models.SmtpSend).

• SmtpForward - Argumenty metody 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()
    {

    }
}

Wysyłaj wiadomości z dysku

Pliki EML zawierają nagłówek, ciało wiadomości i załączniki. Aspose.Email umożliwia programistom pracę z plikami EML na różne sposoby. Ten rozdział pokazuje, jak wczytać pliki EML z dysku i wysłać je jako e‑maile przy użyciu SMTP. Możesz wczytać pliki .eml z dysku lub strumienia do MailMessage klasa i wyślij wiadomość e‑mail używając SmtpClient klasa. Ta MailMessage klasa jest główną klasą do tworzenia nowych wiadomości e‑mail, ładowania plików wiadomości e‑mail z dysku lub strumienia oraz zapisywania wiadomości. Poniższy fragment kodu C# pokazuje, jak wysłać przechowywane wiadomości z dysku.

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

Wysyłaj e‑maile w formacie zwykłego tekstu

Ten Treść właściwość, właściwość klasy MailMessage klasie, służącej do określania treści czystego tekstu w ciele wiadomości. Aby wysłać wiadomość e‑mail w formacie czystego tekstu, wykonaj następujące kroki:

• Utwórz instancję MailMessage klasa.
• Określ adresy e‑mail nadawcy i odbiorcy w MailMessage instancję.
• Określ Treść zawartość, używana w wiadomości tekstowej.
• Utwórz instancję SmtpClient klasa i wyślij e‑mail.

Poniższy fragment kodu pokazuje, jak wysłać e‑mail w formacie czystego tekstu.

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

Wysyłaj e‑maile z ciałem HTML

Poniższe przykłady programistyczne pokazują, jak można wysłać prostą wiadomość e‑mail w formacie HTML. HtmlBody, właściwość klasy MailMessage klasie, która służy do określania treści HTML ciała wiadomości. Aby wysłać prosty e‑mail w formacie HTML, wykonaj następujące kroki:

• Utwórz instancję MailMessage klasa.
• Określ adres e‑mail nadawcy i odbiorcy w MailMessage instancję.
• Określ HtmlBody zawartość.
• Utwórz instancję SmtpClient klasa i wyślij e‑mail przy użyciu Wyślij metoda.

Dla potrzeb tego artykułu zawartość HTML wiadomości e‑mail jest prosta: This is the HTML body Większość e‑maili HTML będzie bardziej złożona. Poniższy fragment kodu pokazuje, jak wysłać e‑mail z treścią HTML.

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

Wysyłaj e‑maile HTML z alternatywnym tekstem

Użyj AlternateView klasie, która służy do wskazywania kopii wiadomości e‑mail w różnych formatach. Na przykład, jeśli wyślesz wiadomość w HTML, możesz także udostępnić wersję czystego tekstu dla odbiorców, którzy używają programów pocztowych nieobsługujących HTML. Albo, jeśli wysyłasz newsletter, możesz dostarczyć wersję tekstową dla odbiorców, którzy wybrali otrzymywanie tekstu w formacie plain text. Aby wysłać e‑mail z alternatywną treścią tekstową, wykonaj następujące kroki:

1. Utwórz instancję MailMessage klasa.
2. Określ adresy e‑mail nadawcy i odbiorcy w MailMessage instancję.
3. Utwórz instancję AlternateView klasa.

Tworzy to alternatywny widok wiadomości e‑mail przy użyciu treści określonej w ciągu znaków.

1. Dodaj instancję AlternateView klasy do MailMessage obiekt.
2. Utwórz instancję SmtpClient klasa i wyślij e‑mail przy użyciu Wyślij metoda.

Poniższy fragment kodu pokazuje, jak wysłać e‑mail z alternatywną treścią tekstową.

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

Wysyłaj e‑maile hurtowo

Możemy wysłać paczkę e‑maili przy użyciu SmtpClient klasa Wyślij przeciążenie metody, które akceptuje MailMessageCollection:

1. Utwórz instancję SmtpClient klasa.
2. Określ SmtpClient właściwości klasy.
3. Utwórz instancję MailMessage klasa.
4. Określ nadawcę, odbiorcę, temat wiadomości oraz treść w instancji MailMessage klasa.
5. Powtórz powyższe dwa kroki, jeśli chcesz wysłać e‑mail do innej osoby.
6. Utwórz instancję MailMessageCollection klasa.
7. Dodaj instancję MailMessage klasy w obiekcie MailMessageCollection klasa.
8. Teraz wyślij swój e‑mail używając SmtpClient klasa Wyślij metoda przy przekazywaniu instancji MailMessageCollection klasa w niej.

Poniższy fragment kodu pokazuje, jak wysłać e‑maile masowo.

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

Śledź sukces wysyłki e‑maili hurtowych

Gdy wysyłasz wiadomości hurtowo, możesz uzyskać informacje o liczbie pomyślnie wysłanych wiadomości i nawet uzyskać listę tych wiadomości. SucceededSending zdarzenie jest przeznaczone do tego celu.

Przykład kodu:

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

Wysyłaj e‑maile z wieloma połączeniami

Ten UseMultiConnection właściwość może być użyta do tworzenia wielu połączeń przy intensywnych operacjach. Możesz także ustawić liczbę połączeń używanych w trybie wielopołączeniowym, używając SmtpClient.ConnectionsQuantity. Poniższy fragment kodu demonstruje użycie trybu wielokrotnego połączenia do wysyłania wielu wiadomości.

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

Należy zauważyć, że użycie trybu wielokonekowego nie gwarantuje zwiększenia wydajności.

Wysyłaj wiadomości jako TNEF

E‑maile TNEF mają specjalne formatowanie, które może zostać utracone przy wysyłaniu przy użyciu standardowego API. SmtpClient klasa UseTnef właściwość może być ustawiona, aby wysłać e‑mail jako TNEF. Poniższy fragment kodu pokazuje, jak wysłać wiadomość jako TNEF.

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

Wyślij zaproszenia na spotkania

Aspose.Email pozwala programistom dodawać funkcje kalendarza do Twoich e‑maili.

Wysyłaj żądania e‑mailem

Aby wysłać zaproszenia na spotkania przez e‑mail, postępuj zgodnie z poniższymi krokami:

• Utwórz instancję MailMessage klasa.
• Określ adresy nadawcy i odbiorcy przy użyciu instancji MailMessage klasa.
• Zainicjuj instancję Appointment klasę i przekazać jej wartości.
• Określ podsumowanie i opis w Calendar instancję.
• Dodaj Calendar do MailMessage instancję i przekazać jej Appointment instancję.

|Żądanie spotkania iCalendar wysłane e‑mailem| | :- | || Poniższy fragment kodu pokazuje, jak wysłać żądania przez e‑mail.

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

Przekazuj wiadomości

Przekazuj wiadomości przy użyciu klienta SMTP

Przekazywanie e‑maila jest powszechną praktyką. Otrzymany e‑mail może być przekazany konkretnym odbiorcom. Przekaż metoda może być użyta do przekazania otrzymanego lub zapisanego e‑maila do wybranych odbiorców. Poniższy fragment kodu pokazuje, jak przekazać e‑mail przy użyciu klienta SMTP.

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

Przekazuj wiadomości bez MailMessage

API obsługuje również przekazywanie wiadomości EML bez uprzedniego wczytywania do MailMessage. Jest to przydatne w sytuacjach, gdy zasoby systemowe, takie jak pamięć, są ograniczone.

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

Przekazuj wiadomości asynchronicznie bez MailMessage

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

Scalanie listów

Jak scalać e‑maile

Scalanie poczty pomaga tworzyć i wysyłać zestaw podobnych wiadomości e‑mail. Główna treść e‑maili jest taka sama, ale zawartość może być spersonalizowana. Zazwyczaj używa się danych kontaktowych odbiorcy (imię, nazwisko, firma itp.) do personalizacji e‑maila.

|Ilustracja, jak działa scalenie korespondencji:| | :- | || Aspose.Email umożliwia programistom konfigurowanie scalania korespondencji, które obejmuje dane z różnych źródeł danych.

Aby wykonać scalanie poczty przy użyciu Aspose.Email, wykonaj następujące kroki:

1. Utwórz funkcję o sygnaturze nazwy
2. Utwórz instancję MailMessage klasa.
3. Określ nadawcę, odbiorcę, temat i treść.
4. Utwórz podpis na końcu e‑mail.
5. Utwórz instancję TemplateEngine klasie i przekaż mu MailMessage instancję.
6. Pobierz podpis w TemplateEngine instancję.
7. Utwórz instancję klasy DataTable.
8. Dodaj kolumny Receipt, FirstName i LastName jako źródła danych w klasie DataTable.
9. Utwórz instancję klasy DataRow.
10. Określ adres odbiorcy, imię i nazwisko w obiekcie DataRow.
11. Utwórz instancję MailMessageCollection klasa
12. Określ TemplateEngine  oraz instancje DataTable w MailMessageCollection instancję.
13. Utwórz instancję SmtpClient klasę i określ serwer, port, nazwę użytkownika oraz hasło.
14. Wysyłaj e‑maile przy użyciu SmtpClient klasa Wyślij metoda.

W poniższym przykładzie #FirstName# wskazuje kolumnę DataTable, której wartość jest ustawiana przez użytkownika. Poniższy fragment kodu pokazuje, jak wykonać scalanie listów.

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

Jak wykonać scalanie listów wiersz po wierszu

Użytkownik może scalić pojedynczy wiersz danych, a także uzyskać kompletny i przygotowany MailMessage obiekt. TemplateEngine.Merge metodę można użyć do przeprowadzenia scalania korespondencji wiersz po wierszu.

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