SmtpClient Clase

Definición

public ref class SmtpClient : IDisposable

public ref class SmtpClient

public class SmtpClient : IDisposable

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public class SmtpClient : IDisposable

public class SmtpClient

type SmtpClient = class
    interface IDisposable

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
type SmtpClient = class
    interface IDisposable

type SmtpClient = class

Public Class SmtpClient
Implements IDisposable

Public Class SmtpClient

Herencia

Object

SmtpClient

Atributos

UnsupportedOSPlatformAttribute

Implementaciones

IDisposable

Ejemplos

En el ejemplo de código siguiente se muestra cómo enviar un mensaje de correo electrónico de forma asincrónica.

#using <System.dll>
using namespace System;
using namespace System::Net;
using namespace System::Net::Mail;
using namespace System::Net::Mime;
using namespace System::Threading;
using namespace System::ComponentModel;

static bool mailSent;

static void SendCompletedCallback(Object^ sender, AsyncCompletedEventArgs^ e)
{
    // Get the unique identifier for this asynchronous 
    // operation.
    String^ token = (String^) e->UserState;

    if (e->Cancelled)
    {
        Console::WriteLine("[{0}] Send canceled.", token);
    }
    if (e->Error != nullptr)
    {
        Console::WriteLine("[{0}] {1}", token, 
            e->Error->ToString());
    } else
    {
        Console::WriteLine("Message sent.");
    }
    mailSent = true;
}

int main(array<String^>^ args)
{
    if (args->Length > 1)
    {
        // Command-line argument must be the SMTP host.
        SmtpClient^ client = gcnew SmtpClient(args[1]);
        // Specify the email sender.
        // Create a mailing address that includes a UTF8 
        // character in the display name.
        MailAddress^ from = gcnew MailAddress("jane@contoso.com",
            "Jane " + (wchar_t)0xD8 + " Clayton",
            System::Text::Encoding::UTF8);
        // Set destinations for the email message.
        MailAddress^ to = gcnew MailAddress("ben@contoso.com");
        // Specify the message content.
        MailMessage^ message = gcnew MailMessage(from, to);
        message->Body = "This is a test email message sent" +
            " by an application. ";
        // Include some non-ASCII characters in body and 
        // subject.
        String^ someArrows = gcnew String(gcnew array<wchar_t>{L'\u2190', 
            L'\u2191', L'\u2192', L'\u2193'});
        message->Body += Environment::NewLine + someArrows;
        message->BodyEncoding = System::Text::Encoding::UTF8;
        message->Subject = "test message 1" + someArrows;
        message->SubjectEncoding = System::Text::Encoding::UTF8;
        // Set the method that is called back when the send
        // operation ends.
        client->SendCompleted += gcnew
            SendCompletedEventHandler(SendCompletedCallback);
        // The userState can be any object that allows your 
        // callback method to identify this send operation.
        // For this example, the userToken is a string constant.
        String^ userState = "test message1";
        client->SendAsync(message, userState);
        Console::WriteLine("Sending message... press c to" +
            " cancel mail. Press any other key to exit.");
        String^ answer = Console::ReadLine();
        // If the user canceled the send, and mail hasn't been 
        // sent yet,then cancel the pending operation.
        if (answer->ToLower()->StartsWith("c") && mailSent == false)
        {
            client->SendAsyncCancel();
        }
        // Clean up.
        delete message;
        client = nullptr;
        Console::WriteLine("Goodbye.");
    }
    else
    {
        Console::WriteLine("Please give SMTP server name!");
    }
}

using System;
using System.Net;
using System.Net.Mail;
using System.Net.Mime;
using System.Threading;
using System.ComponentModel;
namespace Examples.SmtpExamples.Async
{
    public class SimpleAsynchronousExample
    {
        static bool mailSent = false;
        private static void SendCompletedCallback(object sender, AsyncCompletedEventArgs e)
        {
            // Get the unique identifier for this asynchronous operation.
             String token = (string) e.UserState;

            if (e.Cancelled)
            {
                 Console.WriteLine("[{0}] Send canceled.", token);
            }
            if (e.Error != null)
            {
                 Console.WriteLine("[{0}] {1}", token, e.Error.ToString());
            } else
            {
                Console.WriteLine("Message sent.");
            }
            mailSent = true;
        }
        public static void Main(string[] args)
        {
            // Command-line argument must be the SMTP host.
            SmtpClient client = new SmtpClient(args[0]);
            // Specify the email sender.
            // Create a mailing address that includes a UTF8 character
            // in the display name.
            MailAddress from = new MailAddress("jane@contoso.com",
               "Jane " + (char)0xD8+ " Clayton",
            System.Text.Encoding.UTF8);
            // Set destinations for the email message.
            MailAddress to = new MailAddress("ben@contoso.com");
            // Specify the message content.
            MailMessage message = new MailMessage(from, to);
            message.Body = "This is a test email message sent by an application. ";
            // Include some non-ASCII characters in body and subject.
            string someArrows = new string(new char[] {'\u2190', '\u2191', '\u2192', '\u2193'});
            message.Body += Environment.NewLine + someArrows;
            message.BodyEncoding =  System.Text.Encoding.UTF8;
            message.Subject = "test message 1" + someArrows;
            message.SubjectEncoding = System.Text.Encoding.UTF8;
            // Set the method that is called back when the send operation ends.
            client.SendCompleted += new
            SendCompletedEventHandler(SendCompletedCallback);
            // The userState can be any object that allows your callback
            // method to identify this send operation.
            // For this example, the userToken is a string constant.
            string userState = "test message1";
            client.SendAsync(message, userState);
            Console.WriteLine("Sending message... press c to cancel mail. Press any other key to exit.");
            string answer = Console.ReadLine();
            // If the user canceled the send, and mail hasn't been sent yet,
            // then cancel the pending operation.
            if (answer.StartsWith("c") && mailSent == false)
            {
                client.SendAsyncCancel();
            }
            // Clean up.
            message.Dispose();
            Console.WriteLine("Goodbye.");
        }
    }
}

