Sending 500 email messages using ASP.NET MVC: throttling

Question

I am trying to send 500 e-mail messages to our customers from an ASP.NET MVC 4 web application. I simply use a foreach loop like the one below. After ~50 cycles I get a generic exception saying that the mail message cannot be send. I believe I am dealing with throttling and MS Exchange settings that limit my web application. How do I simply implement throttling to bypass these limits?

Thanks.

foreach (var toAddress in addresses)
{
   var message = new MailMessage(fromAddress, toAddress)
   {
      Subject = subject,
      Body = body
   };

   message.IsBodyHtml = isHtml;

   try
   {
      using (var client = new SmtpClient())
      {
         client.Send(message);
      }
   }
   catch (Exception ex)
   {
      Debug.WriteLine("Cannot send e-mail to " + message.To + Environment.NewLine +
                      "Subject: " + subject + Environment.NewLine +
                      "Body: " + body + Environment.NewLine + 
                      "Exception: " + ex.Message);
   }
}

Answer 1

I would have a look at Quartz.NET and use a service to send the emails off. As far as queuing, maybe look into either a simple file storage or a database.

If you use something like Thread.Sleep, keep in mind you'll be holding up the server from rendering the final output (e.g. if this is triggered via form submit, the resulting view won't be displayed until all emails are sent). By using a library like quartz, you can keep the server responsive to requests while off-loading the email send-off.

Also, for reference, there's another SO post about performing expensive operations without dragging the UX. This can be found here, with (IMHO) the most relevant answer by TheCodeKing.

Answer 2

If you using Exchange 2010 or above there is a RecipientRateLimit throttling policy parameter that specifies the limit on the number of recipients that a user can address in a 24-hour period. If you want get around this limit you will need to change the throttling policy for the user that is sending those messages see http://www.slipstick.com/exchange/limit-number-of-internet-messages-user-can-send/

Cheers Glen

Answer 3

Our scenario is a remote Web Application using a local MS Exchange Server 2010 and the only working solution so far is the following. Using chunks of 20-30 messages every 10 seconds I can send the number of customized e-mail messages I want to our customers without the need to touch the MS Exchange Sever 2010 configuration (it requires many of hours of training). In addition, everything is logged in a TXT file to be sure that the messages were actually sent. I also recommend the MS Exchange Tracking Log Explorer tool to inspect if and what messages were sent.

private void SendBulkEmail(List<KeyValuePair<Customer, Order>> customerList, MailAddress sender, string subject, string body, bool isHtml, string fileNamePrefix)
{
    const int chunkSize = 20;

    string rootPath = Server.MapPath("~");

    string path = Path.GetFullPath(Path.Combine(rootPath, "Logs"));

    string fileName = CommonUtils.GetLogFileName(path, fileNamePrefix);

    int len = customerList.Count;

    TextWriter tw = new StreamWriter(fileName);

    int chunkCount = (len / chunkSize) + 1;
    int remainder = len % chunkSize;

    for (int j = 0; j < chunkCount; j++)
    {
       int start = j * chunkSize;
       int end = start + chunkSize;

       if (j == chunkCount - 1)
       {
           end = start + remainder;
       }

       SmtpClient client = new SmtpClient();

       for (int i = start; i < end; i++)
       {
           Customer customer = customerList[i].Key;

           Guid userGuid = new Guid(customer.UserId.ToString());
           MembershipUser membershipUser = Membership.GetUser(userGuid);

           string memberUsername = membershipUser.UserName;
           string memberEmail = membershipUser.Email;

           SendMessage(sender, recipient, subject, body, tw, client, context);

       }

       client.Dispose();

       Thread.Sleep(10000); // 10 seconds

       tw.WriteLine("Completed chunk #" + j);
   }

   tw.Close();
 }

public static void SendEmail(MailAddress fromAddress, MailAddress toAddress, string subject, string body, TextWriter tw, SmtpClient smtpClient)
{
    MailMessage message = new MailMessage(fromAddress, toAddress)
    {
       Subject = subject,
       Body = body
    };

    try
    {
       smtpClient.Send(message);

       if (tw != null)
       {
          tw.WriteLine("\"" + toAddress + "\",");
       }
    }
    catch (Exception ex)
    {
       if (tw != null)
       {
          tw.WriteLine(toAddress + ": " + ex.Message + " " + ex.InnerException.Message);
       }

       Debug.WriteLine("Cannot send e-mail to " + toAddress + ", " + "Exception: " + ex.Message + (ex.InnerException != null ? ", " + ex.InnerException.Message : string.Empty));
    }
}