Usar o Cliente SMTP para Enviar E‑mails, Reencaminhar Mensagens e Realizar Mesclagem de Correspondência em C#

Enviando E‑mails

Enviar E‑mails com a Classe SmtpClient

O SmtpClient classe permite que aplicações enviem e‑mails através do Simple Mail Transfer Protocol (SMTP).

Uma de suas principais características é a capacidade de enviar mensagens em massa.

Ele também suporta totalmente síncrono e assíncrono modelos de programação. Para transmitir um e‑mail bloqueando a thread principal até que a operação seja concluída, os desenvolvedores podem usar um dos síncronos Enviar métodos. Alternativamente, para permitir que a thread principal continue executando enquanto o e‑mail é enviado, os desenvolvedores podem usar o SendAsync método.

Além disso, SmtpClient suporta o envio de mensagens em Formato de Encapsulamento Neutro de Transporte (TNEF).

Enviar E‑mails Síncronamente

Uma mensagem de e‑mail pode ser enviada de forma síncrona usando o Enviar método do SmtpClient classe. Ela envia a mensagem de e‑mail especificada através de um servidor SMTP para entrega. Para enviar uma mensagem de e‑mail de forma síncrona, siga os passos abaixo:

1. Crie uma instância de MailMessage classe e definir suas propriedades.
2. Crie uma instância de SmtpClient classe e especificar o Host, porta, nome de usuário e senha.
3. Enviar a Mensagem usando o Enviar método do SmtpClient classe e passar o MailMessage instância.

O trecho de código C# a seguir mostra como enviar e‑mails do Outlook de forma síncrona.

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

Enviar E‑mails Assincronamente

Às vezes, você pode querer enviar e‑mail de forma assíncrona para permitir que o programa continue executando outras operações enquanto o e‑mail é enviado em segundo plano. A partir do .NET Framework 4.5, você pode usar métodos assíncronos implementados de acordo com TAP modelo. O trecho de código C# abaixo mostra como enviar mensagens de e‑mail do Outlook usando os métodos baseados em padrão assíncrono de tarefa:

• SendAsync Envia as mensagens especificadas.

• IAsyncSmtpClient - Permite que aplicações enviem mensagens usando o Simple Mail Transfer Protocol (SMTP).

• SmtpClient.CreateAsync - Cria uma nova instância da classe Aspose.Email.Clients.Smtp.SmtpClient

• SmtpSend - Conjunto de parâmetros do método Aspose.Email.Clients.Smtp.IAsyncSmtpClient.SendAsync(Aspose.Email.Clients.Smtp.Models.SmtpSend).

• SmtpForward - Os argumentos do 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()
    {

    }
}

Enviar Mensagens do Disco

Arquivos EML contêm um cabeçalho, corpo da mensagem e anexos. Aspose.Email permite que desenvolvedores trabalhem com arquivos EML de diferentes formas. Esta seção mostra como carregar arquivos EML do disco e enviá‑los como e‑mails com SMTP. Você pode carregar arquivos .eml do disco ou stream para o MailMessage classe e envie a mensagem de e‑mail usando o SmtpClient classe. O MailMessage classe é a classe principal para criar novas mensagens de e‑mail, carregar arquivos de mensagens de e‑mail a partir de disco ou stream e salvar as mensagens. O trecho de código C# a seguir mostra como enviar mensagens armazenadas do disco.

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

Enviar E‑mails em Texto Simples

O Corpo propriedade, uma propriedade da MailMessage classe, que é usada para especificar o conteúdo em texto simples do corpo da mensagem. Para enviar um e‑mail em texto simples, siga estes passos:

• Crie uma instância do MailMessage classe.
• Especifique os endereços de e‑mail do remetente e do destinatário no MailMessage instância.
• Especifique o Corpo conteúdo, usado para a mensagem em texto simples.
• Crie uma instância do SmtpClient classe e envie o e‑mail.

O trecho de código a seguir mostra como enviar um e‑mail em texto simples.

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

Enviar E‑mails com Corpo HTML

Os exemplos de programação abaixo mostram como você pode enviar uma mensagem simples de e‑mail HTML. O HtmlBody, uma propriedade da MailMessage classe, que é usada para especificar o conteúdo HTML do corpo da mensagem. Para enviar um e‑mail HTML simples, siga estes passos:

• Crie uma instância do MailMessage classe.
• Especifique o endereço de e‑mail do remetente e do destinatário no MailMessage instância.
• Especifique o HtmlBody conteúdo.
• Crie uma instância do SmtpClient classe e envie o e‑mail usando o Enviar método.

Para os propósitos deste artigo, o conteúdo HTML do e‑mail é rudimentar: This is the HTML body A maioria dos e‑mails HTML será mais complexa. O trecho de código a seguir mostra como enviar um e‑mail com corpo HTML.

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

