Usar SMTP Client para enviar correos electrónicos, reenviar mensajes y realizar combinación de correo en C#

Enviando correos

Enviar correos con la clase SmtpClient

El SmtpClient la clase permite a las aplicaciones enviar correos a través del Protocolo Simple de Transferencia de Correo (SMTP).

Una de sus características clave es la capacidad de enviar mensajes en masa.

También admite completamente síncrono y asíncrono modelos de programación. Para transmitir un correo bloqueando el hilo principal hasta que la operación se complete, los desarrolladores pueden usar uno de los síncronos Enviar métodos. Alternativamente, para permitir que el hilo principal continúe ejecutándose mientras se envía el correo, los desarrolladores pueden usar el SendAsync método.

Además, SmtpClient admite el envío de mensajes en Formato de encapsulación neutral de transporte (TNEF).

Enviar correos de forma síncrona

Un mensaje de correo electrónico puede enviarse de forma síncrona usando el Enviar método del SmtpClient clase. Envía el mensaje de correo especificado a través de un servidor SMTP para su entrega. Para enviar un mensaje de correo de forma síncrona, sigue los pasos a continuación:

1. Cree una instancia de MailMessage clase y establecer sus propiedades.
2. Cree una instancia de SmtpClient clase y especificar el Host, puerto, nombre de usuario y Contraseña.
3. Enviar el mensaje usando el Enviar método del SmtpClient clase y pasar el MailMessage instancia.

El siguiente fragmento de código C# muestra cómo enviar correos 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 correos de forma asíncrona

A veces, puede que desees enviar correo de forma asíncrona para que el programa continúe ejecutando otras operaciones mientras el correo se envía en segundo plano. A partir de .NET Framework 4.5, puedes usar métodos asíncronos implementados según TAP modelo. El siguiente fragmento de código C# muestra cómo enviar mensajes de correo Outlook usando los métodos basados en el patrón asíncrono basado en tareas:

• SendAsync Envía los mensajes especificados.

• IAsyncSmtpClient - Permite a las aplicaciones enviar mensajes usando el Protocolo Simple de Transferencia de Correo (SMTP).

• SmtpClient.CreateAsync - Crea una nueva instancia de la clase Aspose.Email.Clients.Smtp.SmtpClient

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

• SmtpForward - Los argumentos de 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 mensajes desde el disco

Los archivos EML contienen un encabezado, cuerpo del mensaje y adjuntos. Aspose.Email permite a los desarrolladores trabajar con archivos EML de diferentes formas. Esta sección muestra cómo cargar archivos EML desde el disco y enviarlos como correos mediante SMTP. Puedes cargar archivos .eml desde el disco o flujo en el MailMessage clase y envíe el mensaje de correo usando el SmtpClient clase. El MailMessage la clase es la clase principal para crear nuevos mensajes de correo, cargar archivos de mensajes de correo desde disco o flujo y guardar los mensajes. El siguiente fragmento de código C# muestra cómo enviar mensajes almacenados desde el 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 correos en texto plano

El Cuerpo propiedad, una propiedad de la MailMessage clase, se usa para especificar el contenido de texto plano del cuerpo del mensaje. Para enviar un mensaje de correo de texto plano, siga estos pasos:

• Cree una instancia de la MailMessage clase.
• Especifique las direcciones de correo del remitente y del receptor en la MailMessage instancia.
• Especifique el Cuerpo contenido, usado para el mensaje de texto plano.
• Cree una instancia de la SmtpClient clase y envíe el correo.

El siguiente fragmento de código le muestra cómo enviar un correo de texto plano.

//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 correos con cuerpo HTML

Los ejemplos de programación a continuación muestran cómo puede enviar un mensaje de correo electrónico HTML simple. El HtmlBody, una propiedad de la MailMessage clase, se usa para especificar el contenido HTML del cuerpo del mensaje. Para enviar un correo HTML simple, siga estos pasos:

• Cree una instancia de la MailMessage clase.
• Especifique la dirección de correo del remitente y del receptor en la MailMessage instancia.
• Especifique el HtmlBody contenido.
• Cree una instancia de la SmtpClient clase y envíe el correo usando el Enviar método.

Para los propósitos de este artículo, el contenido HTML del correo es rudimentario: This is the HTML body La mayoría de los correos HTML serán más complejos. El siguiente fragmento de código muestra cómo enviar un correo con cuerpo 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 correos electrónicos HTML con texto alternativo

