SmtpClient Classe

Definizione

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

Ereditarietà

Object

SmtpClient

Attributi

UnsupportedOSPlatformAttribute

Implementazioni

IDisposable

Esempio

Nell'esempio di codice seguente viene illustrato l'invio di un messaggio di posta elettronica in modo asincrono.

#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

Commenti

La SmtpClient classe viene usata per inviare messaggi di posta elettronica a un server SMTP per il recapito. Il protocollo SMTP è definito in RFC 2821, disponibile in https://www.ietf.org.

La SmtpClient classe è obsoleta in Xamarin. Tuttavia:

• È incluso in .NET Standard 2.0 e versioni successive e pertanto deve far parte di qualsiasi implementazione .NET che supporti tali versioni.
• È presente e può essere usato in .NET Framework 4 tramite .NET Framework 4.8.
• È utilizzabile in .NET Core, ma l'uso non è consigliato.

Le classi visualizzate nella tabella seguente vengono usate per costruire messaggi di posta elettronica che possono essere inviati usando SmtpClient.

Per costruire e inviare un messaggio di posta elettronica usando SmtpClient, è necessario specificare le informazioni seguenti:

• Server host SMTP usato per inviare posta elettronica. Vedere le Host proprietà e Port .

• Credenziali per l'autenticazione, se richiesto dal server SMTP. Vedere la proprietà Credentials.

• Indirizzo di posta elettronica del mittente. Vedere i Send metodi e SendAsync che accettano un from parametro. Vedere anche la MailMessage.From proprietà.

• Indirizzo di posta elettronica o indirizzi dei destinatari. Vedere i Send metodi e SendAsync che accettano un recipient parametro. Vedere anche la MailMessage.To proprietà.

• Il contenuto del messaggio. Vedere i Send metodi e SendAsync che accettano un body parametro. Vedere anche la MailMessage.Body proprietà.

Per includere un allegato con un messaggio di posta elettronica, creare prima l'allegato usando la classe e quindi aggiungerlo al messaggio usando la AttachmentMailMessage.Attachments proprietà . A seconda del lettore di posta elettronica usato dai destinatari e dal tipo di file dell'allegato, alcuni destinatari potrebbero non essere in grado di leggere l'allegato. Per i client che non possono visualizzare l'allegato nel formato originale, è possibile specificare visualizzazioni alternative usando la MailMessage.AlternateViews proprietà .

In .NET Framework è possibile usare i file di configurazione dell'applicazione o del computer per specificare i valori host, porta e credenziali predefiniti per tutti gli SmtpClient oggetti. Per altre informazioni, vedere <elemento mailSettings> (Impostazioni di rete). .NET Core non supporta l'impostazione predefinita. Come soluzione alternativa, è necessario impostare direttamente le proprietà SmtpClient pertinenti.

Per inviare il messaggio di posta elettronica e bloccare durante l'attesa della trasmissione del messaggio di posta elettronica al server SMTP, usare uno dei metodi sincroni Send . Per consentire al programma di continuare l'esecuzione durante la trasmissione del messaggio di posta elettronica, usare uno dei metodi asincroni SendAsync . L'evento SendCompleted viene generato al termine di un'operazione SendAsync . Per ricevere questo evento, è necessario aggiungere un SendCompletedEventHandler delegato a SendCompleted. Il SendCompletedEventHandler delegato deve fare riferimento a un metodo di callback che gestisce la notifica degli SendCompleted eventi. Per annullare una trasmissione di posta elettronica asincrona, usare il SendAsyncCancel metodo .

La connessione stabilita dall'istanza corrente della SmtpClient classe al server SMTP può essere usata nuovamente se un'applicazione desidera inviare più messaggi allo stesso server SMTP. Ciò è particolarmente utile quando viene usata l'autenticazione o la crittografia stabilire una connessione al server SMTP. Il processo di autenticazione e creazione di una sessione TLS può essere costoso. Un requisito per ristabilire una connessione per ogni messaggio quando si invia una grande quantità di posta elettronica allo stesso server SMTP potrebbe avere un impatto significativo sulle prestazioni. Esistono numerose applicazioni di posta elettronica con volumi elevati che inviano aggiornamenti dello stato di posta elettronica, distribuzioni di newsletter o avvisi di posta elettronica. Anche molte applicazioni client di posta elettronica supportano una modalità off-line in cui gli utenti possono comporre molti messaggi di posta elettronica inviati in un secondo momento quando viene stabilita una connessione al server SMTP. È tipico che un client di posta elettronica invii tutti i messaggi SMTP a un server SMTP specifico (fornito dal provider di servizi Internet) che quindi inoltra questo messaggio di posta elettronica ad altri server SMTP.

Le SmtpClient connessioni SMTP del pool di implementazione della classe consentono di evitare il sovraccarico di ristabilire una connessione per ogni messaggio allo stesso server. Un'applicazione può riutilizzare lo stesso SmtpClient oggetto per inviare molti messaggi di posta elettronica diversi allo stesso server SMTP e a molti server SMTP diversi. Di conseguenza, non è possibile determinare quando un'applicazione viene terminata usando l'oggetto SmtpClient e deve essere pulita.

Al termine di una sessione SMTP e il client desidera terminare la connessione, deve inviare un messaggio QUIT al server per indicare che non contiene più messaggi da inviare. In questo modo il server può liberare le risorse associate alla connessione dal client ed elaborare i messaggi inviati dal client.

La SmtpClient classe non Finalize dispone di alcun metodo, pertanto un'applicazione deve chiamare Dispose per liberare in modo esplicito le risorse. Il Dispose metodo esegue l'iterazione di tutte le connessioni stabilite al server SMTP specificato nella Host proprietà e invia un messaggio QUIT seguito dalla normale chiusura della connessione TCP. Il Dispose metodo rilascia anche le risorse non gestite usate da Socket e, facoltativamente, elimina le risorse gestite.

Chiamare il metodo Dispose dopo aver terminato di utilizzare l'oggetto SmtpClient. Il metodo Dispose lascia l'oggetto SmtpClient in una condizione di inutilizzabilità. Dopo aver chiamato Dispose, è necessario rilasciare tutti i riferimenti a SmtpClient in modo che SmtpClient il Garbage Collector possa recuperare la memoria occupata da .

Costruttori

Proprietà

Metodi

Eventi

Si applica a

Vedi anche

• System.Net.Mime
• Programmazione di rete in .NET Framework
• Esempi di programmazione di rete
• Tracciatura di rete in .NET Framework
• Sicurezza in programmazione di rete