你现在查看的是MailMessageEx.cs类的源码

view plainprint?
  1.  /// <summary>  
  2. /// 类说明：Assistant  
  3. /// 编 码 人：苏飞  
  4. /// 联系方式：361983679    
  5. /// 更新网站：http://www.sufeinet.com/thread-655-1-1.html  
  6. /// </summary>  
  7. using System;  
  8. using System.Collections.Generic;  
  9. using System.Net.Mail;  
  10. using System.Net.Mime;  
  11. using System.Text.RegularExpressions;  
  12.   
  13. namespace DotNet.Utilities  
  14. {  
  15.     /// <summary>  
  16.     /// This class adds a few internet mail headers not already exposed by the   
  17.     /// System.Net.MailMessage.  It also provides support to encapsulate the  
  18.     /// nested mail attachments in the Children collection.  
  19.     /// </summary>  
  20.     public class MailMessageEx : MailMessage  
  21.     {  
  22.         public const string EmailRegexPattern = "(['\"]{1,}.+['\"]{1,}\\s+)?<?[\\w\\.\\-]+@[^\\.][\\w\\.\\-]+\\.[a-z]{2,}>?";  
  23.   
  24.         private long _octets;  
  25.   
  26.         public long Octets  
  27.         {  
  28.             get { return _octets; }  
  29.             set { _octets = value; }  
  30.         }  
  31.   
  32.         private int _messageNumber;  
  33.   
  34.         /// <summary>  
  35.         /// Gets or sets the message number of the MailMessage on the POP3 server.  
  36.         /// </summary>  
  37.         /// <value>The message number.</value>  
  38.         public int MessageNumber  
  39.         {  
  40.             get { return _messageNumber; }  
  41.             internal set { _messageNumber = value; }  
  42.         }  
  43.   
  44.   
  45.         private static readonly char[] AddressDelimiters = new char[] { ',', ';' };  
  46.   
  47.         private List<MailMessageEx> _children;  
  48.         /// <summary>  
  49.         /// Gets the children MailMessage attachments.  
  50.         /// </summary>  
  51.         /// <value>The children MailMessage attachments.</value>  
  52.         public List<MailMessageEx> Children  
  53.         {  
  54.             get  
  55.             {  
  56.                 return _children;  
  57.             }  
  58.         }  
  59.   
  60.         /// <summary>  
  61.         /// Gets the delivery date.  
  62.         /// </summary>  
  63.         /// <value>The delivery date.</value>  
  64.         public DateTime DeliveryDate  
  65.         {  
  66.             get  
  67.             {  
  68.                 string date = GetHeader(MailHeaders.Date);  
  69.                 if (string.IsNullOrEmpty(date))  
  70.                 {  
  71.                     return DateTime.MinValue;  
  72.                 }  
  73.   
  74.                 if ((date.IndexOf("(EST)") > 1) && (date.IndexOf("-") > 1))  
  75.                 {  
  76.                     date = date.Substring(0, date.IndexOf("-"));  
  77.                 }  
  78.                 return Convert.ToDateTime(date);  
  79.             }  
  80.         }  
  81.   
  82.         /// <summary>  
  83.         /// Gets the return address.  
  84.         /// </summary>  
  85.         /// <value>The return address.</value>  
  86.         public MailAddress ReturnAddress  
  87.         {  
  88.             get  
  89.             {  
  90.                 string replyTo = GetHeader(MailHeaders.ReplyTo);  
  91.                 if (string.IsNullOrEmpty(replyTo))  
  92.                 {  
  93.                     return null;  
  94.                 }  
  95.   
  96.                 return CreateMailAddress(replyTo);  
  97.             }  
  98.         }  
  99.   
  100.         /// <summary>  
  101.         /// Gets the routing.  
  102.         /// </summary>  
  103.         /// <value>The routing.</value>  
  104.         public string Routing  
  105.         {  
  106.             get { return GetHeader(MailHeaders.Received); }  
  107.         }  
  108.   
  109.         /// <summary>  
  110.         /// Gets the message id.  
  111.         /// </summary>  
  112.         /// <value>The message id.</value>  
  113.         public string MessageId  
  114.         {  
  115.             get { return GetHeader(MailHeaders.MessageId); }  
  116.         }  
  117.   
  118.         public string ReplyToMessageId  
  119.         {  
  120.             get { return GetHeader(MailHeaders.InReplyTo, true); }  
  121.         }  
  122.   
  123.         /// <summary>  
  124.         /// Gets the MIME version.  
  125.         /// </summary>  
  126.         /// <value>The MIME version.</value>  
  127.         public string MimeVersion  
  128.         {  
  129.             get { return GetHeader(MimeHeaders.MimeVersion); }  
  130.         }  
  131.   
  132.         /// <summary>  
  133.         /// Gets the content id.  
  134.         /// </summary>  
  135.         /// <value>The content id.</value>  
  136.         public string ContentId  
  137.         {  
  138.             get { return GetHeader(MimeHeaders.ContentId); }  
  139.         }  
  140.   
  141.         /// <summary>  
  142.         /// Gets the content description.  
  143.         /// </summary>  
  144.         /// <value>The content description.</value>  
  145.         public string ContentDescription  
  146.         {  
  147.             get { return GetHeader(MimeHeaders.ContentDescription); }  
  148.         }  
  149.   
  150.         /// <summary>  
  151.         /// Gets the content disposition.  
  152.         /// </summary>  
  153.         /// <value>The content disposition.</value>  
  154.         public ContentDisposition ContentDisposition  
  155.         {  
  156.             get  
  157.             {  
  158.                 string contentDisposition = GetHeader(MimeHeaders.ContentDisposition);  
  159.                 if (string.IsNullOrEmpty(contentDisposition))  
  160.                 {  
  161.                     return null;  
  162.                 }  
  163.   
  164.                 return new ContentDisposition(contentDisposition);  
  165.             }  
  166.         }  
  167.   
  168.         /// <summary>  
  169.         /// Gets the type of the content.  
  170.         /// </summary>  
  171.         /// <value>The type of the content.</value>  
  172.         public ContentType ContentType  
  173.         {  
  174.             get  
  175.             {  
  176.                 string contentType = GetHeader(MimeHeaders.ContentType);  
  177.                 if (string.IsNullOrEmpty(contentType))  
  178.                 {  
  179.                     return null;  
  180.                 }  
  181.   
  182.                 return MimeReader.GetContentType(contentType);  
  183.             }  
  184.         }  
  185.   
  186.         /// <summary>  
  187.         /// Initializes a new instance of the <see cref="MailMessageEx"/> class.  
  188.         /// </summary>  
  189.         public MailMessageEx()  
  190.             : base()  
  191.         {  
  192.             _children = new List<MailMessageEx>();  
  193.         }  
  194.   
  195.         /// <summary>  
  196.         /// Gets the header.  
  197.         /// </summary>  
  198.         /// <param name="header">The header.</param>  
  199.         /// <returns></returns>  
  200.         private string GetHeader(string header)  
  201.         {  
  202.             return GetHeader(header, false);  
  203.         }  
  204.   
  205.         private string GetHeader(string header, bool stripBrackets)  
  206.         {  
  207.             if (stripBrackets)  
  208.             {  
  209.                 return MimeEntity.TrimBrackets(Headers[header]);  
  210.             }  
  211.   
  212.             return Headers[header];  
  213.         }  
  214.   
  215.         /// <summary>  
  216.         /// Creates the mail message from entity.  
  217.         /// </summary>  
  218.         /// <param name="entity">The entity.</param>  
  219.         /// <returns></returns>  
  220.         public static MailMessageEx CreateMailMessageFromEntity(MimeEntity entity)  
  221.         {  
  222.             MailMessageEx message = new MailMessageEx();  
  223.             string value;  
  224.             foreach (string key in entity.Headers.AllKeys)  
  225.             {  
  226.                 value = entity.Headers[key];  
  227.                 if (value.Equals(string.Empty))  
  228.                 {  
  229.                     value = " ";  
  230.                 }  
  231.   
  232.                 message.Headers.Add(key.ToLowerInvariant(), value);  
  233.   
  234.                 switch (key.ToLowerInvariant())  
  235.                 {  
  236.                     case MailHeaders.Bcc:  
  237.                         MailMessageEx.PopulateAddressList(value, message.Bcc);  
  238.                         break;  
  239.                     case MailHeaders.Cc:  
  240.                         MailMessageEx.PopulateAddressList(value, message.CC);  
  241.                         break;  
  242.                     case MailHeaders.From:  
  243.                         message.From = MailMessageEx.CreateMailAddress(value);  
  244.                         break;  
  245.                     case MailHeaders.ReplyTo:  
  246.                         message.ReplyTo = MailMessageEx.CreateMailAddress(value);  
  247.                         break;  
  248.                     case MailHeaders.Subject:  
  249.                         message.Subject = value;  
  250.                         break;  
  251.                     case MailHeaders.To:  
  252.                         MailMessageEx.PopulateAddressList(value, message.To);  
  253.                         break;  
  254.                 }  
  255.             }  
  256.   
  257.             return message;  
  258.         }  
  259.   
  260.         /// <summary>  
  261.         /// Creates the mail address.  
  262.         /// </summary>  
  263.         /// <param name="address">The address.</param>  
  264.         /// <returns></returns>  
  265.         public static MailAddress CreateMailAddress(string address)  
  266.         {  
  267.             try  
  268.             {  
  269.                 return new MailAddress(address.Trim('\t'));  
  270.             }  
  271.             catch //(FormatException e)  
  272.             {  
  273.                 //throw new Pop3Exception("Unable to create mail address from provided string: " + address, e);Mail Delivery System  
  274.                 return new MailAddress(address + "@mail.error");  
  275.             }  
  276.         }  
  277.   
  278.         /// <summary>  
  279.         /// Populates the address list.  
  280.         /// </summary>  
  281.         /// <param name="addressList">The address list.</param>  
  282.         /// <param name="recipients">The recipients.</param>  
  283.         public static void PopulateAddressList(string addressList, MailAddressCollection recipients)  
  284.         {  
  285.             foreach (MailAddress address in GetMailAddresses(addressList))  
  286.             {  
  287.                 recipients.Add(address);  
  288.             }  
  289.         }  
  290.   
  291.         /// <summary>  
  292.         /// Gets the mail addresses.  
  293.         /// </summary>  
  294.         /// <param name="addressList">The address list.</param>  
  295.         /// <returns></returns>  
  296.         private static IEnumerable<MailAddress> GetMailAddresses(string addressList)  
  297.         {  
  298.             Regex email = new Regex(EmailRegexPattern);  
  299.   
  300.             foreach (Match match in email.Matches(addressList))  
  301.             {  
  302.                 yield return CreateMailAddress(match.Value);  
  303.             }  
  304.   
  305.   
  306.             /* 
  307.             string[] addresses = addressList.Split(AddressDelimiters); 
  308.             foreach (string address in addresses) 
  309.             { 
  310.                 yield return CreateMailAddress(address); 
  311.             }*/  
  312.         }  
  313.     }  
  314. }