#define debug
using System;
using System.Text;
using System.Linq;
using System.IO;
using System.Net;
using System.Net.Mail;
using System.Net.Mime;
using System.Threading;
using System.ComponentModel;
using System.Diagnostics;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Collections.ObjectModel;
namespace Mail_Test.Mail
{
/// <summary>
/// 非线程安全类
/// 使用注意事项：
/// 1、该类无需（也不能）在外部包裹多线程，因为内部有提供“异步发送”方法，内、外都使用多线程会导致线程池对可用资源的误判，从而创建过多阻塞线程。
/// 2、MailHelper类的 m_autoDisposeSmtp 属性的使用，具体见此字段注释。
/// 3、启用 UTF-8 字符编码
/// </summary>
public class MailHelper
{
#region 构造函数
/// <summary>
/// 构建 MailHelper 实例
/// </summary>
/// <param name="isAsync">是否启用异步邮件发送，默认为同步发送</param>
public MailHelper(bool isAsync = false)
{
m_IsAsync = isAsync;
}
/// <summary>
/// 构建 MailHelper 实例
/// </summary>
/// <param name="mSmtpClient">SmtpClient实例</param>
/// <param name="autoReleaseSmtp">是否自动释放SmtpClient实例</param>
/// <param name="isAsync">是否启用异步邮件发送</param>
public MailHelper(SmtpClient mSmtpClient, bool autoReleaseSmtp, bool isAsync = false)
{
this.SetSmtpClient(mSmtpClient, autoReleaseSmtp);
m_IsAsync = isAsync;
}
#endregion
#region 计划邮件数量 和 已执行完成邮件数量
private long m_CompletedSendCount = 0;
public long CompletedSendCount
{
get { return Interlocked.Read(ref m_CompletedSendCount); }
private set { Interlocked.Exchange(ref m_CompletedSendCount, value); }
}
private long m_PrepareSendCount = 0;
public long PrepareSendCount
{
get { return Interlocked.Read(ref m_PrepareSendCount); }
private set { Interlocked.Exchange(ref m_PrepareSendCount, value); }
}
#endregion
#region 异步 发送邮件相关参数
private bool m_IsAsync = false;
private Thread m_SendMailThread = null;
private AutoResetEvent m_AutoResetEvent = null;
private AutoResetEvent AutoResetEvent
{
get
{
if (m_AutoResetEvent == null)
m_AutoResetEvent = new AutoResetEvent(true);
return m_AutoResetEvent;
}
}
private int m_messageQueueCount = 0;
private ConcurrentQueue<MailUserState> m_MessageQueue = null;
private ConcurrentQueue<MailUserState> MessageQueue
{
get
{
if (m_MessageQueue == null)
m_MessageQueue = new ConcurrentQueue<MailUserState>();
return m_MessageQueue;
}
}
/// <summary>
/// 在执行异步发送时传递的对象，用于传递给异步发生完成时调用的方法 OnSendCompleted 。
/// </summary>
public object AsycUserState { get; set; }
#endregion
#region 内部字段、属性
private SmtpClient m_SmtpClient = null;
/// <summary>
/// 默认为false。设置在 MailHelper 类内部，发送完邮件后是否自动释放 SmtpClient 实例
/// Smtp不管是在 MailHelper 内部还是在外部都必须进行主动释放，
/// 因为：SmtpClient 没有提供 Finalize() 终结器，所以GC不会进行回收，只能使用完后主动进行释放，否则会发生内存泄露问题。
///
/// 何时将 autoReleaseSmtp 设置为false，就是SmtpClient需要重复使用的情况，即需要使用“相同MailHelper”向“相同Smtp服务器”发送大批量的邮件时。
/// </summary>
private bool m_autoDisposeSmtp = false;
/// <summary>
/// 设置此电子邮件的收件人的地址集合。
/// </summary>
Dictionary<string, string> m_DicTo = null;
Dictionary<string, string> DicTo
{
get
{
if (m_DicTo == null)
m_DicTo = new Dictionary<string, string>();
return m_DicTo;
}
}
/// <summary>
/// 设置此电子邮件的抄送 (CC) 收件人的地址集合。
/// </summary>
Dictionary<string, string> m_DicCC = null;
Dictionary<string, string> DicCC
{
get
{
if (m_DicCC == null)
m_DicCC = new Dictionary<string, string>();
return m_DicCC;
}
}
/// <summary>
/// 设置此电子邮件的密件抄送 (BCC) 收件人的地址集合。
/// </summary>
Dictionary<string, string> m_DicBcc = null;
Dictionary<string, string> DicBcc
{
get
{
if (m_DicBcc == null)
m_DicBcc = new Dictionary<string, string>();
return m_DicBcc;
}
}
Collection<Attachment> m_Attachments;
Collection<Attachment> Attachments
{
get
{
if (m_Attachments == null)
m_Attachments = new Collection<Attachment>();
return m_Attachments;
}
}
Collection<AlternateView> m_AlternateViews;
Collection<AlternateView> AlternateViews
{
get
{
if (m_AlternateViews == null)
m_AlternateViews = new Collection<AlternateView>();
return m_AlternateViews;
}
}
#endregion
#region 公开属性
/// <summary>
/// 设置此电子邮件的发信人地址。
/// </summary>
public string From { get; set; }
/// <summary>
/// 设置此电子邮件的发信人地址。
/// </summary>
public string FromDisplayName { get; set; }
/// <summary>
/// 设置此电子邮件的主题。
/// </summary>
public string Subject { get; set; }
/// <summary>
/// 设置邮件正文。
/// </summary>
public string Body { get; set; }
/// <summary>
/// 设置邮件正文是否为 Html 格式的值。
/// </summary>
public bool IsBodyHtml { get; set; }
private int priority = 0;
/// <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;
}
}
#endregion
/// <summary>
/// 重置 MailHelper 实例信息
/// 不释放 SmtpClient 实例和相关的AutoReleaseSimple字段，因为存在异步发送。。这两个字段由SetSmtpClient方法设置
/// </summary>
public void Reset()
{
From = String.Empty;
FromDisplayName = String.Empty;
if (m_DicTo != null)
m_DicTo.Clear();
if (m_DicCC != null)
m_DicCC.Clear();
if (m_DicBcc != null)
m_DicBcc.Clear();
if (m_Attachments != null)
m_Attachments.Clear();
if (m_AlternateViews != null)
m_AlternateViews.Clear();
Subject = String.Empty;
Body = String.Empty;
IsBodyHtml = false;
priority = 0;
AsycUserState = null;
}
#region SmtpClient 相关方法
/// <summary>
/// 检查此 MailHelper 实例是否已经设置了 SmtpClient
/// </summary>
/// <returns>true代表已设置</returns>
public bool ExistsSmtpClient()
{
return m_SmtpClient != null ? true : false;
}
/// <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;
m_PrepareSendCount = 0;
m_CompletedSendCount = 0;
if (m_IsAsync && autoReleaseSmtp)
{
m_SmtpClient.SendCompleted = new SendCompletedEventHandler(SendCompleted4Dispose);
}
}
/// <summary>
/// 释放 SmtpClient
/// </summary>
public void ManualDisposeSmtp()
{
this.InnerDisposeSmtp();
}
/// <summary>
/// 释放SmtpClient
/// </summary>
private void AutoDisposeSmtp()
{
if (m_autoDisposeSmtp && m_SmtpClient != null)
{
if (PrepareSendCount == 0)
{
}
else if (PrepareSendCount < CompletedSendCount)
{
throw new Exception(MailValidatorHelper.EMAIL_ADDRESS_RANGE_ERROR);
}
else if (PrepareSendCount == CompletedSendCount)
{
this.InnerDisposeSmtp();
}
}
else
{
}
}
/// <summary>
/// 释放SmtpClient
/// </summary>
private void InnerDisposeSmtp()
{
if (m_SmtpClient != null)
{
#if DEBUG
Debug.WriteLine("释放SMtpClient");
#endif
m_SmtpClient.Dispose();
m_SmtpClient = null;
m_autoDisposeSmtp = false;
PrepareSendCount = 0;
CompletedSendCount = 0;
}
}
#endregion
#region MessageAddress、Attachment、AlternateView 相关方法
#region 添加收件人、抄送人、密送人（每个类型中，若地址有重复，只保留第一个地址）
/// <summary>
/// 添加收件人、抄送人、密送人（每个类型中，若地址有重复，只保留第一个地址）
/// </summary>
/// <param name="type">类型：收件人、抄送人、密送人</param>
/// <param name="addressList">Email地址列表</param>
public void AddReceive(EmailAddrType type, IEnumerable<string> addressList)
{
MailValidatorHelper.ValideArgumentNull<IEnumerable<string>>(addressList, "addressList");
if (addressList.Count() > 0)
{
Dictionary<string, string> dic = null;
switch (type)
{
case EmailAddrType.To:
dic = DicTo;
break;
case EmailAddrType.CC:
dic = DicCC;
break;
case EmailAddrType.Bcc:
dic = DicBcc;
break;
case EmailAddrType.From:
throw new Exception(MailValidatorHelper.EMAIL_ADDRESS_RANGE_ERROR);
}
foreach (string address in addressList)
{
MailValidatorHelper.ValideStrNullOrEmpty(address, "addressList", MailValidatorHelper.EMAIL_ADDRESS_LIST_ERROR);
if (dic.Count > 0 && !dic.ContainsKey(address))
dic.Add(address, String.Empty);
}
}
}
/// <summary>
/// 添加收件人、抄送人、密送人（每个类型中，若地址有重复，只保留第一个地址）
/// </summary>
/// <param name="type">类型：收件人、抄送人、密送人</param>
/// <param name="address">Email地址</param>
/// <param name="displayName">显示名称</param>
public void AddReceive(EmailAddrType type, string address, string displayName)
{
MailValidatorHelper.ValideStrNullOrEmpty(address, "address");
Dictionary<string, string> dic = null;
switch (type)
{
case EmailAddrType.To:
dic = DicTo;
break;
case EmailAddrType.CC:
dic = DicCC;
break;
case EmailAddrType.Bcc:
dic = DicBcc;
break;
case EmailAddrType.From:
throw new Exception(MailValidatorHelper.EMAIL_ADDRESS_RANGE_ERROR);
}
if (dic.Count == 0 || !dic.ContainsKey(address))
dic.Add(address, displayName);
}
/// <summary>
/// 添加收件人、抄送人、密送人（每个类型中，若地址有重复，只保留第一个地址）
/// </summary>
/// <param name="type">类型：收件人、抄送人、密送人</param>
/// <param name="dicAddress">Email地址，显示名称</param>
public void AddReceive(EmailAddrType type, Dictionary<string, string> dicAddress)
{
MailValidatorHelper.ValideArgumentNull<Dictionary<string, string>>(dicAddress, "dicAddress");
if (dicAddress.Count > 0)
{
Dictionary<string, string> dic = null;
switch (type)
{
case EmailAddrType.To:
dic = DicTo;
break;
case EmailAddrType.CC:
dic = DicCC;
break;
case EmailAddrType.Bcc:
dic = DicBcc;
break;
case EmailAddrType.From:
throw new Exception(MailValidatorHelper.EMAIL_ADDRESS_RANGE_ERROR);
}
foreach (KeyValuePair<string, string> keyValue in dicAddress)
{
MailValidatorHelper.ValideStrNullOrEmpty(keyValue.Key, "dicAddress", MailValidatorHelper.EMAIL_ADDRESS_DIC_ERROR);
if (dic.Count > 0 && !dic.ContainsKey(keyValue.Key))
dic.Add(keyValue.Key, keyValue.Value);
}
}
}
#endregion
#region 添加附件
/// <summary>
/// 添加单个附件
/// </summary>
/// <param name="attachment">Attachment附件实例</param>
public void AddAttachment(Attachment attachment)
{
MailValidatorHelper.ValideArgumentNull<Attachment>(attachment, "attachment");
Attachments.Add(attachment);
}
/// <summary>
/// 添加单个附件
/// </summary>
/// <param name="fieldPath">待上传文件路径</param>
/// <param name="fileName">文件显示名称（不带后缀）</param>
public void AddAttachment(string fieldPath, string fileName = "")
{
MailValidatorHelper.ValideStrNullOrEmpty(fieldPath, "fieldPath");
this.InnerAddAttachment(fieldPath, fileName, false, String.Empty);
}
/// <summary>
/// 添加内嵌资源（eg：图片，mp3等等）
/// </summary>
/// <param name="fieldPath">内嵌资源的文件路径</param>
/// <param name="cidName">设置此附件的 MIME 内容 ID</param>
public void AddInlineAttachment(string fieldPath, string cidName)
{
MailValidatorHelper.ValideStrNullOrEmpty(fieldPath, "fieldPath");
MailValidatorHelper.ValideStrNullOrEmpty(cidName, "cidName");
this.InnerAddAttachment(fieldPath, String.Empty, true, cidName);
}
private void InnerAddAttachment(string fieldPath, string fileName, bool isInline, string cidName)
{
FileInfo file = new FileInfo(fieldPath);
Stream stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.Read);
Attachment data = new Attachment(stream, String.Empty);
ContentDisposition disposition = data.ContentDisposition;
if (isInline)
{
disposition.Inline = true;
data.ContentId = cidName;
}
disposition.CreationDate = file.CreationTime;
disposition.ModificationDate = file.LastWriteTime;
disposition.ReadDate = file.LastAccessTime;
if (String.IsNullOrEmpty(fileName))
disposition.FileName = file.Name.ToString();
else
{
disposition.FileName = fileName Path.GetExtension(fieldPath);
}
Attachments.Add(data);
}
#endregion
#region 添加AlternateView
/// <summary>
/// 添加一个电子邮件不同格式的副本。
/// </summary>
/// <param name="filePath">包含电子邮件内容的文件路径</param>
public void AddAlterViewPath(string filePath)
{
MailValidatorHelper.ValideStrNullOrEmpty(filePath, "filePath");
AlternateViews.Add(new AlternateView(filePath));
}
/// <summary>
/// 添加一个电子邮件不同格式的副本。
/// </summary>
/// <param name="mailContent">电子邮件内容</param>
public void AddAlterViewContent(string mailContent)
{
MailValidatorHelper.ValideStrNullOrEmpty(mailContent, "mailContent");
AlternateViews.Add(AlternateView.CreateAlternateViewFromString(mailContent));
}
/// <summary>
/// 添加一个电子邮件不同格式的副本。
/// </summary>
/// <param name="contentStream">电子邮件内容流</param>
public void AddAlterViewStream(Stream contentStream)
{
MailValidatorHelper.ValideArgumentNull<Stream>(contentStream, "contentStream");
AlternateViews.Add(new AlternateView(contentStream));
}
/// <summary>
/// 添加一个电子邮件不同格式的副本。
/// </summary>
/// <param name="alternateView">电子邮件视图</param>
public void AddAlternateView(AlternateView alternateView)
{
MailValidatorHelper.ValideArgumentNull<AlternateView>(alternateView, "alternateView");
AlternateViews.Add(alternateView);
}
#endregion
#endregion
#region 发送邮件 相关方法
/// <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("preCount", MailValidatorHelper.EMAIL_ADDRESS_RANGE_ERROR);
}
else if (preCount == CompletedSendCount)
{
if (m_autoDisposeSmtp)
this.InnerDisposeSmtp();
}
}
/// <summary>
/// 同步发送一封Email
/// </summary>
public void SendOneMail()
{
m_PrepareSendCount = 1;
this.InnerSendMessage();
}
/// <summary>
/// 批量同步发送Email
/// </summary>
public void SendBatchMail()
{
this.InnerSendMessage();
}
/// <summary>
/// 取消异步邮件发送
/// </summary>
public void SendAsyncCancel()
{
if (m_IsAsync)
{
MailUserState tempMailUserState = null;
while (MessageQueue.TryDequeue(out tempMailUserState))
{
Interlocked.Decrement(ref m_messageQueueCount);
MailMessage message = tempMailUserState.CurMailMessage;
this.InnerDisposeMessage(message);
}
tempMailUserState = null;
m_SmtpClient.SendAsyncCancel();
PrepareSendCount = CompletedSendCount;
this.AutoDisposeSmtp();
}
else
{
throw new Exception(MailValidatorHelper.EMAIL_ASYNC_CALL_ERROR);
}
}
/// <summary>
/// 发送Email
/// </summary>
private void InnerSendMessage()
{
bool hasError = false;
MailMessage mMailMessage = null;
#region 构建 MailMessage
try
{
mMailMessage = new MailMessage();
mMailMessage.From = new MailAddress(From, FromDisplayName);
this.InnerSetAddress(EmailAddrType.To, mMailMessage);
this.InnerSetAddress(EmailAddrType.CC, mMailMessage);
this.InnerSetAddress(EmailAddrType.Bcc, mMailMessage);
mMailMessage.Subject = Subject;
mMailMessage.Body = Body;
if (m_Attachments != null && m_Attachments.Count > 0)
{
foreach (Attachment attachment in m_Attachments)
mMailMessage.Attachments.Add(attachment);
}
mMailMessage.SubjectEncoding = Encoding.UTF8;
mMailMessage.BodyEncoding = Encoding.UTF8;
mMailMessage.HeadersEncoding = Encoding.UTF8;
mMailMessage.IsBodyHtml = IsBodyHtml;
if (m_AlternateViews != null && m_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();
}
}
#endregion
if (!hasError)
{
if (m_IsAsync)
{
#region 异步发送邮件
if (PrepareSendCount == 1)
{
MailUserState state = new MailUserState()
{
AutoReleaseSmtp = m_autoDisposeSmtp,
CurMailMessage = mMailMessage,
CurSmtpClient = m_SmtpClient,
IsSmpleMail = true,
UserState = AsycUserState,
};
if (m_autoDisposeSmtp)
m_SmtpClient = null;
ThreadPool.QueueUserWorkItem((userState) =>
{
MailUserState curUserState = userState as MailUserState;
curUserState.CurSmtpClient.SendAsync(mMailMessage, userState);
}, state);
}
else
{
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(() =>
{
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
AutoResetEvent.WaitOne();
if (MessageQueue.TryDequeue(out curUserState))
{
Interlocked.Decrement(ref m_messageQueueCount);
m_SmtpClient.SendAsync(curUserState.CurMailMessage, curUserState);
}
}
else
{
if (noItemCount >= 10)
{
this.InnerDisposeSmtp();
throw new Exception(MailValidatorHelper.EMAIL_PREPARESENDCOUNT_NOTSET_ERROR);
}
Thread.Sleep(1000);
noItemCount ;
}
}
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)
{
this.InnerDisposeMessage(mMailMessage);
mMailMessage = null;
}
this.AutoDisposeSmtp();
}
#endregion
}
}
}
/// <summary>
/// 将收件人、抄送人、密送人添加到 MailMessage 中
/// </summary>
/// <param name="type">收件人、抄送人、密送人</param>
/// <param name="mMailMessage">待发送的MailMessage类</param>
private void InnerSetAddress(EmailAddrType type, MailMessage mMailMessage)
{
MailAddressCollection receiveCol = null;
Dictionary<string, string> dicReceive = null;
bool hasAddress = false;
switch (type)
{
case EmailAddrType.To:
{
if (m_DicTo != null && m_DicTo.Count > 0)
{
dicReceive = m_DicTo;
receiveCol = mMailMessage.To;
hasAddress = true;
}
}
break;
case EmailAddrType.CC:
{
if (m_DicCC != null && m_DicCC.Count > 0)
{
dicReceive = m_DicCC;
receiveCol = mMailMessage.CC;
hasAddress = true;
}
}
break;
case EmailAddrType.Bcc:
{
if (m_DicBcc != null && m_DicBcc.Count > 0)
{
dicReceive = m_DicBcc;
receiveCol = mMailMessage.Bcc;
hasAddress = true;
}
}
break;
case EmailAddrType.From:
throw new Exception(MailValidatorHelper.EMAIL_ADDRESS_RANGE_ERROR);
}
if (hasAddress)
{
foreach (KeyValuePair<string, string> keyValue in dicReceive)
{
receiveCol.Add(new MailAddress(keyValue.Key, keyValue.Value));
}
}
}
/// <summary>
/// 释放 MailMessage 对象
/// </summary>
private void InnerDisposeMessage(MailMessage message)
{
if (message != null)
{
if (message.AlternateViews.Count > 0)
{
message.AlternateViews.Dispose();
}
message.Dispose();
message = null;
}
}
/// <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)
{
this.AutoDisposeSmtp();
}
#if DEBUG
Debug.WriteLine("Set" Thread.CurrentThread.ManagedThreadId);
#endif
AutoResetEvent.Set();
}
if (e.Error != null && !state.IsErrorHandle)
{
throw e.Error;
}
}
#endregion
#region 异步发送邮件，MessageQueue队列中缓冲的待发邮件数量，使用者可根据此数量来限制邮件数量，以免内存浪费
/// <summary>
/// 获取异步发送邮件，MessageQueue队列中缓冲的待发邮件数量
/// （使用者可根据此数量来限制邮件数量，以免内存浪费）
/// </summary>
public int GetAwaitMailCountAsync()
{
if (m_IsAsync)
{
return Thread.VolatileRead(ref m_messageQueueCount);
}
else
{
throw new Exception(MailValidatorHelper.EMAIL_ASYNC_CALL_ERROR);
}
}
#endregion
#region 发送邮件前检查 相关方法
/// <summary>
/// 发送邮件前检查需要设置的信息是否完整，收集（提示 错误）信息
/// </summary>
public Dictionary<MailInfoType, string> CheckSendMail()
{
Dictionary<MailInfoType, string> dicMsg = new Dictionary<MailInfoType, string>();
this.InnerCheckSendMail4Info(dicMsg);
this.InnerCheckSendMail4Error(dicMsg);
return dicMsg;
}
/// <summary>
/// 发送邮件前检查需要设置的信息是否完整，收集 提示 信息
/// </summary>
public Dictionary<MailInfoType, string> CheckSendMail4Info()
{
Dictionary<MailInfoType, string> dicMsg = new Dictionary<MailInfoType, string>();
this.InnerCheckSendMail4Info(dicMsg);
return dicMsg;
}
/// <summary>
/// 发送邮件前检查需要设置的信息是否完整，收集 错误 信息
/// </summary>
public Dictionary<MailInfoType, string> CheckSendMail4Error()
{
Dictionary<MailInfoType, string> dicMsg = new Dictionary<MailInfoType, string>();
this.InnerCheckSendMail4Error(dicMsg);
return dicMsg;
}
/// <summary>
/// 发送邮件前检查需要设置的信息是否完整，收集 提示 信息
/// </summary>
/// <param name="dicMsg">将检查信息收集到此集合</param>
private void InnerCheckSendMail4Info(Dictionary<MailInfoType, string> dicMsg)
{
StringBuilder infoBuilder = new StringBuilder(128);
this.InnerCheckAddress(infoBuilder, dicMsg, EmailAddrType.CC);
this.InnerCheckAddress(infoBuilder, dicMsg, EmailAddrType.Bcc);
if (Subject.Length == 0)
dicMsg.Add(MailInfoType.SubjectEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.SubjectEmpty));
if (Body.Length == 0 &&
(m_Attachments == null || (m_Attachments != null && m_Attachments.Count == 0))
)
{
dicMsg.Add(MailInfoType.BodyEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.BodyEmpty));
}
}
/// <summary>
/// 发送邮件前检查需要设置的信息是否完整，收集 错误 信息
/// </summary>
/// <param name="dicMsg">将检查信息收集到此集合</param>
private void InnerCheckSendMail4Error(Dictionary<MailInfoType, string> dicMsg)
{
StringBuilder infoBuilder = new StringBuilder(128);
this.InnerCheckAddress(infoBuilder, dicMsg, EmailAddrType.From);
this.InnerCheckAddress(infoBuilder, dicMsg, EmailAddrType.To);
if (m_SmtpClient == null)
dicMsg.Add(MailInfoType.SmtpClientEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.SmtpClientEmpty));
else
{
if (m_SmtpClient.Host.Length == 0)
dicMsg.Add(MailInfoType.HostEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.HostEmpty));
if (m_SmtpClient.EnableSsl && m_SmtpClient.ClientCertificates.Count == 0)
dicMsg.Add(MailInfoType.CertificateEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.CertificateEmpty));
}
}
/// <summary>
/// 检查 发件人、收件人、抄送人、密送人 邮箱地址
/// </summary>
/// <param name="infoBuilder">StringBuilder实例</param>
/// <param name="dicMsg">将检查信息收集到此集合</param>
/// <param name="type">接收邮件地址类型</param>
private void InnerCheckAddress(StringBuilder infoBuilder, Dictionary<MailInfoType, string> dicMsg, EmailAddrType type)
{
Dictionary<string, string> dic = null;
MailInfoType addressFormat = MailInfoType.None;
MailInfoType addressEmpty = MailInfoType.None;
bool allowEmpty = true;
bool hasHandle = false;
switch (type)
{
case EmailAddrType.From:
{
hasHandle = true;
allowEmpty = false;
if (From.Length == 0)
{
dicMsg.Add(MailInfoType.FromEmpty, MailInfoHelper.GetMailInfoStr(MailInfoType.FromEmpty));
}
else if (!MailValidatorHelper.IsEmail(From))
{
string strTemp = infoBuilder.AppendFormat(MailInfoHelper.GetMailInfoStr(MailInfoType.FromFormat), FromDisplayName, From).ToString();
dicMsg.Add(MailInfoType.FromFormat, strTemp);
infoBuilder.Length = 0;
}
}
break;
case EmailAddrType.To:
{
dic = m_DicTo;
addressEmpty = MailInfoType.ToEmpty;
allowEmpty = false;
addressFormat = MailInfoType.ToFormat;
}
break;
case EmailAddrType.CC:
{
dic = m_DicCC;
addressFormat = MailInfoType.CCFormat;
allowEmpty = true;
addressEmpty = MailInfoType.None;
}
break;
case EmailAddrType.Bcc:
{
dic = m_DicBcc;
addressFormat = MailInfoType.BccFormat;
allowEmpty = true;
addressEmpty = MailInfoType.None;
}
break;
}
#region 处理 收件人、抄送人、密送人
if (!hasHandle)
{
if (dic == null)
{
if (!allowEmpty)
{
dicMsg.Add(addressEmpty, MailInfoHelper.GetMailInfoStr(addressEmpty));
}
}
else
{
if (dic.Count > 0)
{
string strTemp = String.Empty;
foreach (KeyValuePair<string, string> keyValue in dic)
{
if (keyValue.Key.Length == 0)
{
if (!allowEmpty)
{
dicMsg.Add(addressEmpty, MailInfoHelper.GetMailInfoStr(addressEmpty));
}
}
else if (!MailValidatorHelper.IsEmail(keyValue.Key))
{
if (strTemp.Length == 0)
strTemp = MailInfoHelper.GetMailInfoStr(addressFormat);
if (infoBuilder.Length > 0)
infoBuilder.AppendLine();
infoBuilder.AppendFormat(strTemp, keyValue.Value, keyValue.Key);
}
}
if (infoBuilder.Length > 0)
{
dicMsg.Add(addressFormat, infoBuilder.ToString());
infoBuilder.Length = 0;
}
}
else if (!allowEmpty)
{
dicMsg.Add(addressEmpty, MailInfoHelper.GetMailInfoStr(addressEmpty));
}
}
}
#endregion
}
#endregion
}
/// <summary>
/// 异步发送邮件时保存的信息，用于释放和传递数据
/// </summary>
public class MailUserState
{
#region 由MailHelper内部的SendCompleted注册的事件使用
public MailMessage CurMailMessage { get; set; }
public bool AutoReleaseSmtp { get; set; }
public SmtpClient CurSmtpClient { get; set; }
public bool IsSmpleMail { get; set; }
#endregion
/// <summary>
/// 用户传递的状态对象
/// </summary>
public object UserState { get; set; }
/// <summary>
/// 当异步发送报错时可通过此标识是否已经处理该异常
/// </summary>
public bool IsErrorHandle { get; set; }
}
}
浙公网安备 33010602011771号