Was sind Best Practices für die Verwendung von SmtpClient, SendAsync und Dispose unter .NET 4.0?

Ich bin etwas ratlos darüber, wie SmtpClient jetzt verwaltet wird, da es verfügbar ist, insbesondere wenn ich mit SendAsync telefoniere. Vermutlich sollte ich Dispose nicht aufrufen, bis SendAsync abgeschlossen ist. Aber sollte ich es jemals nennen (zB mit "using"). Das Szenario ist ein WCF-Dienst, der E-Mails regelmäßig versendet, wenn Anrufe getätigt werden. Der Großteil der Berechnung ist schnell, aber das Senden von E-Mails kann ungefähr eine Sekunde dauern, daher wäre Async vorzuziehen.

Sollte ich jedes Mal, wenn ich E-Mails sende, einen neuen SmtpClient erstellen? Soll ich eine für die gesamte WCF erstellen? Hilfe!

Update Falls es einen Unterschied macht, wird jede E-Mail immer an den Benutzer angepasst. Die WCF wird in Azure gehostet und Google Mail wird als Mailer verwendet.

Hinweis: .NET 4.5 SmtpClient implementiert die async awaitableMethode SendMailAsync. Verwenden Sie für niedrigere Versionen SendAsyncwie unten beschrieben.

Sie sollten IDisposableInstanzen immer zum frühestmöglichen Zeitpunkt entsorgen . Bei asynchronen Anrufen erfolgt dies beim Rückruf, nachdem die Nachricht gesendet wurde.

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

Es ist ein bisschen nervig, SendAsyncdass kein Rückruf akzeptiert wird.

Die ursprüngliche Frage wurde für .NET 4 gestellt, aber wenn es ab .NET 4.5 hilft, implementiert SmtpClient eine asynchrone erwartete Methode SendMailAsync .

Das asynchrone Senden von E-Mails ist daher wie folgt:

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

Es ist besser, die SendAsync-Methode zu vermeiden.

Im Allgemeinen sollten IDisposable-Objekte so schnell wie möglich entsorgt werden. Die Implementierung von IDisposable für ein Objekt soll die Tatsache kommunizieren, dass die betreffende Klasse teure Ressourcen enthält, die deterministisch freigegeben werden sollten. Wenn das Erstellen dieser Ressourcen jedoch teuer ist und Sie viele dieser Objekte erstellen müssen, ist es möglicherweise besser (in Bezug auf die Leistung), eine Instanz im Speicher zu belassen und wiederzuverwenden. Es gibt nur einen Weg zu wissen, ob das einen Unterschied macht: Profilieren Sie es!

Re: Entsorgen und Async: Sie können nicht usingoffensichtlich verwenden. Stattdessen entsorgen Sie das Objekt normalerweise im Ereignis SendCompleted:

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

Ok, alte Frage, die ich kenne. Aber ich bin selbst darauf gestoßen, als ich etwas Ähnliches implementieren musste. Ich wollte nur etwas Code teilen.

Ich iteriere über mehrere SmtpClients, um mehrere E-Mails asynchron zu senden. Meine Lösung ähnelt TheCodeKing, aber ich entsorge stattdessen das Rückrufobjekt. Ich übergebe MailMessage auch als userToken, um es im SendCompleted-Ereignis abzurufen, damit ich auch dispose aufrufen kann. So was:

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

Sie können anhand des folgenden Kommentars erkennen, warum es besonders wichtig ist, SmtpClient zu entsorgen:

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

In meinem Szenario, in dem ich mehrere E-Mails mit Google Mail gesendet habe, ohne den Client zu entsorgen, habe ich Folgendes erhalten:

Meldung: Dienst nicht verfügbar, Übertragungskanal geschlossen. Die Serverantwort lautete: 4.7.0 Temporäres Systemproblem. Versuchen Sie es später erneut (WS). oo3sm17830090pdb.64 - gsmtp