SmtpClient Classe

Définition

Espace de noms:

System.Net.Mail

Assembly:

System.Net.Mail.dll

Source:

SmtpClient.cs

Permet aux applications d’envoyer des e-mails à l’aide du protocole SMTP (Simple Mail Transfer Protocol). Le SmtpClient type est obsolète sur certaines plateformes et déconseillé sur d’autres ; pour plus d’informations, consultez la section Remarques.

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

Héritage

Object

SmtpClient

Attributs

UnsupportedOSPlatformAttribute

Implémente

IDisposable

Exemples

L’exemple de code suivant illustre l’envoi d’un message électronique de façon asynchrone.

#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

Remarques

La SmtpClient classe est utilisée pour envoyer des e-mails à un serveur SMTP en vue de leur remise. Le protocole SMTP est défini dans RFC 2821, qui est disponible à l’adresse https://www.ietf.org.

Important

Nous vous déconseillons d’utiliser la classe pour un SmtpClient nouveau développement, car SmtpClient elle ne prend pas en charge de nombreux protocoles modernes. Utilisez MailKit ou d’autres bibliothèques à la place. Pour plus d’informations, consultez SmtpClient ne doit pas être utilisé sur GitHub.

La SmtpClient classe est obsolète dans Xamarin. Toutefois :

• Il est inclus dans .NET Standard 2.0 et versions ultérieures et doit donc faire partie de toute implémentation de .NET qui prend en charge ces versions.
• Il est présent et peut être utilisé dans .NET Framework 4 à .NET Framework 4.8.
• Il est utilisable dans .NET Core, mais son utilisation n’est pas recommandée.

Les classes indiquées dans le tableau suivant sont utilisées pour construire des messages électroniques qui peuvent être envoyés à l’aide de SmtpClient.

Classe	Description
Attachment	Représente des pièces jointes de fichiers. Cette classe vous permet de joindre des fichiers, des flux ou du texte à un e-mail.
MailAddress	Représente l’adresse e-mail de l’expéditeur et des destinataires.
MailMessage	Représente un e-mail.

Pour construire et envoyer un message électronique à l’aide SmtpClientde , vous devez spécifier les informations suivantes :

• Serveur hôte SMTP que vous utilisez pour envoyer des e-mails. Consultez les Host propriétés et Port .

• Informations d’identification pour l’authentification, si requises par le serveur SMTP. Voir la propriété Credentials.

• Adresse de messagerie de l'expéditeur. Consultez les Send méthodes et SendAsync qui prennent un from paramètre. Consultez également la MailMessage.From propriété .

• Adresse e-mail des destinataires. Consultez les Send méthodes et SendAsync qui prennent un recipient paramètre. Consultez également la MailMessage.To propriété .

• Le contenu du message. Consultez les Send méthodes et SendAsync qui prennent un body paramètre. Consultez également la MailMessage.Body propriété .

Pour inclure une pièce jointe avec un message électronique, commencez par créer la pièce jointe à l’aide de la Attachment classe , puis ajoutez-la au message à l’aide de la MailMessage.Attachments propriété . Selon le lecteur de courrier utilisé par les destinataires et le type de fichier de la pièce jointe, certains destinataires peuvent ne pas être en mesure de lire la pièce jointe. Pour les clients qui ne peuvent pas afficher la pièce jointe dans sa forme d’origine, vous pouvez spécifier d’autres vues à l’aide de la MailMessage.AlternateViews propriété .

Dans .NET Framework, vous pouvez utiliser les fichiers de configuration de l’application ou de l’ordinateur pour spécifier les valeurs d’hôte, de port et d’informations d’identification par défaut pour tous les SmtpClient objets. Pour plus d’informations, consultez <élément mailSettings> (paramètres réseau). .NET Core ne prend pas en charge les paramètres par défaut. Pour contourner ce problème, vous devez définir directement les propriétés SmtpClient pertinentes.

