SmtpClient Classe

Definição

Namespace:

System.Net.Mail

Assembly:

System.Net.Mail.dll

Origem:

SmtpClient.cs

Permite que aplicativos enviem email usando o Protocolo SMTP. O SmtpClient tipo está obsoleto em algumas plataformas e não é recomendado em outras; para obter mais informações, consulte a seção Comentários.

public ref class SmtpClient : IDisposable

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

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

Public Class SmtpClient
Implements IDisposable

Herança

Object

SmtpClient

Atributos

UnsupportedOSPlatformAttribute

Implementações

IDisposable

Exemplos

O exemplo de código a seguir demonstra o envio de uma mensagem de email de forma assíncrona.

#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

Comentários

A SmtpClient classe é usada para enviar emails para um servidor SMTP para entrega. O protocolo SMTP é definido no RFC 2821, que está disponível em https://www.ietf.org.

Importante

Não recomendamos que você use a SmtpClient classe para novo desenvolvimento porque SmtpClient não dá suporte a muitos protocolos modernos. Em vez disso, use o MailKit ou outras bibliotecas. Para obter mais informações, consulte SmtpClient não deve ser usado no GitHub.

A SmtpClient classe está obsoleta no Xamarin. No entanto:

• Ele está incluído no .NET Standard 2.0 e versões posteriores e, portanto, deve fazer parte de qualquer implementação do .NET que dê suporte a essas versões.
• Ele está presente e pode ser usado em .NET Framework 4 a .NET Framework 4.8.
• Ele é utilizável no .NET Core, mas seu uso não é recomendado.

As classes mostradas na tabela a seguir são usadas para construir mensagens de email que podem ser enviadas usando SmtpClient.

Classe	Descrição
Attachment	Representa anexos de arquivo. Essa classe permite anexar arquivos, fluxos ou texto a uma mensagem de email.
MailAddress	Representa o endereço de email do remetente e dos destinatários.
MailMessage	Representa uma mensagem de email.

Para construir e enviar uma mensagem de email usando SmtpClient, você deve especificar as seguintes informações:

• O servidor host SMTP que você usa para enviar email. Consulte as Host propriedades e Port .

• Credenciais para autenticação, se necessário, pelo servidor SMTP. Consulte a propriedade Credentials.

• O endereço de email do remetente. Consulte os Send métodos e SendAsync que tomam um from parâmetro . Consulte também a MailMessage.From propriedade .

• O endereço de email ou endereços dos destinatários. Consulte os Send métodos e SendAsync que tomam um recipient parâmetro . Consulte também a MailMessage.To propriedade .

• O conteúdo da mensagem. Consulte os Send métodos e SendAsync que tomam um body parâmetro . Consulte também a MailMessage.Body propriedade .

Para incluir um anexo com uma mensagem de email, primeiro crie o anexo usando a Attachment classe e adicione-o à mensagem usando a MailMessage.Attachments propriedade . Dependendo do leitor de email usado pelos destinatários e do tipo de arquivo do anexo, alguns destinatários podem não conseguir ler o anexo. Para clientes que não podem exibir o anexo em seu formulário original, você pode especificar exibições alternativas usando a MailMessage.AlternateViews propriedade .

Em .NET Framework, você pode usar os arquivos de configuração do aplicativo ou do computador para especificar valores padrão de host, porta e credenciais para todos os SmtpClient objetos. Para obter mais informações, consulte <Elemento mailSettings> (Configurações de Rede). O .NET Core não dá suporte a padrões de configuração. Como solução alternativa, você deve definir as propriedades relevantes diretamente SmtpClient .

Para enviar a mensagem de email e bloquear enquanto aguarda o email ser transmitido para o servidor SMTP, use um dos métodos Send síncronos. Para permitir que o thread main do programa continue em execução enquanto o email é transmitido, use um dos métodos assíncronosSendAsync. O SendCompleted evento é gerado quando uma SendAsync operação é concluída. Para receber esse evento, você deve adicionar um SendCompletedEventHandler delegado a SendCompleted. O SendCompletedEventHandler delegado deve fazer referência a um método de retorno de chamada que manipula a notificação de SendCompleted eventos. Para cancelar uma transmissão de email assíncrona, use o SendAsyncCancel método .

Observação

Se houver uma transmissão de email em andamento e você chamar SendAsync ou Send novamente, você receberá um InvalidOperationException.

A conexão estabelecida pela instância atual da SmtpClient classe com o servidor SMTP pode ser reutilizado se um aplicativo quiser enviar várias mensagens para o mesmo servidor SMTP. Isso é particularmente útil quando a autenticação ou a criptografia são usadas estabelecem uma conexão com o servidor SMTP. O processo de autenticação e estabelecimento de uma sessão TLS pode ser operações caras. Um requisito para restabelecer uma conexão para cada mensagem ao enviar uma grande quantidade de email para o mesmo servidor SMTP pode ter um impacto significativo no desempenho. Há vários aplicativos de email de alto volume que enviam emails status atualizações, distribuições de boletins informativos ou alertas de email. Além disso, muitos aplicativos cliente de email dão suporte a um modo off-line em que os usuários podem compor muitas mensagens de email que são enviadas posteriormente quando uma conexão com o servidor SMTP é estabelecida. É comum um cliente de email enviar todas as mensagens SMTP para um servidor SMTP específico (fornecido pelo provedor de serviços de Internet) que encaminha esse email para outros servidores SMTP.