Utilice el AlternateView clase para especificar copias de un mensaje de correo electrónico en diferentes formatos. Por ejemplo, si envía un mensaje en HTML, también podría proporcionar una versión de texto plano para los destinatarios que usan lectores de correo que no pueden mostrar contenido HTML. O, si está enviando un boletín, podría querer proporcionar una copia de texto plano para aquellos destinatarios que eligieron recibir una versión de texto plano. Para enviar un correo con texto alternativo, siga estos pasos:

1. Cree una instancia de la MailMessage clase.
2. Especifique las direcciones de correo del remitente y del receptor en la MailMessage instancia.
3. Cree una instancia de la AlternateView clase.

Esto crea una vista alternativa a un mensaje de correo electrónico usando el contenido especificado en la cadena.

1. Agregue la instancia de la AlternateView clase al MailMessage objeto.
2. Cree una instancia de la SmtpClient clase y envíe el correo usando el Enviar método.

El siguiente fragmento de código le muestra cómo enviar un correo electrónico con 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 correos masivos

Podemos enviar un lote de correos usando el SmtpClient clase de la Enviar sobrecarga de método que acepta un MailMessageCollection:

1. Cree una instancia de SmtpClient clase.
2. Especifique el SmtpClient propiedades de la clase.
3. Cree una instancia de la MailMessage clase.
4. Especifique remitente, receptor, asunto del correo y mensaje en la instancia de la MailMessage clase.
5. Repita los dos pasos anteriores nuevamente, si desea enviar correo a una persona diferente.
6. Cree una instancia de MailMessageCollection clase.
7. Agregue una instancia de MailMessage clase en el objeto de la MailMessageCollection clase.
8. Ahora envíe su correo electrónico usando el SmtpClient clase Enviar método pasando la instancia de MailMessageCollection clase en ella.

El siguiente fragmento de código le muestra cómo enviar correos electrónicos masivos.

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

Rastrear el éxito del correo masivo

Cuando envías mensajes en masa, puedes obtener información sobre el número de mensajes enviados con éxito e incluso obtener una lista de esos mensajes. El SucceededSending el evento es para este propósito.

Ejemplo 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 correos electrónicos con MultiConnection

El UseMultiConnection La propiedad puede usarse para crear múltiples conexiones para operaciones intensivas. También puedes establecer el número de conexiones a usar durante el modo multiconexión mediante SmtpClient.ConnectionsQuantity. El siguiente fragmento de código muestra el uso del modo multiconexión para enviar varios mensajes.

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

Tenga en cuenta que el uso del modo multiconexión no garantiza un aumento de rendimiento.

Enviar mensajes como TNEF

Los correos TNEF tienen un formato especial que puede perderse si se envían usando la API estándar. El SmtpClient clase UseTnef la propiedad puede configurarse para enviar el correo como TNEF. El siguiente fragmento de código le muestra cómo enviar un mensaje 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 solicitudes de reunión

Aspose.Email permite a los desarrolladores agregar funciones de calendario a tus correos.

Enviar solicitudes por correo electrónico

Para enviar solicitudes de reunión por correo electrónico, siga estos pasos:

• Cree una instancia de la MailMessage clase.
• Especifique las direcciones del remitente y del destinatario usando una instancia del MailMessage clase.
• Inicialice una instancia de la Appointment clase y pasar sus valores.
• Especifique resumen y descripción en el Calendar instancia.
• Añada el Calendar al MailMessage instancia y pasarle el Appointment instancia.

|Solicitud de reunión iCalendar enviada por correo electrónico| | :- | || El siguiente fragmento de código le muestra cómo enviar solicitudes por correo electrónico.

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

Reenviar mensajes

Reenviar mensajes con SMTP Client

Reenviar un correo es una práctica común. Un correo recibido puede reenviarse a destinatarios específicos. El Reenviar El método puede usarse para reenviar un correo recibido o guardado a los destinatarios deseados. El siguiente fragmento de código muestra cómo reenviar un correo usando 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);

Reenviar mensajes sin MailMessage

La API también admite reenviar mensajes EML sin cargarlos primero en MailMessage. Esto es útil en casos donde hay recursos limitados en cuanto a memoria del sistema.

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

Reenviar mensajes de forma asíncrona sin MailMessage

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

Combinar correspondencia

Cómo combinar correos

Las combinaciones de correspondencia le ayudan a crear y enviar un lote de mensajes de correo electrónico similares. El núcleo de los correos es el mismo, pero el contenido puede personalizarse. Normalmente, los datos de contacto del destinatario (nombre, segundo nombre, empresa, etc.) se usan para personalizar el correo.

|Ilustración de cómo funciona una combinación de correspondencia:| | :- | || Aspose.Email permite a los desarrolladores configurar combinaciones de correspondencia que incluyen datos de una variedad de fuentes de datos.

