Použít SMTP klienta k odesílání e‑mailů, přeposílání zpráv a provádění hromadné korespondence v C#

Odesílání e‑mailů

Odesílat e‑maily pomocí třídy SmtpClient

The SmtpClient třída umožňuje aplikacím odesílat e‑maily přes Simple Mail Transfer Protocol (SMTP).

Jednou z klíčových funkcí je schopnost odesílání zpráv hromadně.

Také plně podporuje synchronních a asynchronních programovací modely. Pro odeslání e‑mailu blokujícím hlavní vlákno až do dokončení operace mohou vývojáři použít jeden ze synchronních Odeslat metod. Alternativně, aby hlavní vlákno mohlo pokračovat v provádění, zatímco e‑mail je odesílán, mohou vývojáři použít SendAsync metoda.

Kromě toho, SmtpClient podporuje odesílání zpráv ve formátu Transport Neutral Encapsulation Format (TNEF).

Synchronní odesílání e‑mailů

E‑mailovou zprávu lze synchronně odeslat pomocí Odeslat metoda třídy SmtpClient třída. Odesílá zadanou e‑mailovou zprávu přes SMTP server k doručení. Pro synchronní odeslání e‑mailové zprávy postupujte podle níže uvedených kroků:

1. Vytvořte instanci MailMessage třída a nastavte její vlastnosti.
2. Vytvořte instanci SmtpClient třída a specifikujte hostitele, port, uživatelské jméno a heslo.
3. Odeslat zprávu pomocí Odeslat metoda třídy SmtpClient třída a předat MailMessage instance.

Níže uvedený útržek kódu v C# ukazuje, jak odeslat Outlook e‑maily synchronně.

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

Odesílat e‑maily asynchronně

Někdy můžete chtít odesílat poštu asynchronně, aby program mohl pokračovat v provádění dalších operací, zatímco e‑mail je odesílán na pozadí. Od .NET Framework 4.5 můžete použít asynchronní metody implementované podle TAP model. Níže uvedený útržek kódu v C# ukazuje, jak odeslat e‑mailové zprávy Outlook pomocí metod založených na úlohách (task‑based asynchronous pattern).

• SendAsync Odešle zadané zprávy.

• IAsyncSmtpClient - Umožňuje aplikacím odesílat zprávy pomocí protokolu Simple Mail Transfer Protocol (SMTP).

• SmtpClient.CreateAsync - Vytvoří novou instanci třídy Aspose.Email.Clients.Smtp.SmtpClient

• SmtpSend - Parametry 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()
    {

    }
}

Odeslat zprávy z disku

Soubory EML obsahují hlavičku, tělo zprávy a přílohy. Aspose.Email umožňuje vývojářům pracovat se soubory EML různými způsoby. Tato sekce ukazuje, jak načíst soubory EML z disku a odeslat je jako e‑maily pomocí SMTP. Soubory .eml můžete načíst z disku nebo proudu do MailMessage třídy a odešlete e‑mailovou zprávu pomocí SmtpClient třída. The MailMessage třída je hlavní třídou pro vytváření nových e‑mailových zpráv, načítání souborů e‑mailových zpráv z disku nebo proudu a ukládání zpráv. Níže uvedený útržek kódu v C# ukazuje, jak odeslat uložené zprávy z disku.

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

Odesílat e‑maily v prostém textu

The Body vlastnost, která je vlastností třídy MailMessage třídy, která se používá k určení obsahu zprávy v prostém textu. Pro odeslání e‑mailu v prostém textu postupujte podle následujících kroků:

• Vytvořte instanci MailMessage třída.
• Určete e‑mailové adresy odesílatele a příjemce v MailMessage instance.
• Určete Body obsah, používaný pro zprávu v prostém textu.
• Vytvořte instanci SmtpClient třídy a odešlete e‑mail.

Následující úryvek kódu vám ukazuje, jak odeslat e‑mail v prostém textu.

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

Odesílat e‑maily s HTML tělem

Níže uvedené programové ukázky ukazují, jak můžete odeslat jednoduchou HTML e‑mailovou zprávu. HtmlBody, vlastnost třídy MailMessage třídy, která se používá k určení HTML obsahu těla zprávy. Pro odeslání jednoduchého HTML e‑mailu postupujte podle následujících kroků:

• Vytvořte instanci MailMessage třída.
• Určete e‑mailovou adresu odesílatele a příjemce v MailMessage instance.
• Určete HtmlBody obsah.
• Vytvořte instanci SmtpClient třídy a odešlete e‑mail pomocí Odeslat metoda.

Pro účely tohoto článku je HTML obsah e‑mailu jednoduchý: This is the HTML body Většina HTML e‑mailů bude složitější. Následující útržek kódu ukazuje, jak odeslat e‑mail s HTML tělem.

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