Pour envoyer le message électronique et bloquer en attendant que l’e-mail soit transmis au serveur SMTP, utilisez l’une des méthodes synchrones Send . Pour permettre au thread main de votre programme de continuer à s’exécuter pendant la transmission de l’e-mail, utilisez l’une des méthodes asynchronesSendAsync. L’événement SendCompleted est déclenché lorsqu’une SendAsync opération se termine. Pour recevoir cet événement, vous devez ajouter un SendCompletedEventHandler délégué à SendCompleted. Le SendCompletedEventHandler délégué doit référencer une méthode de rappel qui gère la notification des SendCompleted événements. Pour annuler une transmission asynchrone d’e-mail, utilisez la SendAsyncCancel méthode .

Notes

Si une transmission d’e-mail est en cours et que vous appelez SendAsync ou Send une nouvelle fois, vous recevrez un InvalidOperationExceptionmessage .

La connexion établie par le instance actuel de la SmtpClient classe au serveur SMTP peut être réutilisée si une application souhaite envoyer plusieurs messages au même serveur SMTP. Cela est particulièrement utile lorsque l’authentification ou le chiffrement sont utilisés pour établir une connexion au serveur SMTP. Le processus d’authentification et d’établissement d’une session TLS peut être coûteux. Une exigence de rétablir une connexion pour chaque message lors de l’envoi d’une grande quantité d’e-mails au même serveur SMTP peut avoir un impact significatif sur les performances. Il existe un certain nombre d’applications de messagerie volumineuses qui envoient des e-mails status mises à jour, des distributions de bulletins d’informations ou des alertes par e-mail. De nombreuses applications clientes de messagerie prennent également en charge un mode hors ligne où les utilisateurs peuvent composer de nombreux messages électroniques qui sont envoyés ultérieurement lorsqu’une connexion au serveur SMTP est établie. Il est courant qu’un client de messagerie envoie tous les messages SMTP à un serveur SMTP spécifique (fourni par le fournisseur de services Internet) qui transfère ensuite cet e-mail à d’autres serveurs SMTP.

L’implémentation SmtpClient de classe met en pool les connexions SMTP afin d’éviter la surcharge liée au rétablissement d’une connexion pour chaque message vers le même serveur. Une application peut réutiliser le même SmtpClient objet pour envoyer de nombreux e-mails différents au même serveur SMTP et à de nombreux serveurs SMTP différents. Par conséquent, il n’existe aucun moyen de déterminer quand une application a fini d’utiliser l’objet SmtpClient et qu’elle doit être nettoyée.

Lorsqu’une session SMTP est terminée et que le client souhaite arrêter la connexion, il doit envoyer un message QUIT au serveur pour indiquer qu’il n’a plus de messages à envoyer. Cela permet au serveur de libérer des ressources associées à la connexion à partir du client et de traiter les messages qui ont été envoyés par le client.

La SmtpClient classe n’ayant aucune Finalize méthode, une application doit appeler Dispose pour libérer explicitement des ressources. La Dispose méthode itère toutes les connexions établies au serveur SMTP spécifié dans la Host propriété et envoie un message QUIT suivi de la fin de la connexion TCP de manière appropriée. La Dispose méthode libère également les ressources non managées utilisées par et Socket supprime éventuellement les ressources managées.

Appelez la méthode Dispose une fois que vous avez terminé d'utiliser SmtpClient. La méthode Dispose rend le SmtpClient inutilisable. Après avoir appelé Dispose, vous devez libérer toutes les références à afin SmtpClient que le garbage collector puisse récupérer la mémoire que le SmtpClient occupait.

Constructeurs

SmtpClient()	Initialise une nouvelle instance de la classe SmtpClient en utilisant des paramètres du fichier de configuration.
SmtpClient(String)	Initialise une nouvelle instance de la classe SmtpClient qui envoie des e-mails à l’aide du serveur SMTP spécifié.
SmtpClient(String, Int32)	Initialise une nouvelle instance de la classe SmtpClient qui envoie des e-mails à l’aide du serveur SMTP et du port spécifiés.

Propriétés

