Quais são as práticas recomendadas para usar SmtpClient, SendAsync e Dispose no .NET 4.0

Estou um pouco perplexo sobre como gerenciar SmtpClient agora que ele é descartável, especialmente se eu fizer chamadas usando SendAsync. Presumivelmente, não devo chamar Dispose até que SendAsync seja concluído. Mas devo chamá-lo (por exemplo, usando "usando"). O cenário é um serviço WCF que envia e-mails periodicamente quando as chamadas são feitas. A maior parte do cálculo é rápida, mas o envio de e-mail pode levar cerca de um segundo, portanto, o Async seria preferível.

Devo criar um novo SmtpClient cada vez que enviar um e-mail? Devo criar um para todo o WCF? Socorro!

Atualizar Caso faça diferença, cada e-mail é sempre customizado para o usuário. O WCF é hospedado no Azure e o Gmail é usado como remetente.

Nota: .NET 4.5 SmtpClient implementa o async awaitablemétodo SendMailAsync. Para versões anteriores, use SendAsyncconforme descrito abaixo.

Você deve sempre descartar as IDisposableinstâncias o mais rápido possível. No caso de chamadas assíncronas, isso ocorre no retorno de chamada após o envio da mensagem.

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

É um pouco chato SendAsyncporque não aceita uma chamada de retorno.

A pergunta original foi feita para o .NET 4, mas se ajudar a partir do .NET 4.5, SmtpClient implementa o método assíncrono aguardável SendMailAsync.

Como resultado, o envio de e-mail de forma assíncrona é o seguinte:

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

É melhor evitar o uso do método SendAsync.

Em geral, os objetos IDisposable devem ser descartados o mais rápido possível; implementar IDisposable em um objeto tem como objetivo comunicar o fato de que a classe em questão contém recursos caros que deveriam ser liberados de forma determinística. No entanto, se criar esses recursos for caro e você precisar construir muitos desses objetos, pode ser melhor (em termos de desempenho) manter uma instância na memória e reutilizá-la. Só há uma maneira de saber se isso faz alguma diferença: crie um perfil!

Re: descarte e assíncrono: você não pode usar usingobviamente. Em vez disso, você normalmente descarta o objeto no evento SendCompleted:

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

Ok, velha pergunta eu sei. Mas me deparei com isso quando precisava implementar algo semelhante. Eu só queria compartilhar um código.

Estou iterando em vários SmtpClients para enviar vários emails de forma assíncrona. Minha solução é semelhante a TheCodeKing, mas estou descartando o objeto de retorno de chamada. Também estou passando MailMessage como userToken para obtê-lo no evento SendCompleted, para que eu possa chamar dispose nisso também. Como isso:

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

Você pode ver por que é particularmente importante descartar SmtpClient com o seguinte comentário:

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

No meu cenário de envio de vários e-mails usando o Gmail sem descartar o cliente, eu costumava obter:

Mensagem: Serviço indisponível, fechando canal de transmissão. A resposta do servidor foi: 4.7.0 Problema Temporário do Sistema. Tente novamente mais tarde (WS). oo3sm17830090pdb.64 - gsmtp