Imports System.Net
Imports System.Net.Mail
Imports System.Net.Mime
Imports System.Threading
Imports System.ComponentModel

Namespace Examples.SmtpExamples.Async
    Public Class SimpleAsynchronousExample
        Private Shared mailSent As Boolean = False
        Private Shared Sub SendCompletedCallback(ByVal sender As Object, ByVal e As AsyncCompletedEventArgs)
            ' Get the unique identifier for this asynchronous operation.
            Dim token As String = CStr(e.UserState)

            If e.Cancelled Then
                Console.WriteLine("[{0}] Send canceled.", token)
            End If
            If e.Error IsNot Nothing Then
                Console.WriteLine("[{0}] {1}", token, e.Error.ToString())
            Else
                Console.WriteLine("Message sent.")
            End If
            mailSent = True
        End Sub
        Public Shared Sub Main(ByVal args() As String)
            ' Command line argument must the SMTP host.
            Dim client As New SmtpClient(args(0))
            ' Specify the email sender.
            ' Create a mailing address that includes a UTF8 character
            ' in the display name.
            Dim mailFrom As New MailAddress("jane@contoso.com", "Jane " & ChrW(&HD8) & " Clayton", System.Text.Encoding.UTF8)
            ' Set destinations for the email message.
            Dim mailTo As New MailAddress("ben@contoso.com")
            ' Specify the message content.
            Dim message As New MailMessage(mailFrom, mailTo)
            message.Body = "This is a test email message sent by an application. "
            ' Include some non-ASCII characters in body and subject.
            Dim someArrows As New String(New Char() {ChrW(&H2190), ChrW(&H2191), ChrW(&H2192), ChrW(&H2193)})
            message.Body += Environment.NewLine & someArrows
            message.BodyEncoding = System.Text.Encoding.UTF8
            message.Subject = "test message 1" & someArrows
            message.SubjectEncoding = System.Text.Encoding.UTF8
            ' Set the method that is called back when the send operation ends.
            AddHandler client.SendCompleted, AddressOf SendCompletedCallback
            ' The userState can be any object that allows your callback 
            ' method to identify this send operation.
            ' For this example, the userToken is a string constant.
            Dim userState As String = "test message1"
            client.SendAsync(message, userState)
            Console.WriteLine("Sending message... press c to cancel mail. Press any other key to exit.")
            Dim answer As String = Console.ReadLine()
            ' If the user canceled the send, and mail hasn't been sent yet,
            ' then cancel the pending operation.
            If answer.StartsWith("c") AndAlso mailSent = False Then
                client.SendAsyncCancel()
            End If
            ' Clean up.
            message.Dispose()
            Console.WriteLine("Goodbye.")
        End Sub
    End Class
End Namespace

Comentarios

La SmtpClient clase se usa para enviar correo electrónico a un servidor SMTP para su entrega. El protocolo SMTP se define en RFC 2821, que está disponible en https://www.ietf.org.

La SmtpClient clase está obsoleta en Xamarin. Pero:

• Se incluye en .NET Standard 2.0 y versiones posteriores y, por tanto, debe formar parte de cualquier implementación de .NET que admita esas versiones.
• Está presente y se puede usar en .NET Framework 4 a .NET Framework 4.8.
• Se puede usar en .NET Core, pero no se recomienda su uso.

Las clases que se muestran en la tabla siguiente se usan para construir mensajes de correo electrónico que se pueden enviar mediante SmtpClient.

Para construir y enviar un mensaje de correo electrónico mediante SmtpClient, debe especificar la siguiente información:

• El servidor host SMTP que se usa para enviar correo electrónico. Consulte las Host propiedades y Port .

• Credenciales para la autenticación, si es necesario para el servidor SMTP. Consulte la propiedad Credentials.

• Dirección de correo electrónico del remitente. Consulte los Send métodos y SendAsync que toman un from parámetro . Vea también la MailMessage.From propiedad .

