Асинхронная отправка писем в C #?

Question

Я разрабатываю приложение, в котором пользователь нажимает / нажимает кнопку ввода на определенной кнопке в окне, приложение выполняет некоторые проверки и определяет, следует ли отправлять пару писем или нет, а затем показывает другое окно с сообщением.

Моя проблема в том, что отправка 2-х электронных писем заметно замедляет процесс, и на несколько (~ 8) секунд первое окно выглядит замороженным во время отправки.

Можно ли как-нибудь отправить эти электронные письма на задний план и сразу же отобразить следующее окно?

Пожалуйста, не ограничивайте свой ответ "используйте класс X" или "просто используйте метод X", так как я еще не слишком знаком с языком, и некоторая дополнительная информация будет высоко оценена.

Спасибо.

Answer 1

Начиная с .NET 4.5 SmtpClient реализует асинхронный ожидаемый метод SendMailAsync. В результате асинхронная отправка электронной почты происходит следующим образом:

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

Поскольку это небольшая единица работы, вы должны использовать ThreadPool.QueueUserWorkItem для ее многопоточности.Если вы используете класс SmtpClient для отправки почты, вы можете обработать событие SendCompleted , чтобы отправить отзыв пользователю.

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

Создав новый SMTP-клиенткаждый раз это позволит вам отправлять электронные письма одновременно.

Answer 3

Не слишком сложно просто отправить сообщение в отдельном потоке:

using System.Net.Mail;

Smtp.SendAsync(message);

Или, если вы хотите построить все сообщение в отдельном потоке, а не просто отправлять его асинхронно:

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 4

Метод SmtpClient.SendAsync

Образец

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

Вот подход для запуска и забывания вместе с асинхронным с использованием .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);
});

где 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
            }
        });
    }
}

Работаеткак очарование в службах приложений Azure.

Answer 6

Только потому, что это немного расплывчато ... Я буду краток ...

Есть много способов сделать асинхронную или параллельную работу в c # /. Net и т. Д.

Самый быстрый способ сделать то, что вы хотите, это использовать фоновый рабочий поток, который позволит избежать блокировки вашего пользовательского интерфейса.

Подсказка с фоновыми рабочими потоками: вы не можете напрямую обновлять пользовательский интерфейс из них (привязка потоков и Marshalling)это просто то, с чем ты учишься иметь дело ...)

Еще одна вещь, которую стоит учесть ... если ты используешь стандартные вещи типа System.Net.Mail для отправки писем ... будь осторожен в том, как ты создаешь свойлогика.Если вы изолируете все это в каком-то методе и будете вызывать его снова и снова, то, вероятно, придется каждый раз разрывать и перестраивать соединение с почтовым сервером, и задержка, связанная с аутентификацией и т. Д., Все равно будет излишне замедлять процесс.По возможности отправляйте несколько электронных писем через одно открытое соединение на почтовый сервер.

Answer 7

Попробуйте это:

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

Answer 8

Используйте класс SmtpClient и используйте метод SendAsync в пространстве имен System.Net.Mail.

Answer 9

Используя Task Parallel Library в .NET 4.0, вы можете сделать:

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

Также см. сообщение Кристины Ману о Parallel.Invoke () и явное управление задачами.

Answer 10

Что вы хотите сделать, так это запустить задачу электронной почты в отдельном потоке, чтобы основной код мог продолжить обработку, пока другой поток выполняет работу с электронной почтой.

Вот учебник о том, как это сделать: Учебник по потокам C #