Quali sono le migliori pratiche per l'utilizzo di SmtpClient, SendAsync e Dispose in .NET 4.0

Sono un po 'perplesso su come gestire SmtpClient ora che è usa e getta, soprattutto se effettuo chiamate utilizzando SendAsync. Presumibilmente non dovrei chiamare Dispose fino al completamento di SendAsync. Ma dovrei mai chiamarlo (ad esempio, usando "using"). Lo scenario è un servizio WCF che invia periodicamente messaggi di posta elettronica quando vengono effettuate le chiamate. La maggior parte del calcolo è veloce, ma l'invio di e-mail può richiedere circa un secondo, quindi Async sarebbe preferibile.

Devo creare un nuovo SmtpClient ogni volta che invio la posta? Devo crearne uno per l'intero WCF? Aiuto!

Aggiorna Nel caso in cui faccia la differenza, ogni email è sempre personalizzata per l'utente. Il WCF è ospitato su Azure e Gmail viene utilizzato come mailer.

Nota: .NET 4.5 SmtpClient implementa il async awaitablemetodo SendMailAsync. Per le versioni inferiori, utilizzare SendAsynccome descritto di seguito.

Dovresti sempre smaltire le IDisposableistanze il prima possibile. Nel caso di chiamate asincrone, questa è sulla richiamata dopo l'invio del messaggio.

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);

È un po 'fastidioso il SendAsyncnon accettare una richiamata.

La domanda originale è stata posta per .NET 4, ma se aiuta a partire da .NET 4.5 SmtpClient implementa il metodo di attesa asincrono SendMailAsync.

Di conseguenza, inviare messaggi di posta elettronica in modo asincrono è il seguente:

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);
        }
    }
}

È meglio evitare di utilizzare il metodo SendAsync.

In generale, gli oggetti IDisposable dovrebbero essere smaltiti il ​​prima possibile; l'implementazione di IDisposable su un oggetto ha lo scopo di comunicare il fatto che la classe in questione contiene risorse costose che dovrebbero essere rilasciate in modo deterministico. Tuttavia, se la creazione di queste risorse è costosa ed è necessario costruire molti di questi oggetti, potrebbe essere meglio (in termini di prestazioni) mantenere un'istanza in memoria e riutilizzarla. C'è solo un modo per sapere se questo fa la differenza: profilalo!

Re: disposing e Async: usingovviamente non puoi usare . Invece in genere si elimina l'oggetto nell'evento SendCompleted:

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

Ok, vecchia domanda lo so. Ma mi sono imbattuto in questo io stesso quando avevo bisogno di implementare qualcosa di simile. Volevo solo condividere del codice.

Sto iterando su diversi SmtpClient per inviare diversi messaggi in modo asincrono. La mia soluzione è simile a TheCodeKing, ma invece sto eliminando l'oggetto callback. Sto anche passando MailMessage come userToken per ottenerlo nell'evento SendCompleted in modo da poter chiamare dispose anche su quello. Come questo:

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);
}

Puoi capire perché è particolarmente importante smaltire SmtpClient dal seguente commento:

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();

Nel mio scenario l'invio di più messaggi di posta utilizzando Gmail senza eliminare il client, ero solito ottenere:

Messaggio: servizio non disponibile, chiusura canale di trasmissione. La risposta del server è stata: 4.7.0 Problema di sistema temporaneo. Riprova più tardi (WS). oo3sm17830090pdb.64 - gsmtp