Enviar E‑mails HTML com Texto Alternativo

Use o AlternateView classe para especificar cópias de uma mensagem de e‑mail em diferentes formatos. Por exemplo, se você enviar uma mensagem em HTML, pode também desejar fornecer uma versão em texto simples para destinatários que usam leitores de e‑mail que não podem exibir conteúdo HTML. Ou, se estiver enviando um boletim, pode querer fornecer uma cópia em texto simples para os destinatários que optaram por receber a versão em texto simples. Para enviar um e‑mail com texto alternativo, siga estes passos:

1. Crie uma instância do MailMessage classe.
2. Especifique os endereços de e‑mail do remetente e do destinatário no MailMessage instância.
3. Crie uma instância do AlternateView classe.

Isso cria uma visualização alternativa para uma mensagem de e‑mail usando o conteúdo especificado na string.

1. Adicione a instância do AlternateView classe para o MailMessage objeto.
2. Crie uma instância do SmtpClient classe e envie o e‑mail usando o Enviar método.

O trecho de código a seguir mostra como enviar um e‑mail com texto alternativo.

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

Enviar E‑mails em Massa

Podemos enviar um lote de e‑mails usando o SmtpClient classe do Enviar sobrecarga de método que aceita um MailMessageCollection:

1. Crie uma instância de SmtpClient classe.
2. Especifique o SmtpClient propriedades da classe.
3. Crie uma instância do MailMessage classe.
4. Especifique o remetente, destinatário, assunto e mensagem na instância do MailMessage classe.
5. Repita os dois passos acima novamente, se quiser enviar e‑mail para outra pessoa.
6. Crie uma instância de MailMessageCollection classe.
7. Adicione uma instância de MailMessage classe no objeto do MailMessageCollection classe.
8. Agora envie seu e‑mail usando o SmtpClient classe Enviar método passando a instância de MailMessageCollection classe nele.

O trecho de código a seguir mostra como enviar e‑mails em massa.

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

Acompanhar Sucesso de E‑mail em Massa

Quando você envia mensagens em massa, pode obter informações sobre o número de mensagens enviadas com sucesso e até obter uma lista dessas mensagens. O SucceededSending evento serve a esse propósito.

Exemplo de código:

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

Enviar E‑mails com MultiConnection

O UseMultiConnection a propriedade pode ser usada para criar múltiplas conexões para operações intensivas. Você também pode definir o número de conexões a serem usadas no modo multiconexão usando SmtpClient.ConnectionsQuantity. O trecho de código a seguir demonstra o uso do modo multiconexão para enviar várias mensagens.

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

Observe que o uso do modo multiconexão não garante aumento de desempenho.

Enviar Mensagens como TNEF

E‑mails TNEF têm formatação especial que pode ser perdida se enviados usando a API padrão. O SmtpClient classe UseTnef propriedade pode ser definida para enviar o e‑mail como TNEF. O trecho de código a seguir mostra como enviar uma mensagem como 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);

Enviar Solicitações de Reunião

Aspose.Email permite que desenvolvedores adicionem funções de calendário aos seus e‑mails.

Enviar Solicitações por E‑mail

Para enviar solicitações de reunião via e‑mail, siga estes passos:

• Crie uma instância do MailMessage classe.
• Especifique endereços de remetente e destinatário usando uma instância do MailMessage classe.
• Inicialize uma instância da Appointment classe e passar seus valores.
• Especifique resumo e descrição no Calendar instância.
• Adicionar o Calendar para o MailMessage instância e passar o Appointment instância.

|Solicitação de reunião iCalendar enviada por e‑mail| | :- | || O trecho de código a seguir mostra como enviar solicitações via 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());
}

Encaminhar Mensagens

Encaminhar Mensagens com Cliente SMTP

Encaminhar um e‑mail é prática comum. Um e‑mail recebido pode ser encaminhado a destinatários específicos. O Encaminhar O método pode ser usado para encaminhar um e‑mail recebido ou salvo para os destinatários desejados. O trecho de código a seguir mostra como encaminhar um e‑mail usando o Cliente 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);

Encaminhar Mensagens sem MailMessage

A API também suporta encaminhamento de mensagens EML sem primeiro carregá‑las em MailMessage. Isso é útil em casos onde há recursos limitados em termos de memória do sistema.

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

Encaminhar Mensagens Assincronamente sem MailMessage

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

Mesclagem de Correspondência

Como Mesclar E‑mails

Mail merges ajudam a criar e enviar um lote de mensagens de e‑mail semelhantes. O núcleo dos e‑mails é o mesmo, mas o conteúdo pode ser personalizado. Normalmente, os detalhes de contato do destinatário (primeiro nome, sobrenome, empresa etc.) são usados para personalizar o e‑mail.

