MailHelper
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Mail;
using System.Net.Mime;
using System.Text;
using System.Threading;
using System.Web;
namespace MailHelpers
{
/// <summary>
/// MailHelper 的摘要说明
/// </summary>
public class MailHelper
{
#region 构造函数
/// <summary>
/// 构建 MailHelper 实例
/// </summary>
public MailHelper()
{
}
/// <summary>
/// 构建 MailHelper 实例
/// </summary>
/// <param name="smtpclient">smtp服务器地址</param>
/// <param name="port">端口</param>
/// <param name="user">用户名</param>
/// <param name="password">密码</param>
public MailHelper(string smtpclient = null, int port = 0, string user = null, string password = null)
{
SmtpClientAdd = smtpclient;
Port = port;
User = user;
Password = password;
}
/// <summary>
/// 构建 MailHelper 实例
/// </summary>
/// <param name="mSmtpClient">SmtpClient实例</param>
/// <param name="autoReleaseSmtp">是否自动释放SmtpClient实例</param>
public MailHelper(SmtpClient mSmtpClient, bool autoReleaseSmtp)
{
SetSmtpClient(mSmtpClient, autoReleaseSmtp);
}
#endregion 构造函数
#region 公开属性
private int priority = 0;
/// <summary>
/// 设置此电子邮件的密送地址列表，分号(;)分隔。
/// </summary>
public string Bcc { get; set; }
/// <summary>
/// 设置邮件正文。
/// </summary>
public string Body { get; set; }
/// <summary>
/// 设置此电子邮件的抄送地址列表，分号(;)分隔。
/// </summary>
public string Cc { get; set; }
/// <summary>
/// 设置此电子邮件的发信人地址。
/// </summary>
public string From { get; set; }
/// <summary>
/// 设置此电子邮件的发信人地址。
/// </summary>
public string FromDisplayName { get; set; }
/// <summary>
/// 设置邮件正文是否为 Html 格式的值。
/// </summary>
public bool IsBodyHtml { get; set; }
/// <summary>
/// 异步发送标志
/// </summary>
public bool m_IsAsync { get; set; }
/// <summary>
/// 设置此电子邮件的优先级 0-Normal 1-Low 2-High
/// 默认Normal。
/// </summary>
public int Priority
{
get { return this.priority; }
set
{
if (value < 0 || value > 2)
priority = 0;
else
priority = value;
}
}
/// <summary>
/// 设置此电子邮件的主题。
/// </summary>
public string Subject { get; set; }
/// <summary>
/// 设置此电子邮件的收件地址列表，分号(;)分隔。
/// </summary>
public string To { get; set; }
#endregion 公开属性
#region 内部字段、属性
/// <summary>
/// 默认为false。设置在 MailHelper 类内部，发送完邮件后是否自动释放 SmtpClient 实例
/// Smtp不管是在 MailHelper 内部还是在外部都必须进行主动释放，
/// 因为：SmtpClient 没有提供 Finalize() 终结器，所以GC不会进行回收，只能使用完后主动进行释放，否则会发生内存泄露问题。
///
/// 何时将 autoReleaseSmtp 设置为false，就是SmtpClient需要重复使用的情况，即需要使用“相同MailHelper”向“相同Smtp服务器”发送大批量的邮件时。
/// </summary>
private bool m_autoDisposeSmtp = false;
// 指定一个电子邮件不同格式显示的副本。
private Collection<AlternateView> AlternateViews { get; set; }
// 附件集合
private Collection<Attachment> Attachments { get; set; }
private SmtpClient m_SmtpClient { get; set; }
/// <summary>
/// smtp密码
/// </summary>
private string Password { get; set; }
/// <summary>
/// smtp端口
/// </summary>
private int Port { get; set; }
/// <summary>
/// smtp服务器地址
/// </summary>
private string SmtpClientAdd { get; set; }
/// <summary>
/// smtp用户名
/// </summary>
private string User { get; set; }
#endregion 内部字段、属性
#region 计划邮件数量 和 已执行完成邮件数量
// 记录和获取在大批量执行异步短信发送时已经处理了多少条记录
// 1、根据此值手动或自动释放 SmtpClient .实际上没有需要根据此值进行手动释放，因为完全可以用自动释放替换此逻辑
// 2、根据此值可以自己设置进度
private long m_CompletedSendCount = 0;
// 计划邮件数量
private long m_PrepareSendCount = 0;
public long CompletedSendCount
{
get { return Interlocked.Read(ref m_CompletedSendCount); }
private set { Interlocked.Exchange(ref m_CompletedSendCount, value); }
}
public long PrepareSendCount
{
get { return Interlocked.Read(ref m_PrepareSendCount); }
private set { Interlocked.Exchange(ref m_PrepareSendCount, value); }
}
#endregion 计划邮件数量 和 已执行完成邮件数量
#region 异步 发送邮件相关参数
// 案例：因为异步发送邮件在SmtpClient处必须加锁保证一封一封的发送。
// 这样阻塞了主线程。所以换用队列的方式以无阻塞的方式进行异步发送大批量邮件
private AutoResetEvent m_AutoResetEvent = null;
// 因为 MessageQueue 可能在 m_SendMailThread 线程中进行出队操作,所以使用并发队列ConcurrentQueue.
// 队列中的数据只能通过取消异步发送进行清空，或则就会每一元素都执行发送邮件
private ConcurrentQueue<MailUserState> m_MessageQueue = null;
// 待发送队列缓存数量。单独开个计数是为了提高获取此计数的效率
private int m_messageQueueCount = 0;
// 发送任务可能很长，所以使用 Thread 而不是用ThreadPool。（避免长时间暂居线程池线程），并且SmtpClient只支持一次一封邮件发送
private Thread m_SendMailThread = null;
/// <summary>
/// 在执行异步发送时传递的对象，用于传递给异步发生完成时调用的方法 OnSendCompleted 。
/// </summary>
public object AsycUserState { get; set; }
private AutoResetEvent AutoResetEvent
{
get
{
if (m_AutoResetEvent == null)
m_AutoResetEvent = new AutoResetEvent(true);
return m_AutoResetEvent;
}
}
private ConcurrentQueue<MailUserState> MessageQueue
{
get
{
if (m_MessageQueue == null)
m_MessageQueue = new ConcurrentQueue<MailUserState>();
return m_MessageQueue;
}
}
#endregion 异步 发送邮件相关参数
#region SmtpClient 相关方法
/// <summary>
/// 根据默认值创建一个链接
/// </summary>
public SmtpClient CreatSmtpClient()
{
var smtp = new SmtpClient(SmtpClientAdd, Port);
smtp.EnableSsl = false;
smtp.UseDefaultCredentials = false;
smtp.DeliveryMethod = SmtpDeliveryMethod.Network;
smtp.Credentials = new NetworkCredential(User, Password);
smtp.Timeout = 100000;
return smtp;
}
/// <summary>
/// 检查此 MailHelper 实例是否已经设置了 SmtpClient
/// </summary>
/// <returns>true代表已设置</returns>
public bool ExistsSmtpClient()
{
return m_SmtpClient != null;
}
/// <summary>
/// 释放 SmtpClient
/// </summary>
public void ManualDisposeSmtp()
{
this.InnerDisposeSmtp();
}
/// <summary>
/// 设置 SmtpClient 实例 和是否自动释放Smtp的唯一入口
/// 1、将内部 计划数量 和 已完成数量 清零，重新统计以便自动释放SmtpClient
/// 2、若要对SmtpClent设置SendCompleted事件，请在调用此方法前进行设置
/// </summary>
/// <param name="mSmtpClient"> SmtpClient 实例</param>
/// <param name="autoReleaseSmtp">设置在 MailHelper 类内部，发送完邮件后是否自动释放 SmtpClient 实例</param>
public void SetSmtpClient(SmtpClient mSmtpClient, bool autoReleaseSmtp)
{
//#if DEBUG
// Debug.WriteLine("设置SmtpClient,自动释放为" + (autoReleaseSmtp ? "TRUE" : "FALSE"));
//#endif
m_SmtpClient = mSmtpClient;
m_autoDisposeSmtp = autoReleaseSmtp;
// 将内部 计划数量 和 已完成数量 清零，重新统计以便自动释放SmtpClient (MailHelper实例唯一的清零地方)
//m_PrepareSendCount = 0;
m_CompletedSendCount = 0;
// 注册回调事件.释放对象---该事件不进行取消注册，只在释放SmtpClient时，一起释放 （所以SmtpClient与MailHelper绑定后，就不要再单独使用了）
m_SmtpClient.SendCompleted += SendCompleted4Dispose;
}
/// <summary>
/// 释放SmtpClient
/// </summary>
private void AutoDisposeSmtp()
{
if (m_autoDisposeSmtp && m_SmtpClient != null)
{
if (PrepareSendCount == 0)
{
// PrepareSendCount=0 说明还未设置计划批量邮件数，所以不自动释放SmtpClient。
// 不能因为小于CompletedSendCount就报错，因为可能是先发送再设置计划邮件数量
}
else if (PrepareSendCount < CompletedSendCount)
{
throw new Exception(MailValidatorHelper.EMAIL_ASYNC_SEND_PREPARE_ERROR);
}
else if (PrepareSendCount == CompletedSendCount)
{
InnerDisposeSmtp();
}
}
else
{
// 不清空和Dispose()内部的SmtpClient字段，即用在需要重复使用时不需要再调用 SetSmtpClient() 进行设置。
}
}
/// <summary>
/// 释放SmtpClient
/// </summary>
private void InnerDisposeSmtp()
{
if (m_SmtpClient != null)
{
//#if DEBUG
// Debug.WriteLine("释放SMtpClient");
//#endif
m_SmtpClient.Dispose();
m_SmtpClient = null;
// 在设置 SmtpClient 入口处重新进行设置
m_autoDisposeSmtp = false;
PrepareSendCount = 0;
CompletedSendCount = 0;
}
}
#endregion SmtpClient 相关方法
#region 发送邮件 相关方法
/// <summary>
/// 取消异步邮件发送
/// </summary>
public void SendAsyncCancel()
{
// 因为此类为非线程安全类，所以 SendAsyncCancel 和发送邮件方法中操作MessageQueue部分的代码肯定是串行化的。
// 所以不存在一边入队，一边出队导致无法完全取消所有邮件发送
// 1、清空队列。
// 2、取消正在异步发送的mail。
// 3、设置计划数量=完成数量
// 4、执行 AutoDisposeSmtp()
// 1、清空队列。
MailUserState tempMailUserState = null;
while (MessageQueue.TryDequeue(out tempMailUserState))
{
Interlocked.Decrement(ref m_messageQueueCount);
MailMessage message = tempMailUserState.CurMailMessage;
InnerDisposeMessage(message);
}
tempMailUserState = null;
// 2、取消正在异步发送的mail。
m_SmtpClient.SendAsyncCancel();
// 3、设置计划数量=完成数量
PrepareSendCount = CompletedSendCount;
// 4、执行 AutoDisposeSmtp()
AutoDisposeSmtp();
}
/// <summary>
/// 发送一封邮件
/// </summary>
/// <param name="subject">邮件标题</param>
/// <param name="body">邮件正文</param>
/// <param name="to">收件列表(;分隔)</param>
/// <param name="cc">抄送列表(;分隔)</param>
/// <param name="bcc">密送列表(;分隔)</param>
public void SendMail(string subject, string body, string to, string cc = null, string bcc = null, string from = null, string fromName = null)
{
SetMailInfo(subject, body, to, cc, bcc, from, fromName);
m_PrepareSendCount = 1;
SendMail();
}
/// <summary>
/// 发送邮件
/// </summary>
/// <param name="smtpClient">smtp链接，如不设置则自动根据默认值创建一个</param>
/// <param name="autoReleaseSmtp">是否自动释放smtp链接</param>
public void SendMail(SmtpClient smtpClient = null, bool autoReleaseSmtp = true)
{
SetSmtpClient(smtpClient ?? CreatSmtpClient(), autoReleaseSmtp);
InnerSendMessage();
}
/// <summary>
/// 计划批量发送邮件的个数，配合自动释放SmtpClient。（批量邮件发送不调用此方法就不会自动释放SmtpClient）
/// 0、此方法可以在发送邮件方法之前或之后调用
/// 1、只有设置后才会自动根据 m_autoDisposeSmtp 字段进行释放SmtpClient。
/// 2、若 m_autoDisposeSmtp = false 即由自己手动进行设置的无需调用此方法设置预计邮件数
/// </summary>
/// <param name="preCount">计划邮件数量</param>
public void SetBatchMailCount(long preCount)
{
PrepareSendCount = preCount;
if (preCount < CompletedSendCount)
{
throw new ArgumentOutOfRangeException(nameof(preCount), MailValidatorHelper.EMAIL_ASYNC_SEND_PREPARE_ERROR);
}
if (preCount == CompletedSendCount)
{
if (m_autoDisposeSmtp)
InnerDisposeSmtp();
}
}
/// <summary>
/// 设置邮件基本信息
/// </summary>
/// <param name="subject">邮件标题</param>
/// <param name="body">邮件正文</param>
/// <param name="to">收件列表(;分隔)</param>
/// <param name="cc">抄送列表(;分隔)</param>
/// <param name="bcc">密送列表(;分隔)</param>
/// <param name="isbodyhtml">邮件内容是否html格式</param>
/// <param name="priority">邮件优先级 0-Normal 1-Low 2-High</param>
public void SetMailInfo(string subject, string body, string to, string cc = null, string bcc = null, string from = null, string fromName = null, bool isbodyhtml = true, int priority = 0)
{
Subject = subject;
Body = body;
To = to;
Cc = cc ?? "";
Bcc = bcc ?? "";
From = from ?? "";
FromDisplayName = fromName ?? "";
IsBodyHtml = isbodyhtml;
Priority = priority;
}
/// <summary>
/// 声明在 SmtpClient.SendAsync() 执行完后释放相关对象的回调方法 最后触发的委托
/// </summary>
protected void SendCompleted4Dispose(object sender, AsyncCompletedEventArgs e)
{
MailUserState state = e.UserState as MailUserState;
if (state.CurMailMessage != null)
{
MailMessage message = state.CurMailMessage;
this.InnerDisposeMessage(message);
state.CurMailMessage = null;
}
if (state.IsSmpleMail)
{
if (state.AutoReleaseSmtp && state.CurSmtpClient != null)
{
//#if DEBUG
// Debug.WriteLine("释放SmtpClient");
//#endif
state.CurSmtpClient.Dispose();
state.CurSmtpClient = null;
}
}
else
{
if (!e.Cancelled) // 取消的就不计数
CompletedSendCount++;
if (state.AutoReleaseSmtp)
{
AutoDisposeSmtp();
}
// 若批量异步发送，需要设置信号
//#if DEBUG
// Debug.WriteLine("Set" + Thread.CurrentThread.ManagedThreadId);
//#endif
AutoResetEvent.Set();
}
// 先释放资源，处理错误逻辑
if (e.Error != null && !state.IsErrorHandle)
{
throw e.Error;
}
}
private MailMessage CreateMessagex()
{
#region 构建 MailMessage
bool hasError = false;
var mMailMessage = new MailMessage();
try
{
mMailMessage.From = new MailAddress(From, FromDisplayName);
//增加收件人地址等
foreach (var item in To.Split(';'))//.Where(s => MailValidatorHelper.IsEmail(s)))
{
mMailMessage.To.Add(item);
}
if (!string.IsNullOrEmpty(Cc))
{
foreach (var item in Cc.Split(';').Where(s => MailValidatorHelper.IsEmail(s)))
{
mMailMessage.CC.Add(item);
}
}
if (!string.IsNullOrEmpty(Bcc))
{
foreach (var item in Bcc.Split(';').Where(s => MailValidatorHelper.IsEmail(s)))
{
mMailMessage.Bcc.Add(item);
}
}
mMailMessage.Subject = Subject;
mMailMessage.Body = Body;
if (Attachments != null && Attachments.Count > 0)
{
foreach (Attachment attachment in Attachments)
mMailMessage.Attachments.Add(attachment);
}
mMailMessage.SubjectEncoding = Encoding.UTF8;
mMailMessage.BodyEncoding = Encoding.UTF8;
// SmtpClient 的 Headers 中会根据 MailMessage 默认设置些值，所以应该为 UTF8 。
mMailMessage.HeadersEncoding = Encoding.UTF8;
mMailMessage.IsBodyHtml = IsBodyHtml;
if (AlternateViews != null && AlternateViews.Count > 0)
{
foreach (AlternateView alternateView in AlternateViews)
{
mMailMessage.AlternateViews.Add(alternateView);
}
}
mMailMessage.Priority = (MailPriority)Priority;
}
catch (ArgumentNullException argumentNullEx)
{
hasError = true;
throw argumentNullEx;
}
catch (ArgumentException argumentEx)
{
hasError = true;
throw argumentEx;
}
catch (FormatException formatEx)
{
hasError = true;
throw formatEx;
}
finally
{
if (hasError)
{
if (mMailMessage != null)
{
this.InnerDisposeMessage(mMailMessage);
mMailMessage = null;
}
this.InnerDisposeSmtp();
}
}
return mMailMessage;
#endregion 构建 MailMessage
}
/// <summary>
/// 释放 MailMessage 对象
/// </summary>
private void InnerDisposeMessage(MailMessage message)
{
if (message != null)
{
if (message.AlternateViews.Count > 0)
{
message.AlternateViews.Dispose();
}
message.Dispose();
message = null;
}
}
/// <summary>
/// 发送Email
/// </summary>
private void InnerSendMessage()
{
bool hasError = false;
var msg = CheckSendMail();
if (msg.Count > 0)
{
throw new FormatException(MailInfoHelper.GetMailInfoStr(msg));
}
var mMailMessage = CreateMessagex();
if (!hasError)
{
if (m_IsAsync)
{
#region 异步发送邮件
if (PrepareSendCount == 1)
{
// 情况一：不重用 SmtpClient 实例会将PrepareSendCount设置为1
// 情况二：计划发送只有一条
// PrepareSendCount 是发送单条邮件。
MailUserState state = new MailUserState()
{
AutoReleaseSmtp = m_autoDisposeSmtp,
CurMailMessage = mMailMessage,
CurSmtpClient = m_SmtpClient,
IsSmpleMail = true,
UserState = AsycUserState,
};
if (m_autoDisposeSmtp)
// 由发送完成回调函数根据 IsSmpleMail 字段进行释放
m_SmtpClient = null;
ThreadPool.QueueUserWorkItem((userState) =>
{
// 无需 catch 发送异常，因为是异步，所以这里 catch 不到。
MailUserState curUserState = userState as MailUserState;
curUserState.CurSmtpClient.SendAsync(mMailMessage, userState);
}, state);
}
else
{
// 情况一：重用 SmtpClient 逻辑，即我们可以直接操作全局的 m_SmtpClient
// 情况二：批量发送邮件 PrepareSendCount>1
// 情况三：PrepareSendCount 还未设置，为0。比如场景在循环中做些判断，再决定发邮件，循环完才调用 SetBatchMailCount 设置计划邮件数量
MailUserState state = new MailUserState()
{
AutoReleaseSmtp = m_autoDisposeSmtp,
CurMailMessage = mMailMessage,
CurSmtpClient = m_SmtpClient,
UserState = AsycUserState,
};
MessageQueue.Enqueue(state);
Interlocked.Increment(ref m_messageQueueCount);
if (m_SendMailThread == null)
{
m_SendMailThread = new Thread(() =>
{
// noItemCount 次获取不到元素，就抛出线程异常
int noItemCount = 0;
while (true)
{
if (PrepareSendCount != 0 && PrepareSendCount == CompletedSendCount)
{
// 已执行完毕。
this.AutoDisposeSmtp();
break;
}
else
{
MailUserState curUserState = null;
if (!MessageQueue.IsEmpty)
{
//#if DEBUG
// Debug.WriteLine("WaitOne" + Thread.CurrentThread.ManagedThreadId);
//#endif
// 当执行异步取消时，会清空MessageQueue，所以 WaitOne 必须在从MessageQueue中取到元素之前
AutoResetEvent.WaitOne();
if (MessageQueue.TryDequeue(out curUserState))
{
Interlocked.Decrement(ref m_messageQueueCount);
m_SmtpClient.SendAsync(curUserState.CurMailMessage, curUserState);
}
}
else
{
if (noItemCount >= 10)
{
// 没有正确设置 PrepareSendCount 值。导致已没有邮件但此线程出现死循环
this.InnerDisposeSmtp();
throw new Exception(MailValidatorHelper.EMAIL_PREPARESENDCOUNT_NOTSET_ERROR);
}
Thread.Sleep(1000);
noItemCount++;
}
}
// SmtpClient 为null表示异步预计发送邮件数已经发送完，在 OnSendCompleted 进行了 m_SmtpClient 释放
if (m_SmtpClient == null)
break;
}
m_SendMailThread = null;
});
m_SendMailThread.Start();
}
}
#endregion 异步发送邮件
}
else
{
#region 同步发送邮件
try
{
m_SmtpClient.Send(mMailMessage);
m_CompletedSendCount++;
}
catch (ObjectDisposedException smtpDisposedEx)
{
throw smtpDisposedEx;
}
catch (InvalidOperationException smtpOperationEx)
{
throw smtpOperationEx;
}
catch (SmtpFailedRecipientsException smtpFailedRecipientsEx)
{
throw smtpFailedRecipientsEx;
}
catch (SmtpException smtpEx)
{
throw smtpEx;
}
finally
{
if (mMailMessage != null)
{
InnerDisposeMessage(mMailMessage);
mMailMessage = null;
}
AutoDisposeSmtp();
}
#endregion 同步发送邮件
}
}
}
private void InnerSendMessageSync()
{
var msg = CheckSendMail();
if (msg.Count > 0)
{
throw new FormatException(MailInfoHelper.GetMailInfoStr(msg));
}
try
{
var mMailMessage = CreateMessagex();
#region 异步发送邮件
if (PrepareSendCount == 1)
{
// 情况一：不重用 SmtpClient 实例会将PrepareSendCount设置为1
// 情况二：计划发送只有一条
m_SmtpClient.SendAsync(mMailMessage, AsycUserState);
if (m_autoDisposeSmtp)
{
m_SmtpClient = null;
}
}
else
{
// 情况一：重用 SmtpClient 逻辑，即我们可以直接操作全局的 m_SmtpClient
// 情况二：批量发送邮件 PrepareSendCount>1
// 情况三：PrepareSendCount 还未设置，为0。比如场景在循环中做些判断，再决定发邮件，循环完才调用 SetBatchMailCount 设置计划邮件数量
MailUserState state = new MailUserState()
{
AutoReleaseSmtp = m_autoDisposeSmtp,
CurMailMessage = mMailMessage,
CurSmtpClient = m_SmtpClient,
UserState = AsycUserState,
};
MessageQueue.Enqueue(state);
Interlocked.Increment(ref m_messageQueueCount);
if (m_SendMailThread == null)
{
m_SendMailThread = new Thread(() =>
{
// noItemCount 次获取不到元素，就抛出线程异常
int noItemCount = 0;
while (true)
{
if (PrepareSendCount != 0 && PrepareSendCount == CompletedSendCount)
{
// 已执行完毕。
this.AutoDisposeSmtp();
break;
}
else
{
MailUserState curUserState = null;
if (!MessageQueue.IsEmpty)
{
//#if DEBUG
// Debug.WriteLine("WaitOne" + Thread.CurrentThread.ManagedThreadId);
//#endif
// 当执行异步取消时，会清空MessageQueue，所以 WaitOne 必须在从MessageQueue中取到元素之前
AutoResetEvent.WaitOne();
if (MessageQueue.TryDequeue(out curUserState))
{
Interlocked.Decrement(ref m_messageQueueCount);
m_SmtpClient.SendAsync(curUserState.CurMailMessage, curUserState);
}
}
else
{
if (noItemCount >= 10)
{
// 没有正确设置 PrepareSendCount 值。导致已没有邮件但此线程出现死循环
this.InnerDisposeSmtp();
throw new Exception(MailValidatorHelper.EMAIL_PREPARESENDCOUNT_NOTSET_ERROR);
}
Thread.Sleep(1000);
noItemCount++;
}
}
// SmtpClient 为null表示异步预计发送邮件数已经发送完，在 OnSendCompleted 进行了 m_SmtpClient 释放
if (m_SmtpClient == null)
break;
}
m_SendMailThread = null;
});
m_SendMailThread.Start();
}
}
#endregion 异步发送邮件
}
catch (Exception e)
{
throw new FormatException(e.Message);
}
}
#endregion 发送邮件 相关方法
#region 异步发送邮件，MessageQueue队列中缓冲的待发邮件数量，使用者可根据此数量来限制邮件数量，以免内存浪费
/// <summary>
/// 获取异步发送邮件，MessageQueue队列中缓冲的待发邮件数量
/// （使用者可根据此数量来限制邮件数量，以免内存浪费）
/// </summary>
public int GetAwaitMailCountAsync()
{
return Thread.VolatileRead(ref m_messageQueueCount);
}
#endregion 异步发送邮件，MessageQueue队列中缓冲的待发邮件数量，使用者可根据此数量来限制邮件数量，以免内存浪费
#region 发送邮件前检查 相关方法
/// <summary>
/// 发送邮件前检查需要设置的信息是否完整，收集（提示+错误）信息
/// </summary>
public Dictionary<MailInfoType, string> CheckSendMail()
{
Dictionary<MailInfoType, string> dicMsg = new Dictionary<MailInfoType, string>();
InnerCheckSendMail4Info(dicMsg);
InnerCheckSendMail4Error(dicMsg);
return dicMsg;
}
/// <summary>
/// 发送邮件前检查需要设置的信息是否完整，收集 错误 信息
/// </summary>
/// <param name="dicMsg">将检查信息收集到此集合</param>
private void InnerCheckSendMail4Error(Dictionary<MailInfoType, string> dicMsg)
{
#region 处理 发件/收件
if (string.IsNullOrEmpty(From))
{
From = "h3bpm@renolit.com.cn";
FromDisplayName = "h3bpm";
}
else
{
if (!MailValidatorHelper.IsEmail(From))
{
string strTemp = string.Format(MailInfoHelper.GetMailInfoStr(MailInfoType.FromFormat), FromDisplayName, From);
dicMsg.Add(MailInfoType.FromFormat, strTemp);
}
}
if (string.IsNullOrEmpty(To))
{
dicMsg.Add(MailInfoType.ToEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.ToEmpty));
}
else
{
foreach (var item in To.Split(';'))
{
if (!MailValidatorHelper.IsEmail(item))
{
string strTemp = string.Format(MailInfoHelper.GetMailInfoStr(MailInfoType.ToFormat), item, item);
dicMsg.Add(MailInfoType.ToFormat, strTemp);
}
}
}
#endregion 处理 发件/收件
// SmtpClient 实例未设置
if (m_SmtpClient == null)
dicMsg.Add(MailInfoType.SmtpClientEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.SmtpClientEmpty));
else
{
// SMTP 主服务器设置 （默认端口为25）
if (m_SmtpClient.Host.Length == 0)
dicMsg.Add(MailInfoType.HostEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.HostEmpty));
// SMPT 凭证
if (m_SmtpClient.EnableSsl && m_SmtpClient.ClientCertificates.Count == 0)
dicMsg.Add(MailInfoType.CertificateEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.CertificateEmpty));
}
}
/// <summary>
/// 发送邮件前检查需要设置的信息是否完整，收集 提示 信息
/// </summary>
/// <param name="dicMsg">将检查信息收集到此集合</param>
private void InnerCheckSendMail4Info(Dictionary<MailInfoType, string> dicMsg)
{
#region 处理 抄送/密送
Cc = Cc ?? "";
Bcc = Bcc ?? "";
#endregion 处理 抄送/密送
// 邮件主题
if (Subject.Length == 0)
dicMsg.Add(MailInfoType.SubjectEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.SubjectEmpty));
// 邮件内容
if (Body.Length == 0 &&
(Attachments == null || (Attachments != null && Attachments.Count == 0))
)
{
dicMsg.Add(MailInfoType.BodyEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.BodyEmpty));
}
}
#endregion 发送邮件前检查 相关方法
}
}
using System;using System.Collections.Concurrent;using System.Collections.Generic;using System.Collections.ObjectModel;using System.ComponentModel;using System.IO;using System.Linq;using System.Net;using System.Net.Mail;using System.Net.Mime;using System.Text;using System.Threading;using System.Web;
namespace MailHelpers{ /// <summary> /// MailHelper 的摘要说明 /// </summary> public class MailHelper { #region 构造函数
/// <summary> /// 构建 MailHelper 实例 /// </summary> public MailHelper() { }
/// <summary> /// 构建 MailHelper 实例 /// </summary> /// <param name="smtpclient">smtp服务器地址</param> /// <param name="port">端口</param> /// <param name="user">用户名</param> /// <param name="password">密码</param> public MailHelper(string smtpclient = null, int port = 0, string user = null, string password = null) { SmtpClientAdd = smtpclient; Port = port; User = user; Password = password; }
/// <summary> /// 构建 MailHelper 实例 /// </summary> /// <param name="mSmtpClient">SmtpClient实例</param> /// <param name="autoReleaseSmtp">是否自动释放SmtpClient实例</param> public MailHelper(SmtpClient mSmtpClient, bool autoReleaseSmtp) { SetSmtpClient(mSmtpClient, autoReleaseSmtp); }
#endregion 构造函数
#region 公开属性
private int priority = 0;
/// <summary> /// 设置此电子邮件的密送地址列表，分号(;)分隔。 /// </summary> public string Bcc { get; set; }
/// <summary> /// 设置邮件正文。 /// </summary> public string Body { get; set; }
/// <summary> /// 设置此电子邮件的抄送地址列表，分号(;)分隔。 /// </summary> public string Cc { get; set; }
/// <summary> /// 设置此电子邮件的发信人地址。 /// </summary> public string From { get; set; }
/// <summary> /// 设置此电子邮件的发信人地址。 /// </summary> public string FromDisplayName { get; set; }
/// <summary> /// 设置邮件正文是否为 Html 格式的值。 /// </summary> public bool IsBodyHtml { get; set; }
/// <summary> /// 异步发送标志 /// </summary> public bool m_IsAsync { get; set; }
/// <summary> /// 设置此电子邮件的优先级 0-Normal 1-Low 2-High /// 默认Normal。 /// </summary> public int Priority { get { return this.priority; } set { if (value < 0 || value > 2) priority = 0; else priority = value; } }
/// <summary> /// 设置此电子邮件的主题。 /// </summary> public string Subject { get; set; }
/// <summary> /// 设置此电子邮件的收件地址列表，分号(;)分隔。 /// </summary> public string To { get; set; }
#endregion 公开属性
#region 内部字段、属性
/// <summary> /// 默认为false。设置在 MailHelper 类内部，发送完邮件后是否自动释放 SmtpClient 实例 /// Smtp不管是在 MailHelper 内部还是在外部都必须进行主动释放， /// 因为：SmtpClient 没有提供 Finalize() 终结器，所以GC不会进行回收，只能使用完后主动进行释放，否则会发生内存泄露问题。 /// /// 何时将 autoReleaseSmtp 设置为false，就是SmtpClient需要重复使用的情况，即需要使用“相同MailHelper”向“相同Smtp服务器”发送大批量的邮件时。 /// </summary> private bool m_autoDisposeSmtp = false;
// 指定一个电子邮件不同格式显示的副本。 private Collection<AlternateView> AlternateViews { get; set; }
// 附件集合 private Collection<Attachment> Attachments { get; set; }
private SmtpClient m_SmtpClient { get; set; }
/// <summary> /// smtp密码 /// </summary> private string Password { get; set; }
/// <summary> /// smtp端口 /// </summary> private int Port { get; set; }
/// <summary> /// smtp服务器地址 /// </summary> private string SmtpClientAdd { get; set; }
/// <summary> /// smtp用户名 /// </summary> private string User { get; set; }
#endregion 内部字段、属性
#region 计划邮件数量 和 已执行完成邮件数量
// 记录和获取在大批量执行异步短信发送时已经处理了多少条记录 // 1、根据此值手动或自动释放 SmtpClient .实际上没有需要根据此值进行手动释放，因为完全可以用自动释放替换此逻辑 // 2、根据此值可以自己设置进度 private long m_CompletedSendCount = 0;
// 计划邮件数量 private long m_PrepareSendCount = 0;
public long CompletedSendCount { get { return Interlocked.Read(ref m_CompletedSendCount); } private set { Interlocked.Exchange(ref m_CompletedSendCount, value); } }
public long PrepareSendCount { get { return Interlocked.Read(ref m_PrepareSendCount); } private set { Interlocked.Exchange(ref m_PrepareSendCount, value); } }
#endregion 计划邮件数量 和 已执行完成邮件数量
#region 异步 发送邮件相关参数
// 案例：因为异步发送邮件在SmtpClient处必须加锁保证一封一封的发送。 // 这样阻塞了主线程。所以换用队列的方式以无阻塞的方式进行异步发送大批量邮件
private AutoResetEvent m_AutoResetEvent = null;
// 因为 MessageQueue 可能在 m_SendMailThread 线程中进行出队操作,所以使用并发队列ConcurrentQueue. // 队列中的数据只能通过取消异步发送进行清空，或则就会每一元素都执行发送邮件 private ConcurrentQueue<MailUserState> m_MessageQueue = null;
// 待发送队列缓存数量。单独开个计数是为了提高获取此计数的效率 private int m_messageQueueCount = 0;
// 发送任务可能很长，所以使用 Thread 而不是用ThreadPool。（避免长时间暂居线程池线程），并且SmtpClient只支持一次一封邮件发送 private Thread m_SendMailThread = null;
/// <summary> /// 在执行异步发送时传递的对象，用于传递给异步发生完成时调用的方法 OnSendCompleted 。 /// </summary> public object AsycUserState { get; set; }
private AutoResetEvent AutoResetEvent { get { if (m_AutoResetEvent == null) m_AutoResetEvent = new AutoResetEvent(true); return m_AutoResetEvent; } }
private ConcurrentQueue<MailUserState> MessageQueue { get { if (m_MessageQueue == null) m_MessageQueue = new ConcurrentQueue<MailUserState>(); return m_MessageQueue; } }
#endregion 异步 发送邮件相关参数
#region SmtpClient 相关方法
/// <summary> /// 根据默认值创建一个链接 /// </summary> public SmtpClient CreatSmtpClient() { var smtp = new SmtpClient(SmtpClientAdd, Port); smtp.EnableSsl = false; smtp.UseDefaultCredentials = false; smtp.DeliveryMethod = SmtpDeliveryMethod.Network; smtp.Credentials = new NetworkCredential(User, Password); smtp.Timeout = 100000; return smtp; }
/// <summary> /// 检查此 MailHelper 实例是否已经设置了 SmtpClient /// </summary> /// <returns>true代表已设置</returns> public bool ExistsSmtpClient() { return m_SmtpClient != null; }
/// <summary> /// 释放 SmtpClient /// </summary> public void ManualDisposeSmtp() { this.InnerDisposeSmtp(); }
/// <summary> /// 设置 SmtpClient 实例 和是否自动释放Smtp的唯一入口 /// 1、将内部 计划数量 和 已完成数量 清零，重新统计以便自动释放SmtpClient /// 2、若要对SmtpClent设置SendCompleted事件，请在调用此方法前进行设置 /// </summary> /// <param name="mSmtpClient"> SmtpClient 实例</param> /// <param name="autoReleaseSmtp">设置在 MailHelper 类内部，发送完邮件后是否自动释放 SmtpClient 实例</param> public void SetSmtpClient(SmtpClient mSmtpClient, bool autoReleaseSmtp) { //#if DEBUG // Debug.WriteLine("设置SmtpClient,自动释放为" + (autoReleaseSmtp ? "TRUE" : "FALSE")); //#endif m_SmtpClient = mSmtpClient; m_autoDisposeSmtp = autoReleaseSmtp;
// 将内部 计划数量 和 已完成数量 清零，重新统计以便自动释放SmtpClient (MailHelper实例唯一的清零地方) //m_PrepareSendCount = 0; m_CompletedSendCount = 0;
// 注册回调事件.释放对象---该事件不进行取消注册，只在释放SmtpClient时，一起释放 （所以SmtpClient与MailHelper绑定后，就不要再单独使用了） m_SmtpClient.SendCompleted += SendCompleted4Dispose; }
/// <summary> /// 释放SmtpClient /// </summary> private void AutoDisposeSmtp() { if (m_autoDisposeSmtp && m_SmtpClient != null) { if (PrepareSendCount == 0) { // PrepareSendCount=0 说明还未设置计划批量邮件数，所以不自动释放SmtpClient。 // 不能因为小于CompletedSendCount就报错，因为可能是先发送再设置计划邮件数量 } else if (PrepareSendCount < CompletedSendCount) { throw new Exception(MailValidatorHelper.EMAIL_ASYNC_SEND_PREPARE_ERROR); } else if (PrepareSendCount == CompletedSendCount) { InnerDisposeSmtp(); } } else { // 不清空和Dispose()内部的SmtpClient字段，即用在需要重复使用时不需要再调用 SetSmtpClient() 进行设置。 } }
/// <summary> /// 释放SmtpClient /// </summary> private void InnerDisposeSmtp() { if (m_SmtpClient != null) { //#if DEBUG // Debug.WriteLine("释放SMtpClient"); //#endif m_SmtpClient.Dispose(); m_SmtpClient = null;
// 在设置 SmtpClient 入口处重新进行设置 m_autoDisposeSmtp = false;
PrepareSendCount = 0; CompletedSendCount = 0; } }
#endregion SmtpClient 相关方法
#region 发送邮件 相关方法
/// <summary> /// 取消异步邮件发送 /// </summary> public void SendAsyncCancel() { // 因为此类为非线程安全类，所以 SendAsyncCancel 和发送邮件方法中操作MessageQueue部分的代码肯定是串行化的。 // 所以不存在一边入队，一边出队导致无法完全取消所有邮件发送
// 1、清空队列。 // 2、取消正在异步发送的mail。 // 3、设置计划数量=完成数量 // 4、执行 AutoDisposeSmtp()
// 1、清空队列。 MailUserState tempMailUserState = null; while (MessageQueue.TryDequeue(out tempMailUserState)) { Interlocked.Decrement(ref m_messageQueueCount); MailMessage message = tempMailUserState.CurMailMessage; InnerDisposeMessage(message); } tempMailUserState = null; // 2、取消正在异步发送的mail。 m_SmtpClient.SendAsyncCancel(); // 3、设置计划数量=完成数量 PrepareSendCount = CompletedSendCount; // 4、执行 AutoDisposeSmtp() AutoDisposeSmtp(); }
/// <summary> /// 发送一封邮件 /// </summary> /// <param name="subject">邮件标题</param> /// <param name="body">邮件正文</param> /// <param name="to">收件列表(;分隔)</param> /// <param name="cc">抄送列表(;分隔)</param> /// <param name="bcc">密送列表(;分隔)</param> public void SendMail(string subject, string body, string to, string cc = null, string bcc = null, string from = null, string fromName = null) { SetMailInfo(subject, body, to, cc, bcc, from, fromName); m_PrepareSendCount = 1; SendMail(); }
/// <summary> /// 发送邮件 /// </summary> /// <param name="smtpClient">smtp链接，如不设置则自动根据默认值创建一个</param> /// <param name="autoReleaseSmtp">是否自动释放smtp链接</param> public void SendMail(SmtpClient smtpClient = null, bool autoReleaseSmtp = true) { SetSmtpClient(smtpClient ?? CreatSmtpClient(), autoReleaseSmtp); InnerSendMessage(); }
/// <summary> /// 计划批量发送邮件的个数，配合自动释放SmtpClient。（批量邮件发送不调用此方法就不会自动释放SmtpClient） /// 0、此方法可以在发送邮件方法之前或之后调用 /// 1、只有设置后才会自动根据 m_autoDisposeSmtp 字段进行释放SmtpClient。 /// 2、若 m_autoDisposeSmtp = false 即由自己手动进行设置的无需调用此方法设置预计邮件数 /// </summary> /// <param name="preCount">计划邮件数量</param> public void SetBatchMailCount(long preCount) { PrepareSendCount = preCount;
if (preCount < CompletedSendCount) { throw new ArgumentOutOfRangeException(nameof(preCount), MailValidatorHelper.EMAIL_ASYNC_SEND_PREPARE_ERROR); } if (preCount == CompletedSendCount) { if (m_autoDisposeSmtp) InnerDisposeSmtp(); } }
/// <summary> /// 设置邮件基本信息 /// </summary> /// <param name="subject">邮件标题</param> /// <param name="body">邮件正文</param> /// <param name="to">收件列表(;分隔)</param> /// <param name="cc">抄送列表(;分隔)</param> /// <param name="bcc">密送列表(;分隔)</param> /// <param name="isbodyhtml">邮件内容是否html格式</param> /// <param name="priority">邮件优先级 0-Normal 1-Low 2-High</param> public void SetMailInfo(string subject, string body, string to, string cc = null, string bcc = null, string from = null, string fromName = null, bool isbodyhtml = true, int priority = 0) { Subject = subject; Body = body; To = to; Cc = cc ?? ""; Bcc = bcc ?? ""; From = from ?? ""; FromDisplayName = fromName ?? ""; IsBodyHtml = isbodyhtml; Priority = priority; }
/// <summary> /// 声明在 SmtpClient.SendAsync() 执行完后释放相关对象的回调方法 最后触发的委托 /// </summary> protected void SendCompleted4Dispose(object sender, AsyncCompletedEventArgs e) { MailUserState state = e.UserState as MailUserState;
if (state.CurMailMessage != null) { MailMessage message = state.CurMailMessage; this.InnerDisposeMessage(message); state.CurMailMessage = null; }
if (state.IsSmpleMail) { if (state.AutoReleaseSmtp && state.CurSmtpClient != null) { //#if DEBUG // Debug.WriteLine("释放SmtpClient"); //#endif state.CurSmtpClient.Dispose(); state.CurSmtpClient = null; } } else { if (!e.Cancelled) // 取消的就不计数 CompletedSendCount++;
if (state.AutoReleaseSmtp) { AutoDisposeSmtp(); }
// 若批量异步发送，需要设置信号 //#if DEBUG // Debug.WriteLine("Set" + Thread.CurrentThread.ManagedThreadId); //#endif AutoResetEvent.Set(); }
// 先释放资源，处理错误逻辑 if (e.Error != null && !state.IsErrorHandle) { throw e.Error; } }
private MailMessage CreateMessagex() { #region 构建 MailMessage
bool hasError = false; var mMailMessage = new MailMessage(); try { mMailMessage.From = new MailAddress(From, FromDisplayName); //增加收件人地址等 foreach (var item in To.Split(';'))//.Where(s => MailValidatorHelper.IsEmail(s))) { mMailMessage.To.Add(item); } if (!string.IsNullOrEmpty(Cc)) { foreach (var item in Cc.Split(';').Where(s => MailValidatorHelper.IsEmail(s))) { mMailMessage.CC.Add(item); } } if (!string.IsNullOrEmpty(Bcc)) { foreach (var item in Bcc.Split(';').Where(s => MailValidatorHelper.IsEmail(s))) { mMailMessage.Bcc.Add(item); } } mMailMessage.Subject = Subject; mMailMessage.Body = Body;
if (Attachments != null && Attachments.Count > 0) { foreach (Attachment attachment in Attachments) mMailMessage.Attachments.Add(attachment); }
mMailMessage.SubjectEncoding = Encoding.UTF8; mMailMessage.BodyEncoding = Encoding.UTF8; // SmtpClient 的 Headers 中会根据 MailMessage 默认设置些值，所以应该为 UTF8 。 mMailMessage.HeadersEncoding = Encoding.UTF8; mMailMessage.IsBodyHtml = IsBodyHtml; if (AlternateViews != null && AlternateViews.Count > 0) { foreach (AlternateView alternateView in AlternateViews) { mMailMessage.AlternateViews.Add(alternateView); } } mMailMessage.Priority = (MailPriority)Priority; } catch (ArgumentNullException argumentNullEx) { hasError = true; throw argumentNullEx; } catch (ArgumentException argumentEx) { hasError = true; throw argumentEx; } catch (FormatException formatEx) { hasError = true; throw formatEx; } finally { if (hasError) { if (mMailMessage != null) { this.InnerDisposeMessage(mMailMessage); mMailMessage = null; } this.InnerDisposeSmtp(); } } return mMailMessage;
#endregion 构建 MailMessage }
/// <summary> /// 释放 MailMessage 对象 /// </summary> private void InnerDisposeMessage(MailMessage message) { if (message != null) { if (message.AlternateViews.Count > 0) { message.AlternateViews.Dispose(); }
message.Dispose(); message = null; } }
/// <summary> /// 发送Email /// </summary> private void InnerSendMessage() { bool hasError = false;
var msg = CheckSendMail(); if (msg.Count > 0) { throw new FormatException(MailInfoHelper.GetMailInfoStr(msg)); } var mMailMessage = CreateMessagex();
if (!hasError) { if (m_IsAsync) { #region 异步发送邮件
if (PrepareSendCount == 1) { // 情况一：不重用 SmtpClient 实例会将PrepareSendCount设置为1 // 情况二：计划发送只有一条
// PrepareSendCount 是发送单条邮件。 MailUserState state = new MailUserState() { AutoReleaseSmtp = m_autoDisposeSmtp, CurMailMessage = mMailMessage, CurSmtpClient = m_SmtpClient, IsSmpleMail = true, UserState = AsycUserState, }; if (m_autoDisposeSmtp) // 由发送完成回调函数根据 IsSmpleMail 字段进行释放 m_SmtpClient = null;
ThreadPool.QueueUserWorkItem((userState) => { // 无需 catch 发送异常，因为是异步，所以这里 catch 不到。 MailUserState curUserState = userState as MailUserState; curUserState.CurSmtpClient.SendAsync(mMailMessage, userState); }, state); } else { // 情况一：重用 SmtpClient 逻辑，即我们可以直接操作全局的 m_SmtpClient // 情况二：批量发送邮件 PrepareSendCount>1 // 情况三：PrepareSendCount 还未设置，为0。比如场景在循环中做些判断，再决定发邮件，循环完才调用 SetBatchMailCount 设置计划邮件数量
MailUserState state = new MailUserState() { AutoReleaseSmtp = m_autoDisposeSmtp, CurMailMessage = mMailMessage, CurSmtpClient = m_SmtpClient, UserState = AsycUserState, };
MessageQueue.Enqueue(state); Interlocked.Increment(ref m_messageQueueCount);
if (m_SendMailThread == null) { m_SendMailThread = new Thread(() => { // noItemCount 次获取不到元素，就抛出线程异常 int noItemCount = 0; while (true) { if (PrepareSendCount != 0 && PrepareSendCount == CompletedSendCount) { // 已执行完毕。 this.AutoDisposeSmtp(); break; } else { MailUserState curUserState = null;
if (!MessageQueue.IsEmpty) { //#if DEBUG // Debug.WriteLine("WaitOne" + Thread.CurrentThread.ManagedThreadId); //#endif // 当执行异步取消时，会清空MessageQueue，所以 WaitOne 必须在从MessageQueue中取到元素之前 AutoResetEvent.WaitOne();
if (MessageQueue.TryDequeue(out curUserState)) { Interlocked.Decrement(ref m_messageQueueCount); m_SmtpClient.SendAsync(curUserState.CurMailMessage, curUserState); } } else { if (noItemCount >= 10) { // 没有正确设置 PrepareSendCount 值。导致已没有邮件但此线程出现死循环 this.InnerDisposeSmtp();
throw new Exception(MailValidatorHelper.EMAIL_PREPARESENDCOUNT_NOTSET_ERROR); }
Thread.Sleep(1000); noItemCount++; } } // SmtpClient 为null表示异步预计发送邮件数已经发送完，在 OnSendCompleted 进行了 m_SmtpClient 释放 if (m_SmtpClient == null) break; }
m_SendMailThread = null; }); m_SendMailThread.Start(); } }
#endregion 异步发送邮件 } else { #region 同步发送邮件
try { m_SmtpClient.Send(mMailMessage); m_CompletedSendCount++; } catch (ObjectDisposedException smtpDisposedEx) { throw smtpDisposedEx; } catch (InvalidOperationException smtpOperationEx) { throw smtpOperationEx; } catch (SmtpFailedRecipientsException smtpFailedRecipientsEx) { throw smtpFailedRecipientsEx; } catch (SmtpException smtpEx) { throw smtpEx; } finally { if (mMailMessage != null) { InnerDisposeMessage(mMailMessage); mMailMessage = null; } AutoDisposeSmtp(); }
#endregion 同步发送邮件 } } }
private void InnerSendMessageSync() { var msg = CheckSendMail(); if (msg.Count > 0) { throw new FormatException(MailInfoHelper.GetMailInfoStr(msg)); } try { var mMailMessage = CreateMessagex();
#region 异步发送邮件
if (PrepareSendCount == 1) { // 情况一：不重用 SmtpClient 实例会将PrepareSendCount设置为1 // 情况二：计划发送只有一条 m_SmtpClient.SendAsync(mMailMessage, AsycUserState); if (m_autoDisposeSmtp) { m_SmtpClient = null; } } else { // 情况一：重用 SmtpClient 逻辑，即我们可以直接操作全局的 m_SmtpClient // 情况二：批量发送邮件 PrepareSendCount>1 // 情况三：PrepareSendCount 还未设置，为0。比如场景在循环中做些判断，再决定发邮件，循环完才调用 SetBatchMailCount 设置计划邮件数量
MailUserState state = new MailUserState() { AutoReleaseSmtp = m_autoDisposeSmtp, CurMailMessage = mMailMessage, CurSmtpClient = m_SmtpClient, UserState = AsycUserState, };
MessageQueue.Enqueue(state); Interlocked.Increment(ref m_messageQueueCount);
if (m_SendMailThread == null) { m_SendMailThread = new Thread(() => { // noItemCount 次获取不到元素，就抛出线程异常 int noItemCount = 0; while (true) { if (PrepareSendCount != 0 && PrepareSendCount == CompletedSendCount) { // 已执行完毕。 this.AutoDisposeSmtp(); break; } else { MailUserState curUserState = null;
if (!MessageQueue.IsEmpty) { //#if DEBUG // Debug.WriteLine("WaitOne" + Thread.CurrentThread.ManagedThreadId); //#endif // 当执行异步取消时，会清空MessageQueue，所以 WaitOne 必须在从MessageQueue中取到元素之前 AutoResetEvent.WaitOne();
if (MessageQueue.TryDequeue(out curUserState)) { Interlocked.Decrement(ref m_messageQueueCount); m_SmtpClient.SendAsync(curUserState.CurMailMessage, curUserState); } } else { if (noItemCount >= 10) { // 没有正确设置 PrepareSendCount 值。导致已没有邮件但此线程出现死循环 this.InnerDisposeSmtp();
throw new Exception(MailValidatorHelper.EMAIL_PREPARESENDCOUNT_NOTSET_ERROR); }
Thread.Sleep(1000); noItemCount++; } } // SmtpClient 为null表示异步预计发送邮件数已经发送完，在 OnSendCompleted 进行了 m_SmtpClient 释放 if (m_SmtpClient == null) break; }
m_SendMailThread = null; }); m_SendMailThread.Start(); } }
#endregion 异步发送邮件 } catch (Exception e) { throw new FormatException(e.Message); } }
#endregion 发送邮件 相关方法
#region 异步发送邮件，MessageQueue队列中缓冲的待发邮件数量，使用者可根据此数量来限制邮件数量，以免内存浪费
/// <summary> /// 获取异步发送邮件，MessageQueue队列中缓冲的待发邮件数量 /// （使用者可根据此数量来限制邮件数量，以免内存浪费） /// </summary> public int GetAwaitMailCountAsync() { return Thread.VolatileRead(ref m_messageQueueCount); }
#endregion 异步发送邮件，MessageQueue队列中缓冲的待发邮件数量，使用者可根据此数量来限制邮件数量，以免内存浪费
#region 发送邮件前检查 相关方法
/// <summary> /// 发送邮件前检查需要设置的信息是否完整，收集（提示+错误）信息 /// </summary> public Dictionary<MailInfoType, string> CheckSendMail() { Dictionary<MailInfoType, string> dicMsg = new Dictionary<MailInfoType, string>();
InnerCheckSendMail4Info(dicMsg); InnerCheckSendMail4Error(dicMsg);
return dicMsg; }
/// <summary> /// 发送邮件前检查需要设置的信息是否完整，收集 错误 信息 /// </summary> /// <param name="dicMsg">将检查信息收集到此集合</param> private void InnerCheckSendMail4Error(Dictionary<MailInfoType, string> dicMsg) { #region 处理 发件/收件
if (string.IsNullOrEmpty(From)) { From = "h3bpm@renolit.com.cn"; FromDisplayName = "h3bpm"; } else { if (!MailValidatorHelper.IsEmail(From)) { string strTemp = string.Format(MailInfoHelper.GetMailInfoStr(MailInfoType.FromFormat), FromDisplayName, From); dicMsg.Add(MailInfoType.FromFormat, strTemp); } }
if (string.IsNullOrEmpty(To)) { dicMsg.Add(MailInfoType.ToEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.ToEmpty)); } else { foreach (var item in To.Split(';')) { if (!MailValidatorHelper.IsEmail(item)) { string strTemp = string.Format(MailInfoHelper.GetMailInfoStr(MailInfoType.ToFormat), item, item); dicMsg.Add(MailInfoType.ToFormat, strTemp); } } }
#endregion 处理 发件/收件
// SmtpClient 实例未设置 if (m_SmtpClient == null) dicMsg.Add(MailInfoType.SmtpClientEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.SmtpClientEmpty)); else { // SMTP 主服务器设置 （默认端口为25） if (m_SmtpClient.Host.Length == 0) dicMsg.Add(MailInfoType.HostEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.HostEmpty)); // SMPT 凭证 if (m_SmtpClient.EnableSsl && m_SmtpClient.ClientCertificates.Count == 0) dicMsg.Add(MailInfoType.CertificateEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.CertificateEmpty)); } }
/// <summary> /// 发送邮件前检查需要设置的信息是否完整，收集 提示 信息 /// </summary> /// <param name="dicMsg">将检查信息收集到此集合</param> private void InnerCheckSendMail4Info(Dictionary<MailInfoType, string> dicMsg) { #region 处理 抄送/密送
Cc = Cc ?? ""; Bcc = Bcc ?? "";
#endregion 处理 抄送/密送
// 邮件主题 if (Subject.Length == 0) dicMsg.Add(MailInfoType.SubjectEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.SubjectEmpty));
// 邮件内容 if (Body.Length == 0 && (Attachments == null || (Attachments != null && Attachments.Count == 0)) ) { dicMsg.Add(MailInfoType.BodyEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.BodyEmpty)); } }
#endregion 发送邮件前检查 相关方法 }}
