¿Enviar correo electrónico de forma asíncrona en C#?

Question

Estoy desarrollando una aplicación donde un usuario hace clic/presiona ingresar en un botón determinado en una ventana, la aplicación realiza algunas comprobaciones y determina si envía un par de correos electrónicos o no, luego muestra otra ventana con un mensaje.

Mi problema es que enviar los 2 correos electrónicos ralentiza notablemente el proceso, y durante algunos (~ 8) segundos la primera ventana se ve congelada mientras realiza el envío.

¿Hay alguna manera en que pueda hacer que estos correos electrónicos se envíen en segundo plano y mostrar la siguiente ventana de inmediato?

Por favor, no limite su respuesta con "use la clase X" o "simplemente use el método X", ya que aún no estoy muy familiarizado con el idioma y se agradecerá más información.

Gracias.

Answer 1

A partir de .NET 4.5 SmtpClient implementa el método async awaitable SendMailAsync. Como resultado, para enviar correo electrónico de forma asíncrona es el siguiente:

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

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

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

Answer 2

No es demasiado complicado para simplemente enviar el mensaje en un hilo separado:

using System.Net.Mail; 

Smtp.SendAsync(message); 

O, si se quiere construir todo el mensaje en el hilo separado en lugar de algo acaba de enviarlo de forma asíncrona:

using System.Threading; 
using System.Net.Mail; 

var sendMailThread = new Thread(() => { 
    var message=new MailMessage(); 
    message.From="from e-mail"; 
    message.To="to e-mail"; 
    message.Subject="Message Subject"; 
    message.Body="Message Body"; 

    SmtpMail.SmtpServer="SMTP Server Address"; 
    SmtpMail.Send(message); 
}); 

sendMailThread.Start(); 

Answer 3

Lo que quiere hacer es ejecutar la tarea de correo electrónico en un hilo separado para que el código principal pueda continuar el procesamiento mientras que el otro hilo funciona el correo electrónico.

Aquí es un tutorial sobre cómo hacerlo: Threading Tutorial C#

Answer 4

SmtpClient.SendAsync Method

Muestra

using System; 
using System.Net; 
using System.Net.Mail; 
using System.Net.Mime; 
using System.Threading; 
using System.ComponentModel; 
namespace Examples.SmptExamples.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 the the SMTP host. 
      SmtpClient client = new SmtpClient(args[0]); 
      // Specify the e-mail 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 e-mail message. 
      MailAddress to = new MailAddress("ben@contoso.com"); 
      // Specify the message content. 
      MailMessage message = new MailMessage(from, to); 
      message.Body = "This is a test e-mail 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."); 
     } 
    } 
} 

Answer 5

la solución más fácil es crear un BackgroundWorker y empujar los correos en una cola. Luego solo deje que BackgroundWorker revise la cola y envíe cada correo.

Ver también How to: Run an Operation in the Background

Answer 6

utilizar la clase SmtpClient y utilizar el método SendAsync en el espacio de nombres System.Net.Mail.

Answer 7

El hecho de que esto es un poco vago ... Voy a ser breve ...

Hay un montón de maneras de hacer el trabajo asíncrono o paralelo en C# /. Net etc.

el más rápido La forma de hacer lo que desea es usar un hilo de trabajador de fondo que evitará bloquear su UI.

Una punta con subprocesos de trabajo de fondo: no se puede actualizar directamente a la interfaz de usuario de ellos (afinidad hilo y Marshalling es sólo algo que se aprende a tratar con ...)

Otra cosa a tener en cuenta ... si se utiliza el tipo de cosas estándar de System.Net.Mail para enviar los correos electrónicos ... tenga cuidado de cómo elabora su lógica. Si aisla todo en algún método y lo llama una y otra vez, probablemente tendrá que demoler y reconstruir la conexión con el servidor de correo cada vez y la latencia involucrada en la autenticación, etc., ralentizará todo el proceso innecesariamente. Envíe múltiples correos electrónicos a través de una única conexión abierta al servidor de correo cuando sea posible.

Answer 8

Prueba esto:

var client = new System.Net.Mail.SmtpClient("smtp.server"); 
var message = new System.Net.Mail.MailMessage() { /* provide its properties */ }; 
client.SendAsync(message, null); 

Answer 9

Utilizando el Task Parallel Library en .NET 4.0, que puede hacer:

Parllel.Invoke(() => { YourSendMailMethod(); }); 

Además, vea cristina manu's el blog post sobre Parallel.Invoke() frente a la gestión de tareas explícito .

Answer 10

Como es una pequeña unidad de trabajo, debe usar ThreadPool.QueueUserWorkItem para el aspecto de roscado de la misma. Si usa la clase SmtpClient para enviar su correo, puede manejar el evento SendCompleted para enviar comentarios al usuario.

ThreadPool.QueueUserWorkItem(t => 
{ 
    SmtpClient client = new SmtpClient("MyMailServer"); 
    MailAddress from = new MailAddress("me@mydomain.com", "My Name", System.Text.Encoding.UTF8); 
    MailAddress to = new MailAddress("someone@theirdomain.com"); 
    MailMessage message = new MailMessage(from, to); 
    message.Body = "The message I want to send."; 
    message.BodyEncoding = System.Text.Encoding.UTF8; 
    message.Subject = "The subject of the email"; 
    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, I am passing the message itself 
    client.SendAsync(message, message); 
}); 

private static void SendCompletedCallback(object sender, AsyncCompletedEventArgs e) 
{ 
     // Get the message we sent 
     MailMessage msg = (MailMessage)e.UserState; 

     if (e.Cancelled) 
     { 
      // prompt user with "send cancelled" message 
     } 
     if (e.Error != null) 
     { 
      // prompt user with error message 
     } 
     else 
     { 
      // prompt user with message sent! 
      // as we have the message object we can also display who the message 
      // was sent to etc 
     } 

     // finally dispose of the message 
     if (msg != null) 
      msg.Dispose(); 
} 

Al crear un cliente SMTP nuevo cada vez esto le permitirá enviar correos electrónicos simultáneamente.

Answer 11

Aquí es fuego y olvidarse enfoque junto con asíncrono usando .Net 4.5.2+:

BackgroundTaskRunner.FireAndForgetTaskAsync(async() => 
{ 
    SmtpClient smtpClient = new SmtpClient(); // using configuration file settings 
    MailMessage message = new MailMessage(); // TODO: Initialize appropriately 
    await smtpClient.SendMailAsync(message); 
}); 

donde es BackgroundTaskRunner :

public static class BackgroundTaskRunner 
{  
    public static void FireAndForgetTask(Action action) 
    { 
     HostingEnvironment.QueueBackgroundWorkItem(cancellationToken => // .Net 4.5.2+ required 
     { 
      try 
      { 
       action(); 
      } 
      catch (Exception e) 
      { 
       // TODO: handle exception 
      } 
     }); 
    } 

    /// <summary> 
    /// Using async 
    /// </summary> 
    public static void FireAndForgetTaskAsync(Func<Task> action) 
    { 
     HostingEnvironment.QueueBackgroundWorkItem(async cancellationToken => // .Net 4.5.2+ required 
     { 
      try 
      { 
       await action(); 
      } 
      catch (Exception e) 
      { 
       // TODO: handle exception 
      } 
     }); 
    } 
} 

Funciona como un encanto en Azure App Services.