ClientCertificates	Spécifiez quels certificats doivent être utilisés pour établir la connexion SSL.
Credentials	Obtient ou définit les informations d'identification utilisées pour authentifier l'expéditeur.
DeliveryFormat	Obtient ou définit le format de la livraison utilisé par SmtpClient pour envoyer des e-mails.
DeliveryMethod	Spécifie comment les messages électroniques sortants seront gérés.
EnableSsl	Spécifiez si SmtpClient utilise le protocole SSL (Secure Sockets Layer) pour chiffrer la connexion.
Host	Obtient ou définit le nom ou l'adresse IP de l'hôte utilisé pour les transactions SMTP.
PickupDirectoryLocation	Obtient ou définit le dossier dans lequel les applications enregistrent les messages électroniques à traiter par le serveur SMTP local.
Port	Obtient ou définit le port utilisé pour les transactions SMTP.
ServicePoint	Obtient la connexion réseau utilisée pour transmettre l’e-mail.
TargetName	Obtient ou définit le nom de fournisseur de services (SPN ou Service Provider Name) à utiliser pour l'authentification lors de l'utilisation de la protection étendue.
Timeout	Obtient ou définit une valeur qui spécifie le délai d'attente d'un appel Send synchrone.
UseDefaultCredentials	Obtient ou définit une valeur Boolean qui contrôle si les DefaultCredentials sont envoyés avec les demandes.

Méthodes

Dispose()	Envoie un message QUIT au serveur SMTP, termine la connexion TCP et libère toutes les ressources utilisées par l'instance actuelle de la classe SmtpClient.
Dispose(Boolean)	Envoie un message QUIT au serveur SMTP, met fin à la connexion TCP, libère toutes les ressources utilisées par l'instance actuelle de la classe SmtpClient, et supprime éventuellement les ressources managées.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
OnSendCompleted(AsyncCompletedEventArgs)	Déclenche l’événement SendCompleted.
Send(MailMessage)	Envoie le message spécifié à un serveur SMTP en vue de sa remise.
Send(String, String, String, String)	Envoie l’e-mail spécifié à un serveur SMTP en vue de sa remise. L'expéditeur, les destinataires, l'objet et le corps du message sont spécifiés à l'aide d'objets String.
SendAsync(MailMessage, Object)	Envoie l’e-mail spécifié à un serveur SMTP en vue de sa remise. Cette méthode ne bloque pas le thread appelant et permet à l'appelant de passer un objet à la méthode qui est appelée lorsque l'opération se termine.
SendAsync(String, String, String, String, Object)	Envoie un e-mail à un serveur SMTP en vue de sa remise. L'expéditeur, les destinataires, l'objet et le corps du message sont spécifiés à l'aide d'objets String. Cette méthode ne bloque pas le thread appelant et permet à l'appelant de passer un objet à la méthode qui est appelée lorsque l'opération se termine.
SendAsyncCancel()	Annule une opération asynchrone pour envoyer un e-mail.
SendMailAsync(MailMessage)	Envoie le message spécifié à un serveur SMTP pour remise en tant qu'opération asynchrone.
SendMailAsync(MailMessage, CancellationToken)	Envoie le message spécifié à un serveur SMTP pour remise en tant qu'opération asynchrone.
SendMailAsync(String, String, String, String)	Envoie le message spécifié à un serveur SMTP pour remise en tant qu'opération asynchrone. L'expéditeur, les destinataires, l'objet et le corps du message sont spécifiés à l'aide d'objets String.
SendMailAsync(String, String, String, String, CancellationToken)	Envoie le message spécifié à un serveur SMTP pour qu’il soit remis en tant qu’opération asynchrone à l’aide de l’expéditeur, des destinataires, de l’objet et des chaînes de corps spécifiés.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Événements

SendCompleted

Se produit lorsqu’une opération d’envoi d’e-mail asynchrone se termine.

Voir aussi

• System.Net.Mime
• Programmation réseau dans le .NET Framework
• Exemples de programmation réseau
• Traçage réseau dans le .NET Framework
• Sécurité dans la programmation réseau