JMail Pro接收邮件附件

首先去搜索下载w3 JMail v4.4 Professional 这个COM 组件,然后注册这个组件,jmail 的注册方法,运行命令行: regsvr32 e:/jmail/jmail.dll,最后添加引用这个组件就可以使用了。

//Jmail接收邮件处理类NJMail.cs

namespace Common.NJMail
...{
    public class POP3
    ...{
        public delegate void MessagesEventHandler(MessagesState oMessagesState);
        public delegate void AttachmentsEventHandler(AttachmentsState oAttachmentsState);

        //异步事件
        public event MessagesEventHandler MessagesReceiveAsync;
        public event AttachmentsEventHandler AttachmentsReceiveAsync;

        //同步事件
        public event MessagesEventHandler MessageReceived;//一封邮件已收到本地
        public event MessagesEventHandler MessageReceive;//一封邮件正到达
        public event AttachmentsEventHandler AttachmentReceive;//一封邮件的附件正到达

        //发生异常事件
        public event MessagesEventHandler MessageException;
        public event AttachmentsEventHandler AttachmentException;

        private string _UserName;
        private string _Password;
        private string _Server;
        private int _Port = 110;

        private static object _LockObject = new object();

        /**//// <summary>
        /// 每次接收邮件的数量
        /// </summary>
        private int _mCount = 0;
        public int MCount
        ...{
            set
            ...{
                this._mCount = value;
            }
            get
            ...{
                return this._mCount;
            }
        }

        /**//// <summary>
        /// 接收邮件或附件重试次数
        /// </summary>
        private int _aRetryCount = 0;
        public int RetryCount
        ...{
            set
            ...{
                this._aRetryCount = value;
            }
            get
            ...{
                return this._aRetryCount;
            }
        }

        /**//// <summary>
        /// 是否删除服务器上已下载邮件
        /// </summary>
        private bool _bDelete = false;
        public bool BDelete
        ...{
            set
            ...{
                this._bDelete = value;
            }
            get
            ...{
                return this._bDelete;
            }
        }

        构造函数#region 构造函数
        /**//// <summary>
        /// 带端口的构造函数
        /// </summary>
        /// <param name="UserName">用户名</param>
        /// <param name="Password">密码</param>
        /// <param name="Server">邮件服务器</param>
        /// <param name="Port">端口</param>
        public POP3(string UserName,string Password,string Server,int Port)
        ...{
            this._UserName = UserName;
            this._Password = Password;
            this._Server = Server;
            this._Port = Port;
        }

        /**//// <summary>
        /// 默认110端口的构造函数
        /// </summary>
        /// <param name="UserName">用户名</param>
        /// <param name="Password">密码</param>
        /// <param name="Server">邮件服务器</param>
        public POP3(string UserName,string Password,string Server)
        ...{
            this._UserName = UserName;
            this._Password = Password;
            this._Server = Server;
        }
        #endregion

        同步收邮件#region 同步收邮件
        public void Execute()
        ...{
            this.Execute(false);
        }
        #endregion

        收邮件#region 收邮件
        public void Execute(bool IsAsync)
        ...{
            jmail.POP3Class pop3 = new jmail.POP3Class();
            try
            ...{
                pop3.Timeout = 0;
                pop3.Connect(this._UserName,this._Password,this._Server,this._Port);
                jmail.MessagesClass jms = (jmail.MessagesClass) pop3.Messages;
                int I = jms.Count;
                MessagesState omss = null;
                for (int i = 0; i < I - 1 && i < this._mCount; i++)
                ...{
                    try
                    ...{
                        jmail.MessageClass jmc = (jmail.MessageClass) jms[i+1];
                        omss = new MessagesState(i+1,jmc,jms,pop3); 
                        if (this.MessageReceive != null)
                        ...{
                            this.MessageReceive(omss);
                        }
                        if (!omss.CancelCurrent)
                        ...{
                            if (IsAsync)
                            ...{
                                (new MessagesEventHandler(this.MessageExecuteAsync)).BeginInvoke(omss,new System.AsyncCallback(this.OnMessageCallBack),omss); 
                            }
                            else
                            ...{
                                附件处理#region 附件处理
                                int J = jmc.Attachments.Count;
                                AttachmentsState oass = null;
                                int iErr = 0;
                                for (int j = 0; j < J; j++)
                                ...{
                                    try
                                    ...{
                                        oass = new AttachmentsState(j,omss); 
                                        if (this.AttachmentReceive != null)
                                        ...{
                                            this.AttachmentReceive(oass);
                                        }
                                        if (!oass.CancelCurrent)
                                        ...{
                                            string s = oass.FileName;
                                            omss.SetFilePath(System.IO.Path.GetDirectoryName(s) + @"");
                                            //oass.SaveToFile(s);
                                        }
                                    }
                                    catch (System.Exception e)
                                    ...{
                                        if (this.AttachmentException != null)
                                        ...{
                                            oass.Exception = e;
                                            this.AttachmentException(oass);
                                            if (oass.ExceptionAction == ExceptionActions.CancelAll)
                                            ...{
                                                break;
                                            }
                                            else if (oass.ExceptionAction == ExceptionActions.Retry)
                                            ...{
                                                j--;
                                                iErr++;
                                                //重试超过指定次数
                                                if(iErr > this._aRetryCount)
                                                    throw e;
                                            }
//                                            else if (oass.ExceptionAction == ExceptionActions.Ignore)
//                                            {
//                                                continue;
//                                            }
//                                            else if (oass.ExceptionAction == ExceptionActions.Throw)
//                                            {
//                                                throw e;
//                                            }
                                        }
                                        else
                                        ...{
                                            throw e;
                                        }
                                    }
                                }
                                #endregion

                                if (this.MessageReceived != null)
                                ...{
                                    this.MessageReceived(omss);
                                }
                            }
                        }
                    }
                    catch (System.Exception e)
                    ...{
                        if (this.MessageException != null)
                        ...{
                            omss.Exception = e;
                            this.MessageException(omss);

                    }
                        else
                        ...{
                            throw e;
                        }
                    }
                }
            }
            catch (System.Exception e)
            ...{
                throw e;
            }
            finally
            ...{
                pop3.Disconnect();
                pop3 = null;
            }
        }

        #endregion

        异步收邮件#region 异步收邮件
        //[MTAThread]
        private void MessageExecuteAsync(MessagesState oMessagesState)
        ...{
            int J = oMessagesState.jMessage.Attachments.Count;
            for (int j = 0; j < J; j++)
            ...{
                AttachmentsState oass = new AttachmentsState(j,oMessagesState);
                (new AttachmentsEventHandler(this.AttachmentExecuteAsync)).BeginInvoke(oass,new System.AsyncCallback(this.OnAttachemnetCallBack),oass);
            }
        }

        //[MTAThread]
        private void AttachmentExecuteAsync(AttachmentsState oAttachmentsState)
        ...{
            //
        }

        //[MTAThread]
        private void OnMessageCallBack(System.IAsyncResult iar)
        ...{
            MessagesState omss = (MessagesState) iar.AsyncState; 
            if (this.MessagesReceiveAsync != null)
            ...{
                if (omss.jMessage.Attachments.Count == 0)
                ...{
                    this.MessagesReceiveAsync(omss);
                }
            }
        }

        //[MTAThread]
        private void OnAttachemnetCallBack(System.IAsyncResult iar)
        ...{
            AttachmentsState oass = (AttachmentsState) iar.AsyncState;
            if (this.AttachmentsReceiveAsync != null)
            ...{
                this.AttachmentsReceiveAsync(oass);
            }
            if (!oass.CancelCurrent)
            ...{
                try
                ...{
                    oass.SaveToFile(oass.FileName);
                }
                catch (System.Exception e)
                ...{
                    oass.Exception = e;
                    if (AttachmentException != null)
                    ...{
                        AttachmentException(oass);
                        if (oass.ExceptionAction == NJMail.ExceptionActions.CancelAll)
                        ...{

                        }
                        else
                            if (oass.ExceptionAction == NJMail.ExceptionActions.Retry)
                        ...{
                            this.OnAttachemnetCallBack((System.IAsyncResult) oass);
                        }
                        else
                            if (oass.ExceptionAction == NJMail.ExceptionActions.Ignore)
                        ...{

                        }
                        else
                            if (oass.ExceptionAction == NJMail.ExceptionActions.Throw)
                        ...{
                            throw e;
                        }
                    }
                }
            }
            if (this.MessagesReceiveAsync != null)
            ...{
                if (oass.AttachmentsCount == 0)
                ...{
                    this.MessagesReceiveAsync(oass.MessagesState);
                }
            }
        }
        #endregion
    }


    邮件#region 邮件
    public class MessagesState //Messages 状态
    ...{
        private static object _LockObject = new object();
        private int _MessageID;
        private jmail.MessageClass _jMessage;
        private jmail.MessagesClass _jMessages;
        private jmail.POP3Class _jPOP3;
        private string _FilePath;

        private bool _CancelCurrent;
        private System.Exception _Exception;
        private ExceptionActions _ExceptionAction;

        public ExceptionActions ExceptionAction
        ...{
            get
            ...{
                return _ExceptionAction;
            }
            set
            ...{
                this._ExceptionAction = value;
            }
        }

        public System.Exception Exception
        ...{
            get
            ...{
                return _Exception;
            }
            set
            ...{
                this._Exception = value;
            }
        }

        public string FilePath
        ...{
            get
            ...{
                return this._FilePath;
            }
        }

        internal void SetFilePath(string FilePath)
        ...{
            this._FilePath = FilePath;
        }

        public bool CancelCurrent
        ...{
            get
            ...{
                return this._CancelCurrent;
            }
            set
            ...{
                this._CancelCurrent = value;
            }
        }

        public int MessagesCount //尚未处理的邮件数
        ...{
            get
            ...{
                //lock(MessagesState._LockObject)
            ...{
                return this._jMessages.Count - this._MessageID - 1;
            }
            }
        }

        public jmail.MessagesClass jMessages
        ...{
            get
            ...{
                return this._jMessages;
            }
        }

        public jmail.MessageClass jMessage
        ...{
            get
            ...{
                return this._jMessage;
            }
        }

        public int MessageID
        ...{
            get
            ...{
                return this._MessageID;
            }
        }

        internal MessagesState(int MessageID,jmail.MessageClass jMessage,jmail.MessagesClass jMessages,jmail.POP3Class jPOP3)
        ...{
            this._MessageID = MessageID;
            this._jMessage = jMessage;
            this._jMessages = jMessages;
            this._jPOP3 = jPOP3;
        }

        public void DeleteSingleMessage()
        ...{
            lock(MessagesState._LockObject)
            ...{
                this.DeleteSingleMessage(this._MessageID);
            }
   
        }

        public void DeleteSingleMessage(int MessageID)
        ...{
            lock(MessagesState._LockObject)
            ...{
                this._jPOP3.DeleteSingleMessage(MessageID);
            }
        }

        public void DeleteMessages()
        ...{
            lock(MessagesState._LockObject)
            ...{
                this._jPOP3.DeleteMessages();
            }
        }
    }

    #endregion

    异常类型#region 异常类型
    public enum ExceptionActions
    ...{
        CancelAll,Ignore,Retry,Throw
    }
    #endregion

    附件#region 附件
    public class AttachmentsState //Attachments 状态
    ...{
        private MessagesState _MessagesState;
        private int _AttachmentID;
        private string _FileName;
        private static object _LockObject = new object();
        private jmail.AttachmentClass _jAttachment;
        private bool _CancelCurrent;
        private System.Exception _Exception;
        private ExceptionActions _ExceptionAction;

        public ExceptionActions ExceptionAction
        ...{
            get
            ...{
                return _ExceptionAction;
            }
            set
            ...{
                this._ExceptionAction = value;
            }
        }

        public System.Exception Exception
        ...{
            get
            ...{
                return _Exception;
            }
            set
            ...{
                this._Exception = value;
            }
        }

        public bool CancelCurrent
        ...{
            get
            ...{
                return this._CancelCurrent;
            }
            set
            ...{
                this._CancelCurrent = value;
            }
        }

        public jmail.AttachmentClass jAttachment
        ...{
            get
            ...{
                return this._jAttachment;
            }
        }

        public int AttachmentsCount //尚未处理的邮件附件数
        ...{
            get
            ...{
                //lock(AttachmentsState._LockObject)
            ...{
                return this._MessagesState.jMessage.Attachments.Count - this._AttachmentID - 1;
            }
            }
        }

        public string FileName
        ...{
            get
            ...{
                return this._FileName;
            }
            set
            ...{
                this._FileName = value;
            }
        }

        public MessagesState MessagesState
        ...{
            get
            ...{
                return this._MessagesState;
            }
        }

        public int AttachmentID
        ...{
            get
            ...{
                return this._AttachmentID;
            }
        }

        public void SaveToFile(string FileName)
        ...{
            if (!this.CancelCurrent)
            ...{
                this._jAttachment.SaveToFile(FileName);
            }
        }

        internal AttachmentsState(int AttachmentID,MessagesState oMessagesState)
        ...{
            this._MessagesState = oMessagesState;
            this._AttachmentID = AttachmentID;
            this._jAttachment = (jmail.AttachmentClass) oMessagesState.jMessage.Attachments[AttachmentID];
            this._FileName = System.String.Format("[{0}].{1}.[{2}].{3}",oMessagesState.MessageID,oMessagesState.jMessage.Subject,AttachmentID,this._jAttachment.Name);
        }
    }
    #endregion
}