Odesílat HTML e‑maily s alternativním textem

Použijte AlternateView třídy pro zadání kopií e‑mailové zprávy v různých formátech. Například pokud odešlete zprávu v HTML, můžete také poskytnout verzi prostého textu pro příjemce, kteří používají e‑mailové čtečky, které nedokážou zobrazit HTML obsah. Nebo pokud posíláte newsletter, můžete poskytnout prostý text pro příjemce, kteří si zvolili verzi v prostém textu. Pro odeslání e‑mailu s alternativním textem postupujte podle následujících kroků:

1. Vytvořte instanci MailMessage třída.
2. Určete e‑mailové adresy odesílatele a příjemce v MailMessage instance.
3. Vytvořte instanci AlternateView třída.

Tím se vytvoří alternativní pohled na e‑mailovou zprávu pomocí obsahu uvedeného v řetězci.

1. Přidejte instanci AlternateView třídy k MailMessage objektu.
2. Vytvořte instanci SmtpClient třídy a odešlete e‑mail pomocí Odeslat metoda.

Následující úryvek kódu vám ukazuje, jak odeslat e‑mail s alternativním textem.

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

Odeslat hromadné e‑maily

Můžeme odeslat dávku e‑mailů pomocí SmtpClient třída Odeslat přetížení metody, které přijímá MailMessageCollection:

1. Vytvořte instanci SmtpClient třída.
2. Určete SmtpClient vlastností třídy.
3. Vytvořte instanci MailMessage třída.
4. Určete odesílatele, příjemce, předmět e‑mailu a zprávu v instanci MailMessage třída.
5. Opakujte výše uvedené dva kroky, pokud chcete odeslat e‑mail jiné osobě.
6. Vytvořte instanci MailMessageCollection třída.
7. Přidejte instanci MailMessage třídy v objektu MailMessageCollection třída.
8. Nyní odešlete svůj e‑mail pomocí SmtpClient třída Odeslat metoda předáním instance MailMessageCollection třída v ní.

Následující úryvek kódu vám ukazuje, jak odeslat hromadné e‑mailové zprávy.

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

Sledovat úspěšnost hromadného e‑mailu

Když odesíláte zprávy hromadně, můžete získat informace o počtu úspěšně odeslaných zpráv a dokonce i seznam těchto zpráv. SucceededSending událost je k tomuto účelu.

Ukázka kódu:

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

Odesílat e‑maily s MultiConnection

The UseMultiConnection vlastnost lze použít k vytvoření více připojení pro náročné operace. Počet připojení, která se mají použít během režimu více připojení, můžete nastavit pomocí SmtpClient.ConnectionsQuantity. Následující úryvek kódu demonstruje použití režimu multipojení pro odesílání více zpráv.

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

Všimněte si, že použití režimu multikonfigurace nezaručuje zvýšení výkonu.

Odesílat zprávy jako TNEF

TNEF e‑maily mají speciální formátování, které může být ztraceno při odeslání pomocí standardního API. SmtpClient třída UseTnef vlastnost lze nastavit tak, aby e‑mail byl odeslán jako TNEF. Následující úryvek kódu ukazuje, jak odeslat zprávu 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);

Odeslat žádosti o schůzku

Aspose.Email umožňuje vývojářům přidávat kalendářové funkce do vašich e‑mailů.

Odesílat požadavky e‑mailem

Pro odeslání žádostí o schůzky prostřednictvím e‑mailu postupujte takto:

• Vytvořte instanci MailMessage třída.
• Zadejte adresy odesílatele a příjemce pomocí instance MailMessage třída.
• Inicializujte instanci Appointment třída a předat její hodnoty.
• Zadejte souhrn a popis v Calendar instance.
• Přidejte Calendar na MailMessage instance a předat jí Appointment instance.

|Žádost o schůzku iCalendar odeslaná e‑mailem| | :- | || Následující úryvek kódu ukazuje, jak posílat žádosti prostřednictvím e‑mailu.

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

Přeposílat zprávy

Přeposílat zprávy pomocí SMTP klienta

Přeposílání e‑mailu je běžná praxe. Přijatý e‑mail může být přeposlán konkrétním příjemcům. Přeposlat metoda může být použita k přeposlání přijatého nebo uloženého e‑mailu požadovaným příjemcům. Níže uvedený útržek kódu ukazuje, jak přeposlat e‑mail pomocí SMTP klienta.

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

Přeposílat zprávy bez MailMessage

API také podporuje přeposílání EML zpráv bez předchozího načtení do MailMessage. To je užitečné v případech, kdy jsou omezené prostředky systému, jako je paměť.

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

Asynchronně přeposílat zprávy bez MailMessage

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

Hromadná korespondence

Jak sloučit e‑maily