• Dirección de correo electrónico o direcciones de los destinatarios. Consulte los Send métodos y SendAsync que toman un recipient parámetro . Vea también la MailMessage.To propiedad .

• El contenido del mensaje. Consulte los Send métodos y SendAsync que toman un body parámetro . Vea también la MailMessage.Body propiedad .

Para incluir datos adjuntos con un mensaje de correo electrónico, cree primero los datos adjuntos mediante la Attachment clase y, a continuación, agréguelo al mensaje mediante la MailMessage.Attachments propiedad . Según el lector de correo electrónico utilizado por los destinatarios y el tipo de archivo de los datos adjuntos, es posible que algunos destinatarios no puedan leer los datos adjuntos. En el caso de los clientes que no pueden mostrar los datos adjuntos en su forma original, puede especificar vistas alternativas mediante la MailMessage.AlternateViews propiedad .

En .NET Framework, puede usar los archivos de configuración de la aplicación o máquina para especificar los valores predeterminados de host, puerto y credenciales para todos los SmtpClient objetos. Para obtener más información, vea <elemento mailSettings> (Configuración de red) . .NET Core no admite la configuración predeterminada. Como solución alternativa, debe establecer las propiedades pertinentes SmtpClient directamente.

Para enviar el mensaje de correo electrónico y bloquear mientras espera a que el correo electrónico se transmita al servidor SMTP, use uno de los métodos sincrónicos Send . Para permitir que el subproceso principal del programa continúe ejecutándose mientras se transmite el correo electrónico, use uno de los métodos asincrónicos SendAsync . El SendCompleted evento se genera cuando se completa una SendAsync operación. Para recibir este evento, debe agregar un SendCompletedEventHandler delegado a SendCompleted. El SendCompletedEventHandler delegado debe hacer referencia a un método de devolución de llamada que controla la notificación de SendCompleted eventos. Para cancelar una transmisión de correo electrónico asincrónica, use el SendAsyncCancel método .

La conexión establecida por la instancia actual de la SmtpClient clase al servidor SMTP se puede volver a usar si una aplicación desea enviar varios mensajes al mismo servidor SMTP. Esto resulta especialmente útil cuando se usa la autenticación o el cifrado para establecer una conexión con el servidor SMTP. El proceso de autenticación y establecimiento de una sesión tls puede ser operaciones costosas. Un requisito para volver a establecer una conexión para cada mensaje al enviar una gran cantidad de correo electrónico al mismo servidor SMTP podría tener un impacto significativo en el rendimiento. Hay una serie de aplicaciones de correo electrónico de gran volumen que envían actualizaciones de estado de correo electrónico, distribuciones de boletines o alertas por correo electrónico. Además, muchas aplicaciones cliente de correo electrónico admiten un modo fuera de línea donde los usuarios pueden redactar muchos mensajes de correo electrónico que se envían más adelante cuando se establece una conexión al servidor SMTP. Es habitual que un cliente de correo electrónico envíe todos los mensajes SMTP a un servidor SMTP específico (proporcionado por el proveedor de servicios de Internet) que, a continuación, reenvía este correo electrónico a otros servidores SMTP.

La SmtpClient implementación de clase agrupa las conexiones SMTP para que pueda evitar la sobrecarga de restablecer una conexión para cada mensaje al mismo servidor. Una aplicación puede volver a usar el mismo SmtpClient objeto para enviar muchos correos electrónicos diferentes al mismo servidor SMTP y a muchos servidores SMTP diferentes. Como resultado, no hay ninguna manera de determinar cuándo una aplicación ha terminado de usar el SmtpClient objeto y se debe limpiar.

Cuando finaliza una sesión SMTP y el cliente desea finalizar la conexión, debe enviar un mensaje QUIT al servidor para indicar que no tiene más mensajes que enviar. Esto permite que el servidor libere los recursos asociados a la conexión del cliente y procese los mensajes enviados por el cliente.

La SmtpClient clase no tiene ningún Finalize método, por lo que una aplicación debe llamar Dispose a para liberar explícitamente los recursos. El Dispose método recorre en iteración todas las conexiones establecidas al servidor SMTP especificado en la Host propiedad y envía un mensaje QUIT seguido de finalizar correctamente la conexión TCP. El Dispose método también libera los recursos no administrados utilizados por Socket y, opcionalmente, elimina los recursos administrados.

Llame a Dispose cuando haya terminado de usar SmtpClient. El método Dispose deja el SmtpClient en un estado no utilizable. Después de llamar a Dispose, debe liberar todas las referencias a para SmtpClient que el recolector de elementos no utilizados pueda reclamar la memoria que SmtpClient estaba ocupando.

Constructores

Propiedades

Métodos

Eventos

Se aplica a

Consulte también

• System.Net.Mime
• Programación para redes en .NET Framework
• Network Programming Samples (Ejemplos de programación de red)
• Network Tracing in the .NET Framework (Seguimiento de red en .NET Framework)
• Seguridad en la programación para redes