|Ilustração de como funciona uma mesclagem de e‑mail:| | :- | || Aspose.Email permite que desenvolvedores configurem mesclagens de e‑mail que incluam dados de uma variedade de fontes de dados.

Para executar um mail merge com Aspose.Email, siga os passos a seguir:

1. Crie uma função com a assinatura de nome
2. Crie uma instância do MailMessage classe.
3. Especifique o remetente, destinatário, assunto e corpo.
4. Crie uma assinatura para o final do e‑mail.
5. Crie uma instância do TemplateEngine classe e passe-a para o MailMessage instância.
6. Obtenha assinatura no TemplateEngine instância.
7. Crie uma instância da classe DataTable.
8. Adicione as colunas Receipt, FirstName e LastName como fontes de dados na classe DataTable.
9. Crie uma instância da classe DataRow.
10. Especifique o endereço de recebimento, nomes e sobrenomes no objeto DataRow.
11. Crie uma instância do MailMessageCollection classe
12. Especifique o TemplateEngine  e instâncias DataTable no MailMessageCollection instância.
13. Crie uma instância do SmtpClient classe e especificar o servidor, porta, nome de usuário e senha.
14. Enviar e‑mails usando o SmtpClient classe Enviar método.

No exemplo abaixo, #FirstName# indica uma coluna DataTable, cujo valor é definido pelo usuário. O trecho de código a seguir mostra como realizar a Mesclagem de Correspondência.

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

Como Realizar Mesclagem de Correspondência por Linha

O usuário pode mesclar linha de dados individual assim como obter um completo e preparado MailMessage objeto. O TemplateEngine.Merge método pode ser usado para realizar uma mesclagem de e‑mail linha a linha.

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

Enviar Mail Usando DNS

Às vezes, enviar e‑mails através de um servidor SMTP configurado não é viável para os requisitos de um projeto. Nesses casos você pode entregar a mensagem diretamente aos servidores de mail do destinatário pesquisando os registros MX (Mail Exchange) do domínio do destinatário.

Aspose.Email fornece o DnsClient classe para resolver registros MX. Para cada destinatário, o código abaixo resolve os servidores de troca de mail para o domínio do destinatário e tenta enviar a mensagem a um deles usando um SmtpClient configurado sem autenticação (porta 25). O trecho de código a seguir mostra como enviar e‑mails usando os servidores de mail do domínio do destinatário.

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

Receber Notificações de Entrega para Mensagens Enviadas e Falhas

Para obter notificação de entrega tanto para mensagens enviadas com sucesso quanto para falhas, use o pipe (|) operador para combinar valores do DeliveryNotificationOptions enumeração e atribuí‑las ao DeliveryNotificationOptions propriedade do MailMessage classe. O trecho de código a seguir mostra como receber notificações tanto para mensagens enviadas com sucesso quanto para falhas.

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

Usar um Documento Office como Corpo da Mensagem

Aspose.Email lida com protocolos de rede e recursos do Microsoft Outlook e não pode, por si só, renderizar documentos Word ou planilhas Excel. Contudo, combinando Aspose.Email com outros produtos Aspose, você pode converter um documento Office para HTML ou MHTML e usar o resultado como corpo do e‑mail.

Usar um Documento Microsoft Word como Corpo da Mensagem

Este exemplo usa Aspose.Words para .NET para carregar um documento Word e convertê‑lo para formato MHTML. Aspose.Email então carrega o MHTML em um MailMessage objeto, que é usado como corpo do e‑mail e enviado via SMTP. A formatação HTML e as imagens são preservadas como no documento fonte original ao ser visualizado no Outlook ou em um cliente de e‑mail web.

1. Carregar um documento Microsoft Word usando o Aspose.Words Document classe.
2. Salvá‑lo em um fluxo no formato MHTML.
3. Carregar o fluxo MHTML em um MailMessage objeto usando MhtmlLoadOptions.
4. Definir outras propriedades da mensagem.
5. Enviar o e‑mail usando o SmtpClient classe.

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

Usar uma Planilha Microsoft Excel como Corpo da Mensagem

Este exemplo usa Aspose.Cells para .NET para carregar uma planilha Excel e convertê‑la para um fluxo HTML. Aspose.Email então usa o HTML como corpo de um MailMessage e enviá‑la via SMTP.

1. Carregar uma planilha Microsoft Excel usando o Aspose.Cells Workbook classe.
2. Salvar a planilha carregada em um MemoryStream em formato HTML.
3. Ler o HTML do fluxo como uma string.
4. Criar um novo MailMessage objeto e definir seu HtmlBody para o conteúdo HTML.
5. Enviar o e‑mail usando o SmtpClient classe.

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