Hromadné dopisy vám pomáhají vytvořit a odeslat skupinu podobných e‑mailových zpráv. Základ e‑mailů je stejný, ale obsah lze personalizovat. Typicky se k personalizaci e‑mailu používají kontaktní údaje příjemce (jméno, příjmení, firma atd.).

|Ilustrace, jak hromadné rozesílání funguje:| | :- | || Aspose.Email umožňuje vývojářům nastavit hromadné rozesílání, které zahrnuje data z různých zdrojů dat.

Pro provedení hromadného dopisu pomocí Aspose.Email postupujte podle následujících kroků:

1. Vytvořte funkci s podpisem názvu
2. Vytvořte instanci MailMessage třída.
3. Zadejte odesílatele, příjemce, předmět a tělo zprávy.
4. Vytvořte podpis pro konec e‑mailu.
5. Vytvořte instanci TemplateEngine třídě a předáte jí MailMessage instance.
6. Získejte podpis v TemplateEngine instance.
7. Vytvořte instanci třídy DataTable.
8. Přidejte sloupce Receipt, FirstName a LastName jako datové zdroje do třídy DataTable.
9. Vytvořte instanci třídy DataRow.
10. Zadejte adresu příjemce, jméno a příjmení v objektu DataRow.
11. Vytvořte instanci MailMessageCollection třída
12. Určete TemplateEngine  a instance DataTable v MailMessageCollection instance.
13. Vytvořte instanci SmtpClient třída a specifikujte server, port, uživatelské jméno a heslo.
14. Odesílejte e‑maily pomocí SmtpClient třída Odeslat metoda.

V níže uvedeném příkladu #FirstName# označuje sloupec DataTable, jehož hodnota je nastavena uživatelem. Následující útržek kódu ukazuje, jak provést hromadné sloučení pošty.

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 provést řádkové hromadné sloučení pošty

Uživatel může sloučit jednotlivý řádek dat a také získat kompletní a připravený MailMessage objekt. Tento TemplateEngine.Merge metoda může být použita k provedení řádkového hromadného rozesílání.

// Create message from the data in current row.
message = engine.Merge(currentRow);

Poslat poštu pomocí DNS

Někdy není pro požadavky projektu možné posílat e-maily přes nakonfigurovaný SMTP server. V takových případech můžete doručit zprávu přímo na mail servery příjemce vyhledáním MX (Mail Exchange) záznamů domény příjemce.

Aspose.Email poskytuje DnsClient třída pro řešení MX záznamů. Pro každého příjemce kód níže řeší mail exchange servery domény příjemce a zkouší odeslat zprávu na jeden z nich pomocí SmtpClient konfigurováno bez ověřování (port 25). Následující ukázka kódu ukazuje, jak posílat e-maily pomocí mail serverů domény příjemce.

static void Main(string[] args)
{
    try
    {
        MailMessage msg = new MailMessage("[e-mail]", "[e-mail]", "test", "this is a test");
        msg.CC.Add(new MailAddress("[e-mail]", "CC Display Name"));
        DnsSendMessage(msg);
    }
    catch (Exception e)
    {
        Console.WriteLine(e.Message);
    }
}

private static void DnsSendMessage(MailMessage msg)
{
    // Get all the recipients in To, CC and Bcc in one collection
    MailAddressCollection addresses = new MailAddressCollection();
    foreach (MailAddress to in msg.To)
    {
        addresses.Add(to);
    }

    foreach (MailAddress cc in msg.CC)
    {
        addresses.Add(cc);
    }

    foreach (MailAddress bcc in msg.Bcc)
    {
        addresses.Add(bcc);
    }

    // Send mail using DNS to each address
    foreach (MailAddress addr in addresses)
    {
        // Find mail exchange servers with the help of DnsClient
        DnsClient dnsClient = new DnsClient();
        Question mxQuestion = new Question(addr.Host, QueryType.MX);
        if (dnsClient.Resolve(mxQuestion))
        {
            // Try to send a message
            foreach (ResourceRecord record in dnsClient.ReceivedMessage.Answers)
            {
                MXResourceRecord cnRecord = record as MXResourceRecord;
                if (cnRecord != null)
                {
                    try
                    {
                        // Send message
                        SmtpClient client = new SmtpClient();
                        client.AuthenticationMethod = SmtpAuthentication.None;
                        client.Host = cnRecord.ExchangeName;
                        client.Port = 25;
                        client.Send(msg);
                        Console.WriteLine("Mail sent to " + addr.Address);
                    }
                    catch (SmtpException e)
                    {
                        Console.WriteLine(cnRecord.ExchangeName + ": " + e.Message + Environment.NewLine);
                        continue;
                    }
                }
            }
        }
    }
}

Přijímat oznámení o doručení pro odeslané i neúspěšné zprávy

