mailkit库收发邮件

mailkit库用于收发邮件.这个库可以替代C#自带的发邮件库

环境  W10 / VS2017CMMT / MailKit version="2.0.3" "net46"  / MimeKit version="2.0.3" "net46"

mailkit使用nuget下载或者到GIT  https://github.com/jstedfast/MailKit

邮件收发是与邮件服务器交互,原理参考 https://www.cnblogs.com/ysocean/p/7652934.html

帮助类参考部份mailkit源码.可简单实现发邮件与收邮件.在处理大附件,草稿保存,时未找到解决办法

发送邮件

MyMailKit mymail = new MyMailKit();
// 设置发件人
mymail.CfgSendEmail(1);
// 添加1个或多个收件人
mymail.AddTo("xxx@qq.com", "收件人XXX");
mymail.AddTo("yyy@163.com");
// 添加1个或多个附件
MemoryStream ms = new MemoryStream();
using (FileStream fs = new FileStream("123.doc", FileMode.Open))
{
    fs.CopyTo(ms);
}
mymail.AddAttachment(ms, "123.doc", ms.Length);
// 发送邮件
mymail.SendEmail();

接收邮件

// 查看一个文件夹的邮件
MyMailKit mymail = new MyMailKit();
// 收邮件配置
mymail.CfgIMAP(1);
// 获取文件夹的所有邮件(3个月内的)
var list = mymail.GetEmailByFolder(folder);
if (list == null)
{
   // 没找到邮件出错信息提示
   mymail.ErrMsg;
   return;
}
foreach (var item in list)
{
   // 收件人
   StringBuilder tolist = new StringBuilder();
   foreach (var to in item.ToList)
   {
      tolist.Append($"{to.Name}<{to.Address}>,");
   }
   //
   item.UniqueId; // 邮件标识
   item.IsRead;// 是否已读
   item.Count;// 附件数
   item.IsAnswered;// 是否回复
   item.Name;// 发件人
   item.Address;// 发件人邮箱
   item.Subject;// 标题
   item.Date.ToString("yyyy-MM-dd");// 日期
}
// 显示邮件详细
var emdetail = mymail.GetEmailByUniqueId(uint.Parse(id), folder);
// 设置删除邮件
List uids = new List();
uids.Add(id);
mymail.SetFlag(uids, 8, folder);

  public class MyMailKit
     {
         #region 属性 账户配置信息等
         /// <summary>
         ///  发件人邮箱地址
         /// </summary>
         private string fromEmail = null;
         /// <summary>
         ///  发件人别名
         /// </summary>
         private string fromAlias = null;
         /// <summary>
         /// 发件人邮箱密码(或授权码)
         /// </summary>
         private string fromPwd = null;
         /// <summary>
         /// SMTP服务器地址
         /// </summary>
         private string serverSMTP = null;
         private int portSMTP = ;
         /// <summary>
         /// IMAP服务器地址
         /// </summary>
         private string serverIMAP = null;
         private int portIMAP = ;
         /// <summary>
         /// POP服务器地址
         /// </summary>
         private string serverPOP = null;
         private int portPOP = ;
         /// <summary>
         /// 邮件账户(收邮件时登录账户)
         /// </summary>
         private string account = null;
         /// <summary>
         /// 邮件账户密码(收邮件时登录密码)
         /// </summary>
         private string pwd = null;
         #endregion

         #region 属性 邮件主体内容 内容块容器

         /// <summary>
         /// 邮件对象
         /// </summary>
         private MimeMessage message = null;
         /// <summary>
         /// 邮件内容块的容器 放置邮件正文,附件等内容块
         /// </summary>
         private Multipart mimeparts = null;
         /// <summary>
         /// 收件人列表
         /// </summary>
         private List<MailboxAddress> toList = null;
         /// <summary>
         /// 附件列表
         /// </summary>
         private List<MimePart> attaList = null;
         #endregion

         /// <summary>
         /// 操作异常信息
         /// </summary>
         public string ErrMsg { get; private set; }

         #region 制作与发送邮件

         /// <summary>
         /// 添加一个收件人
         /// 在制作邮件方法之前调用
         /// </summary>
         /// <param name="address">收件人地址</param>
         /// <param name="name"></param>
         public void AddTo(string address, string name = null)
         {
             if (this.toList == null)
                 this.toList = new List<MailboxAddress>();
             if (string.IsNullOrWhiteSpace(name))
                 name = address.Substring(, address.IndexOf('@'));
             this.toList.Add(new MailboxAddress(name, address));
         }

         /// <summary>
         /// 添加一个附件
         /// 在制作邮件方法之前调用
         /// </summary>
         /// <param name="atta">附件流</param>
         /// <param name="name">附件名字</param>
         /// <param name="size">附件大小(K)</param>
         public void AddAttachment(Stream atta, string name, long size = )
         {
             try
             {
                 if (this.attaList == null)
                     this.attaList = new List<MimePart>();
                 // 附件内容块
                 MimePart attapart = new MimePart();
                 attapart.Content = new MimeContent(atta);

                 // 内容描述为附件
                 attapart.ContentDisposition = new ContentDisposition(ContentDisposition.Attachment);

                 // 附件名字设置,如果名字有中文也没关系
                 attapart.ContentDisposition.FileName = name;
                 // 大小设置
                 if (size > )
                     attapart.ContentDisposition.Size = size;

                 // 采用base64编码传输
                 attapart.ContentTransferEncoding = ContentEncoding.Base64;

                 //
                 this.attaList.Add(attapart);
             }
             catch (Exception e)
             {
                 ErrMsg = $"添加附件异常:{e.ToString()} [{e.Message}]";
             }
         }

         /// <summary>
         /// 制作一封邮件
         /// 调用此方法之前,先调用邮件配置初始化方法和添加收件人,添加附件方法
         /// </summary>
         /// <param name="subject">邮件主题(标题)</param>
         /// <param name="body">邮件正文(内容)</param>
         /// <param name="ishtml">正文是否为HTML格式,纯文本格式=false</param>
         public void MakeEmail(string subject, string body, bool ishtml = true)
         {
             try
             {
                 // 邮件类新实例
                 message = new MimeMessage();

                 // 设置邮件主题
                 message.Subject = subject;

                 // 设置发件人信息
                 message.From.Add(new MailboxAddress(fromAlias, fromEmail));

                 // 设置收件人信息
                 message.To.AddRange(this.toList);

                 // 设置邮件正文
                 var content = new TextPart(ishtml ? "html" : "plain");
                 content.SetText(Encoding.UTF8, body);

                 // 建立内容块容器,将内容或附件等添加到其中 MimeEntity是各种类型内容的基类
                 mimeparts = new Multipart("mixed");
                 mimeparts.Add(content);
                 // 附件
                 if (this.attaList != null)
                 {
                     foreach (var atta in this.attaList)
                     {
                         mimeparts.Add(atta);
                     }
                 }

                 // 将内容块容器设置到邮件的内容.到此已经填好邮件实体的主要属性
                 message.Body = mimeparts;
             }
             catch (Exception e)
             {
                 ErrMsg = $"制作邮件异常:{e.ToString()} [{e.Message}]";
             }
         }

         /// <summary>
         /// 设置此邮件是对指定邮件的回复(这是一封回复邮件)
         /// 在调用制作邮件方法之后调用,在发送前调用.需要调用收件配置方法CfgIMAP()
         /// </summary>
         /// <param name="uniqueid">被回复邮件唯一标识</param>
         /// <param name="folderName">被回复邮件文件夹</param>
         public void SetReplyTo(uint uniqueid, string folderName = null)
         {
             try
             {
                 // 被回复的邮件
                 MimeMessage remail;
                 // 查找这个被回复的邮件,设置回复状态
                 using (var client = ConnectIMAP())
                 {
                     if (folderName == null)
                         folderName = client.Inbox.Name;
                     var emailUniqueId = new UniqueId(uniqueid);
                     var folder = client.GetFolder(folderName);
                     folder.Open(FolderAccess.ReadWrite);

                     remail = folder.GetMessage(emailUniqueId);
                     folder.AddFlags(emailUniqueId, MessageFlags.Answered, true);
                     folder.Close();
                     client.Disconnect(true);
                 }
                 // construct the In-Reply-To and References headers
                 if (!string.IsNullOrEmpty(remail.MessageId))
                 {
                     // 设置此邮件是对这个MESSAGEID的邮件的回复
                     message.InReplyTo = remail.MessageId;
                     // 此邮件的"对其它消息"的引用属性设为这个邮件的引用属性
                     foreach (var id in remail.References)
                         message.References.Add(id);
                     message.References.Add(remail.MessageId);
                 }
                 // 回复邮件主题前面加RE:
                 if (!message.Subject.StartsWith("RE:", StringComparison.OrdinalIgnoreCase))
                     message.Subject = "RE:" + message.Subject;
             }
             catch (Exception e)
             {
                 ErrMsg = $"设置为回复邮件异常:{e.ToString()} [{e.Message}]";
             }
         }

         /// <summary>
         /// 设置
         /// </summary>
         /// <param name="uniqueid"></param>
         /// <param name="folderName"></param>
         //public void SetForWard(uint uniqueid, string folderName = null)
         //{

         //}

         /// <summary>
         /// 发送一个邮件
         /// 调用此方法之前,请先调用建立邮件的方法MakeMessage()
         /// </summary>
         public bool SendEmail()
         {
             try
             {
                 // 建立发件服务客户端
                 using (var client = new SmtpClient())
                 {
                     // SMTP服务器
                     client.Connect(serverSMTP, portSMTP);

                     // 登录
                     client.Authenticate(fromEmail, fromPwd);

                     // 发邮件
                     client.Send(message);

                     // 关闭连接
                     client.Disconnect(true);
                     return true;
                 }
             }
             catch (Exception e)
             {
                 ErrMsg = $"发送邮件异常:{e.ToString()} [{e.Message}]";
                 return false;
             }
         }

         #endregion

         #region 接收与处理邮件

         /// <summary>
         /// 连接到IMAP服务器
         /// </summary>
         private ImapClient ConnectIMAP()
         {
             try
             {
                 ImapClient client = new ImapClient();
                 client.Connect(serverIMAP, portIMAP);
                 client.Authenticate(account, pwd);

                 /**********************************************************************/
                 // 网易126 163相关邮箱时,要用这两句话,表明客户端身份.在连接后调用.否则无法登录邮箱.
                 var clientImplementation = new ImapImplementation
                 {
                     Name = "MeSince",
                     Version = "2.0"
                 };
                 var serverImplementation = client.Identify(clientImplementation);
                 /*********************************************************************/

                 return client;
             }
             catch (Exception e)
             {
                 ErrMsg = $"连接到IMAP服务器异常:{e.ToString()} [{e.Message}]";
                 return null;
             }
         }

         /// <summary>
         /// 获取邮箱的所有文件夹列表
         /// 调用前先调用配置方法CfgIMAP()
         /// </summary>
         public EmailViewM GetFolders()
         {
             try
             {
                 using (var client = ConnectIMAP())
                 {
                     List<IMailFolder> mailFolderList = client.GetFolders(client.PersonalNamespaces[]).ToList();
                     var entity = FillEntity(null, null, mailFolderList.ToArray());
                     client.Disconnect(true);
                     //
                     return entity;
                 }
             }
             catch (Exception e)
             {
                 ErrMsg = $"获取邮箱的所有文件夹异常:{e.ToString()} [{e.Message}]";
                 return null;
             }
         }

         /// <summary>
         /// 根据唯一标识和文件夹名,获取单个邮件
         /// </summary>
         /// <param name="folderName"></param>
         /// <returns></returns>
         public EmailViewM GetEmailByUid(uint uniqueid, string folderName = null)
         {
             try
             {
                 using (ImapClient client = ConnectIMAP())
                 {
                     if (folderName == null)
                         folderName = client.Inbox.Name;
                     IMailFolder folder = client.GetFolder(folderName);
                     folder.Open(FolderAccess.ReadOnly);
                     var email = folder.GetMessage(new UniqueId(uniqueid));
                     var entity = FillEntity(null, email);
                     //
                     folder.Close();
                     client.Disconnect(true);
                     //
                     return entity;
                 }
             }
             catch (Exception e)
             {
                 ErrMsg = $"获取单个邮件异常:{e.ToString()} [{e.Message}]";
                 return null;
             }
         }

         /// <summary>
         /// 获取一个文件夹的邮件 返回一个列表,包含摘要信息.收件/发件人,有几个附件,时间和标题,是否已读
         /// 默认只获取3个月内的邮件
         /// 调用前先调用配置方法CfgIMAP()
         /// </summary>
         public List<EmailViewM> GetEmailByFolder(string folderName = null)
         {
             try
             {
                 using (ImapClient client = ConnectIMAP())
                 {
                     IMailFolder folder;
                     // 默认是收件箱
                     if (folderName == null||folderName.ToLower()=="inbox")
                     {
                         folder=client.GetFolder(client.Inbox.Name);
                     }
                     else {
                         // 其它特定的文件夹
                         string dirK = folderName.ToLower();
                         Dictionary<string, SpecialFolder> fdict = new Dictionary<string, SpecialFolder>();
                         fdict.Add("archive", SpecialFolder.Archive);
                         fdict.Add("drafts", SpecialFolder.Drafts);
                         fdict.Add("flagged", SpecialFolder.Flagged);
                         fdict.Add("sent", SpecialFolder.Sent);
                         fdict.Add("junk", SpecialFolder.Junk);
                         fdict.Add("trash", SpecialFolder.Trash);
                         if (fdict.ContainsKey(dirK))
                             folder = client.GetFolder(fdict[dirK]);
                         else
                         {
                             // 否则是自定义的文件夹,或者是邮件服务商的特别文件夹
                             folder = client.GetFolder(folderName);
                         }
                     }

                     folder.Open(FolderAccess.ReadOnly);

                     // 获取所有邮件的唯一标识列表
                     SearchQuery sq = SearchQuery.DeliveredAfter(DateTime.Today.AddMonths(-));
                     var emailUids = folder.Search(sq);

                     // 获取这些邮件的摘要信息(MessageSummaryItems.BodyStructure这个项可以知道是否带附件)
                     var mails = folder.Fetch(emailUids, MessageSummaryItems.UniqueId | MessageSummaryItems.BodyStructure | MessageSummaryItems.Full);
                     List<EmailViewM> entityls = new List<EmailViewM>();
                     foreach (var emhead in mails)
                     {
                         var entity = FillEntity(emhead, null, folder);
                         entityls.Add(entity);
                     }
                     //
                     folder.Close();
                     client.Disconnect(true);
                     //
                     return entityls;
                 }
             }
             catch (Exception e)
             {
                 ErrMsg = $"获取一个文件夹的邮件异常:{e.ToString()} [{e.Message}]";
                 return null;
             }
         }

         /// <summary>
         /// 使用唯一ID获取一封完整邮件
         /// 调用前先调用配置方法CfgIMAP()
         /// </summary>
         /// <param name="folder">文件夹名,默认是收件箱</param>
         /// <param name="uniqueid">邮件唯一编号</param>
         public EmailViewM GetEmailByUniqueId(uint uniqueid, string folderName = null)
         {
             try
             {
                 using (ImapClient client = ConnectIMAP())
                 {
                     if (folderName == null)
                         folderName = client.Inbox.Name;
                     IMailFolder folder = client.GetFolder(folderName);
                     folder.Open(FolderAccess.ReadWrite);
                     UniqueId emailUniqueId = new UniqueId(uniqueid);

                     // 获取这些邮件的摘要信息
                     List<UniqueId> uids = new List<UniqueId>();
                     uids.Add(emailUniqueId);
                     var emaills = folder.Fetch(uids, MessageSummaryItems.UniqueId | MessageSummaryItems.Envelope);
                     var emhead = emaills[];

                     // 获取邮件含正文部分,然后设置为已读.
                     MimeMessage embody = folder.GetMessage(emailUniqueId);
                     folder.AddFlags(emailUniqueId, MessageFlags.Seen, true);

                     /*赋值到实体类*/
                     var entity = FillEntity(emhead, embody, folder);
                     //
                     folder.Close();
                     client.Disconnect(true);
                     //
                     return entity;
                 }
             }
             catch (Exception e)
             {
                 ErrMsg = $"获取单个完整邮件异常:{e.ToString()} [{e.Message}]";
                 return null;
             }
         }

         /// <summary>
         /// 邮件添加标识(已读,已回复,已删除等等).参数值参考EmailViewM实体同名属性
         /// 调用前先调用配置方法CfgIMAP()
         /// </summary>
         /// <param name="uniqueIdls">同一文件夹下的邮件唯一标识列表</param>
         /// <param name="flag">标识代码 1=已读 2=已回复 8=删除</param>
         /// <param name="folderType">文件夹名</param>
         public void SetFlag(List<uint> uniqueIdls, int flag, string folderType = null)
         {
             try
             {
                 using (ImapClient client = ConnectIMAP())
                 {
                     List<UniqueId> uniqueids = uniqueIdls.Select(o => new UniqueId(o)).ToList();
                     MessageFlags messageFlags = (MessageFlags)flag;
                     if (folderType == null)
                         folderType = client.Inbox.Name;
                     IMailFolder folder = client.GetFolder(folderType);
                     folder.Open(FolderAccess.ReadWrite);
                     folder.AddFlags(uniqueids, messageFlags, true);
                     //
                     folder.Close();
                     client.Disconnect(true);
                 }
             }
             catch (Exception e)
             {
                 ErrMsg = $"邮件添加标识时异常:{e.ToString()} [{e.Message}]";
             }
         }

         /// <summary>
         /// 将邮件保存到草稿箱 返回邮件的唯一标识
         /// 调用前先调用配置方法CfgIMAP(),调用制做邮件方法
         /// </summary>
         public int SaveDrafts(int uniqueId = -)
         {
             try
             {
                 using (ImapClient client = ConnectIMAP())
                 {
                     // 打开草稿箱,添加邮件
                     IMailFolder folder = client.GetFolder(SpecialFolder.Drafts);
                     folder.Open(FolderAccess.ReadWrite);

                     // 如果保存的是已经有的草稿邮件,则删除它再保存新的草稿.(没找到保存已有草稿的办法)
                     if (uniqueId > -)
                     {
                         List<UniqueId> uidls = new List<UniqueId>();
                         uidls.Add(new UniqueId((uint)uniqueId));
                         folder.SetFlags(uidls, MessageFlags.Seen | MessageFlags.Deleted, true);
                         folder.Expunge(uidls);
                     }

                     UniqueId? uid = folder.Append(this.message, MessageFlags.Seen | MessageFlags.Draft);
                     //
                     folder.Close();
                     client.Disconnect(true);
                     return uid.HasValue ? (int)uid.Value.Id : -;
                 }
             }
             catch (Exception e)
             {
                 ErrMsg = $"邮件保存草稿时异常:{e.ToString()} [{e.Message}]";
                 return -;
             }
         }
         #endregion

         /// <summary>
         /// 将邮件相关信息填充到实体对象
         /// </summary>
         /// <param name="emhead">邮件基本信息</param>
         /// <param name="embody">邮件详细信息</param>
         /// <param name="folders">邮箱文件夹</param>
         /// <returns></returns>
         private EmailViewM FillEntity(IMessageSummary emhead = null, MimeMessage embody = null, params IMailFolder[] folders)
         {
             try
             {
                 // 邮件基本信息 主题(标题),发件人名,地址,日期,状态等
                 EmailViewM entity = new EmailViewM();
                 if (emhead != null)
                 {
                     entity.UniqueId = emhead.UniqueId.Id;
                     if (emhead.Envelope.From.Count > )
                     {
                         entity.Name = emhead.Envelope.From.Mailboxes.ElementAt().Name;
                         entity.Address = emhead.Envelope.From.Mailboxes.ElementAt().Address;
                     }
                     entity.Date = emhead.Envelope.Date.Value.DateTime;
                     entity.Subject = emhead.Envelope.Subject;
                     if (folders.Length > )
                     {
                         entity.FolderType = folders[].Name;
                     }
                     // 收件人可能有多个
                     entity.ToList = new List<EmailViewM>();
                     foreach (var to in emhead.Envelope.To.Mailboxes)
                     {
                         entity.ToList.Add(new EmailViewM { Name = to.Name, Address = to.Address });
                     }
                     // 邮件状态,已读未读等等
                     if (emhead.Flags.HasValue)
                     {
                         entity.IsRead = emhead.Flags.Value.HasFlag(MessageFlags.Seen);
                         entity.IsAnswered = emhead.Flags.Value.HasFlag(MessageFlags.Answered);
                     }
                     // 附件个数(只传emhead时)
                     entity.Count = emhead.Attachments.Count();
                 }

                 // 正文 附件
                 if (embody != null)
                 {
                     // 正文
                     entity.BodyText = embody.TextBody;
                     entity.BodyHTML = embody.HtmlBody;

                     // 附件
                     // 附件个数(传embody时,包含有附件完整信息)
                     entity.Count = embody.Attachments.Count();
                     // 附件信息
                     if (entity.Count > )
                     {
                         entity.AttaList = new List<EmailViewM>();
                         // 这里要转成mimepart类型
                         foreach (MimePart attachment in embody.Attachments)
                         {
                             var atta = new EmailViewM();
                             atta.Name = attachment.ContentDisposition.FileName;
                             atta.AttaStream = new MemoryStream();
                             attachment.Content.DecodeTo(atta.AttaStream);
                             atta.Size = Math.Round((double)atta.AttaStream.Length / , ).ToString();
                             entity.AttaList.Add(atta);
                         }
                     }
                 }
                 // 邮箱文件夹
                 if (folders.Length > )
                 {
                     entity.FolderList = new List<EmailViewM>();
                     foreach (var item in folders)
                     {
                         entity.FolderList.Add(new EmailViewM()
                         {
                             Name = item.Name,
                             FolderType = item.Attributes.ToString(),
                             Count = item.Count
                         });
                     }
                 }
                 return entity;
             }
             catch (Exception e)
             {
                 ErrMsg = $"邮件填充到实体时异常:{e.ToString()} [{e.Message}]";
                 return null;
             }
         }

         #region 配置账号密码方法

         /// <summary>
         /// 初始化一个发件人的配置,发件箱,发件箱密码,SMTP服务器
         /// </summary>
         /// <param name="emailCode"></param>
         public void CfgSendEmail(int emailCode)
         {
             switch (emailCode)
             {
                 default:
                     fromAlias = "发件人名称";
                     fromEmail = "发件人地址";
                     fromPwd = "授权码或密码";
                     serverSMTP = "smtp服务器地址";
                     portSMTP = ;
                     break;
             }
         }

         /// <summary>
         /// 初始化一个接收邮件的配置 登录名和密码,IMAP服务器,
         /// </summary>
         /// <param name="accountCode"></param>
         public void CfgIMAP(int accountCode)
         {
             switch (accountCode)
             {
                    default:
                     account = "邮件地址";
                     pwd = "邮件密码或者授权码";//"";
                     serverIMAP = "IMAP服务器地址";
                     portIMAP = ;
                     //serverPOP = "POP3服务器地址";
                     //portPOP = 110;
                     break;
             }
         }

         #endregion
     }        