//调用方法,放在要调用的类里,其中this开头的变量需要预先声明和赋值

/**//// <summary>
        /// 接收邮件
        /// </summary>
        private void Pop3()
        ...{
            this.mCount = 0;
            this.aCount = 0;

            try
            ...{
                x = new Common.NJMail.POP3(this.MailLoginName,this.MailLoginPwd,this.MailServer,this.MailPort);//配置邮件服务器
                x.MCount = this.MailAmount;
                x.RetryCount = this.MailRetry;
                x.BDelete = this.MailDelete;
                x.MessageReceive += new Common.NJMail.POP3.MessagesEventHandler(x_MessageReceive);
                x.MessageReceived += new Common.NJMail.POP3.MessagesEventHandler(x_MessageReceived);
                x.AttachmentReceive += new Common.NJMail.POP3.AttachmentsEventHandler(x_AttachmentReceive);
                x.AttachmentException += new Common.NJMail.POP3.AttachmentsEventHandler(x_AttachmentException);
                x.MessageException += new Common.NJMail.POP3.MessagesEventHandler(x_MessageException);
                x.Execute();

                Debug.WriteLine("邮件接收报文成功! ");
                Debug.WriteLine("共接收邮件 "+this.mCount.ToString()+" 个，附件 "+this.aCount.ToString()+" 个！ ");
            }
            catch(Exception ex)
            ...{
                Debug.WriteLine("邮件接收报文出错!出错原因："+ex.Message+" ");
            }
        }

        /**//// <summary>
        /// 接收当前邮件
        /// </summary>
        /// <param name="oMessagesState">邮件</param>
        private void x_MessageReceive(Common.NJMail.MessagesState oMessagesState)
        ...{
            Debug.WriteLine(oMessagesState.MessageID.ToString()+",Subject:《"+oMessagesState.jMessage.Subject+"》");
            Debug.WriteLine("Body: "+oMessagesState.jMessage.Body);
            Debug.WriteLine("Text: "+oMessagesState.jMessage.Text);
        }

        /**//// <summary>
        /// 接收当前邮件结束
        /// </summary>
        /// <param name="oMessagesState">邮件</param>
        private void x_MessageReceived(Common.NJMail.MessagesState oMessagesState)
        ...{
            if (oMessagesState.MessageID > 0)
            ...{
                Debug.WriteLine("邮件 "+oMessagesState.MessageID.ToString()+" 接收完成!");
                if(this.MailDelete)
                ...{
                    oMessagesState.DeleteSingleMessage();
                    Debug.WriteLine("邮件 "+oMessagesState.MessageID.ToString()+" 删除!");
                }
                this.mCount++;
            }
        }

        /**//// <summary>
        /// 接收当前邮件附件
        /// </summary>
        /// <param name="oAttachmentsState">附件集</param>
        private void x_AttachmentReceive(Common.NJMail.AttachmentsState oAttachmentsState)
        ...{
//判断指定路径的附件是否存在
            if(!Directory.Exists(Application.StartupPath + "/"+ this.MailDownPath))
                Directory.CreateDirectory(Application.StartupPath + "/"+ this.MailDownPath);
            oAttachmentsState.FileName =  Application.StartupPath + "/"+ this.MailDownPath + oAttachmentsState.jAttachment.Name;
            if(!File.Exists(oAttachmentsState.FileName))
                oAttachmentsState.SaveToFile(oAttachmentsState.FileName);
            if (oAttachmentsState.Exception != null)
            ...{
                throw oAttachmentsState.Exception ;
            }

            oAttachmentsState.CancelCurrent = true; //不Save处理当前附件
            if (oAttachmentsState.AttachmentID > -1)
            ...{
                Debug.WriteLine("附件 "+oAttachmentsState.AttachmentID.ToString()+":"+oAttachmentsState.FileName +"下载完成！");
            }
            this.aCount++;
        }

        /**//// <summary>
        /// 接收附件异常处理
        /// </summary>
        /// <param name="oAttachmentsState">附件</param>
        private void x_AttachmentException(Common.NJMail.AttachmentsState oAttachmentsState)
        ...{
            if(File.Exists(Application.StartupPath + "/"+ this.MailDownPath + oAttachmentsState.jAttachment.Name))
                this.DeleteFile(Application.StartupPath + "/"+ this.MailDownPath + oAttachmentsState.jAttachment.Name);
            oAttachmentsState.ExceptionAction = Common.NJMail.ExceptionActions.Retry;
        }

        /**//// <summary>
        /// 接收邮件异常处理
        /// </summary>
        /// <param name="oMessagesState">邮件</param>
        private void x_MessageException(Common.NJMail.MessagesState oMessagesState)
        ...{
            //oMessagesState.ExceptionAction = Common.NJMail.ExceptionActions.Retry; 
            Debug.WriteLine("接收邮件 "+oMessagesState.MessageID.ToString()+" 出错!错误原因："+oMessagesState.Exception.Message);
            this.log.WriteLogFile("接收邮件 "+oMessagesState.jMessage.Subject+" 时出错！错误原因："+oMessagesState.Exception.Message+" ");
        }