Question

I’m trying to send confirmation mails to users periodically in ASP.NET.

To do this I polulate a queue with mails and check it every 30 seconds. Any confirmation emails in the queue at this time are sent and then cleared from the queue.

Does anyone know how to do this?

Here is my sending mail code

public static bool SendMail(string AdminMail,string AdminPassword,string subject,string toAddress, string content,DateTime SendTime)
        {
            toAddressListProperty.Enqueue(toAddress);

            if(date==null)
            {
                date = DateTime.Now.Second;
            }
            if (date-SendTime.Second > 120)
            {
                    var message = new MailMessage
                                      {
                                          From = new MailAddress(AdminMail)
                                      };

                    foreach (var toAddressl in toAddressListProperty)
                    {
                        message.To.Add(new MailAddress(toAddressl));
                    }

                    message.Subject = subject;
                    message.Body = content;
                    message.IsBodyHtml = true;
                    var smtp = new SmtpClient
                                   {
                                       Credentials = new System.Net.NetworkCredential(AdminMail, AdminPassword),
                                       Port = 587,
                                       Host = "smtp.gmail.com",
                                       EnableSsl = true
                                   };
                    smtp.Send(message);
                //date = SendTime;
                return true;
            }
            return false;
        }

Answer 1

I have done this using a background thread. I did a little research, and I believe this is an ok approach. There are a few dangers, which this blog details.

The main thing is to ensure you never throw an exception from a background thread, as I believe that will cause the web process to restart. Also, incase the thread dies, I ensure it is running on every call.

I have been using this approach for a few months, and so far no issues.

Also I run it every 1 second, this minamizes the amount of time you might loose emails due to an app shutdown.

public class BackgroundSmtpService
{
    private ILog _log = LogManager.GetLogger(typeof(BackgroundSmtpService));
    private readonly SmtpService SmtpService;
    private static Thread _watchThread;
    private static List<Email> _emailToSend = new List<Email>();

    public BackgroundSmtpService(SmtpService smtpService)
    {
        SmtpService = smtpService;
    }

    public void Send(Email email)
    {
        lock (_emailToSend)
        {
            _emailToSend.Add(email);
        }
        EnsureRunning();
    }

    private void EnsureRunning()
    {
        if (_watchThread == null || !_watchThread.IsAlive)
        {
            lock (SmtpService)
            {
                if (_watchThread == null || !_watchThread.IsAlive)
                {
                    _watchThread = new Thread(ThreadStart);
                    _watchThread.Start();
                }
            }
        }
    }

    private void ThreadStart()
    {
        try
        {
            while (true)
            {
                Thread.Sleep(1000);
                try
                {
                    lock (_emailToSend)
                    {
                        var emails = _emailToSend;
                        _emailToSend = new List<Email>();
                        emails.AsParallel().ForAll(a=>SmtpService.Send(a));
                    }
                }
                catch (Exception e)
                {
                    _log.Error("Error during running send emails", e);
                }
            }
        }
        catch (Exception e)
        {
            _log.Error("Error during running send emails, outer", e);
        }
    }
}