public class EmailViewM
    {
        /// <summary>
        /// 1.从服务器上获取的邮件的UniqueId
        /// </summary>
        public uint UniqueId { get; set; }
        /// <summary>
        /// 1.发件人名字,这个名字可能为null.因为发件人可以不设名字
        /// 2.收件人名(只在ToList里的对象有值)
        /// 3.附件名(只在AttaList里的对象有值)
        /// 4.文件夹名字(只在FolderList里的对象有值)
        /// </summary>
        public string Name { get; set; }
        /// <summary>
        /// 1.发件人地址
        /// 2.收件人地址(只在ToList里的对象有值)
        /// </summary>
        public string Address { get; set; }
        /// <summary>
        /// 发件人邮箱授权码
        /// </summary>
        public string AuthCode { get; set; }
        /// <summary>
        /// 收件人列表
        /// </summary>
        public List<EmailViewM> ToList { get; set; }
        /// <summary>
        /// 邮件主题(标题)
        /// </summary>
        public string Subject { get; set; }
        /// <summary>
        /// 邮件时间
        /// </summary>
        public DateTime Date { get; set; }
        /// <summary>
        /// 1.附件个数
        /// 2.文件夹内邮件个数(只在FolderList里的对象有值)
        /// </summary>
        public int Count { get; set; }
        /// <summary>
        /// 附件标识ID在保存附件在本地时设置(只在AttaList里的对象有值)
        /// 当附件从邮件服务器下载到本地后,需要向客户端提供下载时,用这个ID找到该附件.
        /// </summary>
        public string AttaGuid { get; set; }
        /// <summary>
        /// 附件大小(只在AttaList里的对象有值)
        /// </summary>
        public string Size { get; set; }
        /// <summary>
        /// 附件流(只在AttaList里的对象有值)
        /// </summary>
        public Stream AttaStream { get; set; }
        /// <summary>
        /// 附件列表
        /// </summary>
        public List<EmailViewM> AttaList { get; set; }
        /// <summary>
        /// 是否已经读
        /// </summary>
        public bool IsRead { get; set; }
        /// <summary>
        /// 是否已经回复
        /// </summary>
        public bool IsAnswered { get; set; }
        /// <summary>
        /// 邮件正文的纯文本形式
        /// </summary>
        public string BodyText { get; set; }
        /// <summary>
        /// 邮件正文的HTML形式.
        /// </summary>
        public string BodyHTML { get; set; }

        /// <summary>
        /// 邮箱的文件夹列表
        /// </summary>
        public List<EmailViewM> FolderList { get; set; }
        /// <summary>
        /// 文件夹类型名
        /// 1.表示当前邮件所处文件夹名字
        /// 2.在FolderList里的对象,表示文件夹名字
        ///inbox(收件箱),
        ///archive(档案箱),
        ///drafts(草稿箱),
        ///flagged(标记的),
        ///junk(垃圾箱),
        ///sent(发件箱),
        ///trash(回收箱)
        /// </summary>
        public string FolderType { get; set; }
        /// <summary>
        /// 邮件标识,需要修改邮件标识时,传入此值
        /// 1=Seen(设为已读),
        /// 2=Answered(设为已经回复),
        /// 8=Deleted(设为删除),
        /// </summary>
        public int Flag { get; set; }
    }