Para realizar una combinación de correspondencia con Aspose.Email, siga los siguientes pasos:

1. Cree una función con la firma de nombre
2. Cree una instancia de la MailMessage clase.
3. Especifique el remitente, destinatario, asunto y cuerpo.
4. Cree una firma para el final del correo electrónico.
5. Cree una instancia de la TemplateEngine clase y pásela al MailMessage instancia.
6. Obtenga la firma en el TemplateEngine instancia.
7. Crea una instancia de la clase DataTable.
8. Agrega las columnas Receipt, FirstName y LastName como fuentes de datos en la clase DataTable.
9. Crea una instancia de la clase DataRow.
10. Especifica la dirección de recepción, nombres y apellidos en el objeto DataRow.
11. Cree una instancia de la MailMessageCollection clase
12. Especifique el TemplateEngine  e instancias de DataTable en el MailMessageCollection instancia.
13. Cree una instancia de la SmtpClient clase y especificar el servidor, puerto, nombre de usuario y contraseña.
14. Enviar correos electrónicos usando el SmtpClient clase Enviar método.

En el ejemplo a continuación, #FirstName# indica una columna de DataTable, cuyo valor es establecido por el usuario. El siguiente fragmento de código muestra cómo realizar la combinación de correspondencia.

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

Cómo realizar una combinación de correspondencia fila por fila

El usuario puede combinar una fila de datos individual así como obtener un completo y preparado MailMessage objeto. El TemplateEngine.Merge el método puede usarse para realizar una combinación de correspondencia fila por fila.

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

Enviar correo usando DNS

A veces enviar correos a través de un servidor SMTP configurado no es viable para los requisitos de un proyecto. En esos casos puedes entregar un mensaje directamente a los servidores de correo del destinatario buscando los registros MX (Mail Exchange) del dominio del destinatario.

Aspose.Email proporciona el DnsClient clase para resolver registros MX. Para cada destinatario, el código a continuación resuelve los servidores de intercambio de correo del dominio del destinatario y trata de enviar el mensaje a uno de ellos usando un SmtpClient configurado sin autenticación (puerto 25). El siguiente fragmento de código muestra cómo enviar correos usando los servidores de correo del dominio del destinatario.

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

Recibir notificaciones de entrega para mensajes enviados y fallidos

Para obtener una notificación de entrega tanto de mensajes enviados con éxito como fallidos, usa la barra vertical (|) operador para combinar valores del DeliveryNotificationOptions enumeración y asignarlos al DeliveryNotificationOptions propiedad del MailMessage clase. El siguiente fragmento de código muestra cómo recibir notificaciones tanto de mensajes enviados correctamente como fallidos.

// 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 un documento Office como cuerpo del mensaje

Aspose.Email maneja protocolos de red y funciones de Microsoft Outlook y no puede, por sí solo, renderizar documentos Word o libros de Excel. Sin embargo, combinando Aspose.Email con otros productos Aspose, puedes convertir un documento Office a HTML o MHTML y usar el resultado como cuerpo del correo.

Usar un documento de Microsoft Word como cuerpo del mensaje

Este ejemplo usa Aspose.Words para .NET para cargar un documento Word y convertirlo a formato MHTML. Aspose.Email luego carga el MHTML en un MailMessage objeto, que se usa como cuerpo del correo electrónico y se envía mediante SMTP. El formato HTML y las imágenes se conservan como en el documento fuente original al visualizarse en Outlook o en un cliente de correo web.

1. Cargar un documento de Microsoft Word usando Aspose.Words Document clase.
2. Guardarlo en un flujo en formato MHTML.
3. Cargar el flujo MHTML en un MailMessage objeto usando MhtmlLoadOptions.
4. Establecer otras propiedades del mensaje.
5. Enviar el correo usando el SmtpClient clase.

// 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 una hoja de cálculo de Microsoft Excel como cuerpo del mensaje

Este ejemplo usa Aspose.Cells para .NET para cargar un libro de Excel y convertirlo a un flujo HTML. Aspose.Email luego usa el HTML como cuerpo de un MailMessage y lo envía mediante SMTP.

1. Cargar un libro de Microsoft Excel usando Aspose.Cells Workbook clase.
2. Guardar el libro de trabajo cargado en un MemoryStream en formato HTML.
3. Leer el HTML del flujo como una cadena.
4. Crear un nuevo MailMessage objeto y establecer su HtmlBody al contenido HTML.
5. Enviar el correo usando el SmtpClient clase.

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