Quelles sont les meilleures pratiques pour l'utilisation de SmtpClient, SendAsync et Dispose sous .NET 4.0

Je suis un peu perplexe sur la façon de gérer SmtpClient maintenant qu'il est jetable, surtout si je passe des appels en utilisant SendAsync. Je ne devrais probablement pas appeler Dispose avant la fin de SendAsync. Mais devrais-je jamais l'appeler (par exemple, en utilisant "using"). Le scénario est un service WCF qui envoie régulièrement des e-mails lorsque des appels sont effectués. La plupart des calculs sont rapides, mais l'envoi d'e-mails peut prendre une seconde environ, donc Async serait préférable.

Dois-je créer un nouveau SmtpClient à chaque fois que j'envoie du courrier? Dois-je en créer un pour l'ensemble de la WCF? Aidez-moi!

Mise à jour Au cas où cela ferait une différence, chaque e-mail est toujours personnalisé pour l'utilisateur. Le WCF est hébergé sur Azure et Gmail est utilisé comme messagerie.

Remarque: .NET 4.5 SmtpClient implémente la async awaitableméthode SendMailAsync. Pour les versions inférieures, utilisez SendAsynccomme décrit ci-dessous.

Vous devez toujours supprimer les IDisposableinstances le plus tôt possible. Dans le cas des appels asynchrones, il s'agit du rappel après l'envoi du message.

var message = new MailMessage("from", "to", "subject", "body"))
var client = new SmtpClient("host");
client.SendCompleted += (s, e) => {
                           client.Dispose();
                           message.Dispose();
                        };
client.SendAsync(message, null);

C'est un peu ennuyeux que SendAsyncn'accepte pas de rappel.

La question d'origine a été posée pour .NET 4, mais si cela aide à partir de .NET 4.5, SmtpClient implémente la méthode attendable asynchrone SendMailAsync .

Par conséquent, pour envoyer des e-mails de manière asynchrone, procédez comme suit:

public async Task SendEmail(string toEmailAddress, string emailSubject, string emailMessage)
{
    using (var message = new MailMessage())
    {
        message.To.Add(toEmailAddress);

        message.Subject = emailSubject;
        message.Body = emailMessage;

        using (var smtpClient = new SmtpClient())
        {
            await smtpClient.SendMailAsync(message);
        }
    }
}

Il vaut mieux éviter d'utiliser la méthode SendAsync.

En général, les objets IDisposables doivent être éliminés dès que possible; l'implémentation de IDisposable sur un objet est destinée à communiquer le fait que la classe en question contient des ressources coûteuses qui devraient être libérées de manière déterministe. Cependant, si la création de ces ressources coûte cher et que vous devez construire beaucoup de ces objets, il peut être préférable (en termes de performances) de conserver une instance en mémoire et de la réutiliser. Il n'y a qu'une seule façon de savoir si cela fait une différence: profiler!

Re: disposer et Async: vous ne pouvez pas utiliser usingévidemment. Au lieu de cela, vous supprimez généralement l'objet dans l'événement SendCompleted:

var smtpClient = new SmtpClient();
smtpClient.SendCompleted += (s, e) => smtpClient.Dispose();
smtpClient.SendAsync(...);

Ok, vieille question que je connais. Mais je suis tombé sur cela moi-même lorsque j'avais besoin de mettre en œuvre quelque chose de similaire. Je voulais juste partager du code.

J'itère plusieurs SmtpClients pour envoyer plusieurs e-mails de manière asynchrone. Ma solution est similaire à TheCodeKing, mais je supprime l'objet de rappel à la place. Je passe également MailMessage en tant que userToken pour l'obtenir dans l'événement SendCompleted afin que je puisse également appeler Dispose sur cela. Comme ça:

foreach (Customer customer in Customers)
{
    SmtpClient smtpClient = new SmtpClient(); //SmtpClient configuration out of this scope
    MailMessage message = new MailMessage(); //MailMessage configuration out of this scope

    smtpClient.SendCompleted += (s, e) =>
    {
        SmtpClient callbackClient = s as SmtpClient;
        MailMessage callbackMailMessage = e.UserState as MailMessage;
        callbackClient.Dispose();
        callbackMailMessage.Dispose();
    };

    smtpClient.SendAsync(message, message);
}

Vous pouvez voir pourquoi il est particulièrement important de se débarrasser de SmtpClient par le commentaire suivant:

public class SmtpClient : IDisposable
   // Summary:
    //     Sends a QUIT message to the SMTP server, gracefully ends the TCP connection,
    //     and releases all resources used by the current instance of the System.Net.Mail.SmtpClient
    //     class.
    public void Dispose();

Dans mon scénario d'envoi de plusieurs e-mails à l'aide de Gmail sans supprimer le client, j'avais l'habitude d'obtenir:

Message: Service non disponible, fermeture du canal de transmission. La réponse du serveur fut: 4.7.0 Problème système temporaire. Réessayez plus tard (WS). oo3sm17830090pdb.64 - gsmtp