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 发送邮件前检查 相关方法    }}