A SmtpClient classe de implementação agrupa conexões SMTP para evitar a sobrecarga de restabelecer uma conexão para cada mensagem para o mesmo servidor. Um aplicativo pode reutilizar o mesmo SmtpClient objeto para enviar muitos emails diferentes para o mesmo servidor SMTP e para muitos servidores SMTP diferentes. Como resultado, não há como determinar quando um aplicativo foi concluído usando o SmtpClient objeto e ele deve ser limpo.

Quando uma sessão SMTP é concluída e o cliente deseja encerrar a conexão, ele deve enviar uma mensagem QUIT para o servidor para indicar que ele não tem mais mensagens para enviar. Isso permite que o servidor libere recursos associados à conexão do cliente e processe as mensagens que foram enviadas pelo cliente.

A SmtpClient classe não tem nenhum Finalize método, portanto, um aplicativo deve chamar Dispose para liberar explicitamente os recursos. O Dispose método itera por meio de todas as conexões estabelecidas com o servidor SMTP especificado na Host propriedade e envia uma mensagem QUIT seguida pelo término normal da conexão TCP. O Dispose método também libera os recursos não gerenciados usados pelo Socket e, opcionalmente, descarta os recursos gerenciados.

Chame Dispose quando terminar de usar o SmtpClient. O Dispose método deixa o SmtpClient em um estado inutilizável. Depois de chamar Dispose, você deve liberar todas as referências para o SmtpClient para que o coletor de lixo possa recuperar a memória que o SmtpClient estava ocupando.

Construtores

SmtpClient()	Inicializa uma nova instância da classe SmtpClient usando as definições do arquivo de configuração.
SmtpClient(String)	Inicializa uma nova instância da classe SmtpClient, que envia o email usando o servidor SMTP especificado.
SmtpClient(String, Int32)	Inicializa uma nova instância da classe SmtpClient, que envia emails usando o servidor SMTP e a porta especificados.

Propriedades

ClientCertificates	Especifique quais certificados devem ser usados para estabelecer a conexão do protocolo SSL.
Credentials	Obtém ou define as credenciais usadas para autenticar o remetente.
DeliveryFormat	Obtém ou define o formato de entrega usado pelo SmtpClient para enviar email.
DeliveryMethod	Especifica como mensagens de email de saída serão tratadas.
EnableSsl	Especifica se SmtpClient usa o protocolo SSL para criptografar a conexão.
Host	Obtém ou define o nome ou endereço IP do host usado para transações de SMTP.
PickupDirectoryLocation	Obtém ou define a pasta em que os aplicativos salvam os emails a serem processados pelo servidor SMTP local.
Port	Obtém ou define a porta usada para transações de SMTP.
ServicePoint	Obtém a conexão de rede usada para transmitir a mensagem de email.
TargetName	Obtém ou define o SPN (Nome do Provedor de Serviços) a ser usado para autenticação ao usar a proteção estendida.
Timeout	Obtém ou define um valor que especifica o tempo após o qual uma chamada Send síncrona atinge o tempo limite.
UseDefaultCredentials	Obtém ou define um valor Boolean que controla se o DefaultCredentials é enviado com solicitações.

Métodos

Dispose()	Envia uma mensagem QUIT para o servidor SMTP, normalmente termina a conexão TCP e libera todos os recursos usados pela instância atual da classe SmtpClient.
Dispose(Boolean)	Envia uma mensagem QUIT para o servidor SMTP, normalmente termina a conexão TCP, libera todos os recursos usados pela instância atual da classe SmtpClient e, opcionalmente, descarta os recursos gerenciados.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
OnSendCompleted(AsyncCompletedEventArgs)	Aciona o evento SendCompleted.
Send(MailMessage)	Envia a mensagem especificada para entrega a um servidor SMTP.
Send(String, String, String, String)	Envia a mensagem de email especificada para entrega a um servidor SMTP. O remetente, os destinatários, o assunto e o corpo da mensagem são especificados usando objetos String.
SendAsync(MailMessage, Object)	Envia a mensagem de email especificada para entrega a um servidor SMTP. Esse método não bloqueia o thread de chamada e permite que o chamador passe um objeto para o método invocado quando a operação é concluída.
SendAsync(String, String, String, String, Object)	Envia uma mensagem de email para entrega a um servidor SMTP. O remetente, os destinatários, o assunto e o corpo da mensagem são especificados usando objetos String. Esse método não bloqueia o thread de chamada e permite que o chamador passe um objeto para o método invocado quando a operação é concluída.
SendAsyncCancel()	Cancela uma operação assíncrona para enviar uma mensagem de email.
SendMailAsync(MailMessage)	Envia a mensagem especificada para um servidor SMTP para entrega como uma operação assíncrona.
SendMailAsync(MailMessage, CancellationToken)	Envia a mensagem especificada para um servidor SMTP para entrega como uma operação assíncrona.
SendMailAsync(String, String, String, String)	Envia a mensagem especificada para um servidor SMTP para entrega como uma operação assíncrona. O remetente, os destinatários, o assunto e o corpo da mensagem são especificados usando objetos String.
SendMailAsync(String, String, String, String, CancellationToken)	Envia a mensagem especificada a um servidor SMTP para entrega como uma operação assíncrona, usando o remetente, os destinatários, o assunto e as cadeias de caracteres de corpo especificados.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Eventos

SendCompleted

Ocorre quando uma operação assíncrona de envio de email é concluída.

Confira também

• System.Net.Mime
• Programação de rede no .NET Framework
• Amostras de programação de rede
• Rastreamento de rede no .NET Framework
• Segurança na programação de rede