Pro získání oznámení o doručení pro úspěšně odeslané i neúspěšné zprávy použijte rouru (|) operátor pro kombinaci hodnot DeliveryNotificationOptions enumeraci a přiřadit je k DeliveryNotificationOptions vlastnost třídy MailMessage třída. Následující úryvek kódu ukazuje, jak získat upozornění pro úspěšně odeslané i neúspěšné zprávy.

// Create the message
MailMessage msg = new MailMessage();
msg.From = "[e-mail]";
msg.To = "[e-mail]";
msg.Subject = "the subject of the message";

// Set delivery notifications for success and failed messages and add the MIME headers
msg.DeliveryNotificationOptions = DeliveryNotificationOptions.OnSuccess | DeliveryNotificationOptions.OnFailure;
msg.Headers.Add("Read-Receipt-To", "[e-mail]");
msg.Headers.Add("Disposition-Notification-To", "[e-mail]");

// Send the message
SmtpClient client = new SmtpClient("host", "username", "password");
client.Send(msg);

Použít Office dokument jako tělo zprávy

Aspose.Email se zabývá síťovými protokoly a funkcemi Microsoft Outlook a není schopen sám renderovat Word dokumenty nebo Excel sešity. Kombinací Aspose.Email s dalšími produkty Aspose však můžete převést Office dokument do HTML nebo MHTML a použít výsledek jako tělo emailu.

Použít Microsoft Word dokument jako tělo zprávy

Tento příklad používá Aspose.Words for .NET na načtení Word dokumentu a konverzi do formátu MHTML. Aspose.Email poté načte MHTML do MailMessage objekt, který je použit jako tělo emailu a odeslán přes SMTP. HTML formátování a obrázky zůstávají zachovány jako v původním dokumentu při zobrazení v Outlooku nebo webovém emailovém klientu.

1. Načtěte dokument Microsoft Word pomocí Aspose.Words Document třída.
2. Uložte jej do streamu ve formátu MHTML.
3. Načtěte MHTML stream do MailMessage objekt pomocí MhtmlLoadOptions.
4. Nastavte další vlastnosti zprávy.
5. Odeslat e‑mail pomocí SmtpClient třída.

// Load a Word document from disk and save it to stream as MHTML
Document wordDocument = new Document(folderPath + "invoice.docx");
MemoryStream mhtmlStream = new MemoryStream();
wordDocument.Save(mhtmlStream, SaveFormat.Mhtml);

// Load the MHTML in a MailMessage object
mhtmlStream.Position = 0;
using (MailMessage message = MailMessage.Load(mhtmlStream, new MhtmlLoadOptions()))
{
    message.Subject = "Sending Invoice by Email";
    message.From = "[e-mail]";
    message.To = "[e-mail]";

    // Save the message in MSG format to disk
    message.Save(folderPath + "WordDocAsEmailBody_out.msg", SaveOptions.DefaultMsgUnicode);

    // Send the email message
    using (SmtpClient client = new SmtpClient("smtp.gmail.com", 587, "[e-mail]", "password"))
    {
        client.SecurityOptions = SecurityOptions.SSLExplicit;
        client.Send(message);
    }
}

Použít Excel list jako tělo zprávy

Tento příklad používá Aspose.Cells pro .NET na načtení Excel sešitu a konverzi do HTML streamu. Aspose.Email poté použije HTML jako tělo MailMessage a odešle jej přes SMTP.

1. Načtěte sešit Microsoft Excel pomocí Aspose.Cells Workbook třída.
2. Uložte načtený sešit do MemoryStream ve formátu HTML.
3. Přečtěte HTML ze streamu jako řetězec.
4. Vytvořit nový MailMessage objekt a nastavit jeho HtmlBody do HTML obsahu.
5. Odeslat e‑mail pomocí SmtpClient třída.

// Load the desired workbook from disk
Workbook workbook = new Workbook(dataDir + "Data.xlsx");

// Save the workbook to a memory stream in HTML format
MemoryStream ms = new MemoryStream();
workbook.Save(ms, SaveFormat.Html);
ms.Position = 0;

// Define a StreamReader object with the above MemoryStream
StreamReader sr = new StreamReader(ms);

// Load the saved HTML from StreamReader into a string variable
string strHtmlBody = sr.ReadToEnd();

// Define a new MailMessage object and set its HtmlBody
MailMessage message = new MailMessage();
message.HtmlBody = strHtmlBody;
message.Subject = "Inline Excel Message";
message.From = "[e-mail]";
message.To = "[e-mail]";
message.IsBodyHtml = true;

SmtpClient client = new SmtpClient();
client.Host = "smtp.gmail.com";
client.Username = "Username";
client.Password = "Password";
client.Port = 587;
client.SecurityOptions = SecurityOptions.Auto;
client.Send(message);