C#访问hotmail邮件

如何使用程序来访问HOTMAIL的邮件

using System;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Text;
using System.Xml;
using System.Web;

namespace Hotmail
{
 /// <summary>
 /// HotmailProxy is able to speak HttpMail to various
 /// Hotmail servers across the world.
 /// </summary>
 public class HotmailProxy
 {
  /// <summary>
  /// Storage area for cookies.
  /// </summary>
  private CookieContainer ccContainer;

  /// <summary>
  /// Creates a new instance of HotmailHttp.
  /// </summary>
  public HotmailProxy()
  {
   Trace.WriteLine("Creating new instance.");
   ccContainer = new CookieContainer();
  }

  /// <summary>
  /// Sends the given request to the given destination
  /// and returns the answer from the server.
  /// </summary>
  /// <param name="request">The request to send.</param>
  /// <param name="destination">The destination to send the request to.</param>
  /// <returns>The answer from the remote host.</returns>
  public string SendRequest(string request, Uri destination)
  {
   // pass along
   return SendRequest(request,destination,null);
  }

  /// <summary>
  /// Sends the given request to the given destination
  /// and returns the answer from the server.
  /// </summary>
  /// <param name="request">The request to send.</param>
  /// <param name="destination">The destination to send the request to.</param>
  /// <param name="credential">The network credentials to use with the request.</param>
  /// <returns>The answer from the remote host.</returns>
  public string SendRequest(string request, Uri destination, NetworkCredential credential)
  {
   // Verify input
   if(request == null || request.Trim().Length == 0)
    throw new ArgumentNullException("request");
   else if (destination == null)
    throw new ArgumentNullException("destination");
   else
   {
    // Get byte[] and send the request using private method.
    byte[] xmlBytes = Encoding.ASCII.GetBytes(request);
    return SendRequestTo(xmlBytes,destination, credential);
   }
  }

  /// <summary>
  /// Sends the given byte[] to the given remote host using
  /// authentication with the supplied credentials.
  /// </summary>
  /// <param name="requestBytes"></param>
  /// <param name="destination"></param>
  /// <param name="credential"></param>
  /// <returns></returns>
  private string SendRequestTo(byte[] requestBytes, Uri destination, NetworkCredential credential)
  {
   Trace.WriteLine("Sending request to url:" + destination.AbsoluteUri);

   // Build the request.
   HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(destination);
   webRequest.Method = "PROPFIND";
   webRequest.Accept = "*/*";
   webRequest.AllowAutoRedirect = false;
   webRequest.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET CLR v1.1.4322)";
   webRequest.CookieContainer = new CookieContainer();
   webRequest.ContentLength = requestBytes.Length;
   webRequest.ContentType = "text/xml";
   // Set the credentials
   webRequest.Credentials = credential;
   // Add cookies for this request
   webRequest.CookieContainer.Add(ccContainer.GetCookies(destination));

   try
   {
    // Write the request
    Stream reqStream = webRequest.GetRequestStream();
    reqStream.Write(requestBytes,0,requestBytes.Length);
    reqStream.Close();
    // Get a response
    HttpWebResponse webResponse = (HttpWebResponse)webRequest.GetResponse();
    if (webRequest.HaveResponse)
    {
     // Handle returned cookies
     foreach(Cookie retCookie in webResponse.Cookies)
     {
      bool cookieFound = false;
      
      foreach(Cookie oldCookie in ccContainer.GetCookies(destination))
      {
       if (retCookie.Name.Equals(oldCookie.Name))
       {
        oldCookie.Value = retCookie.Value;
        cookieFound = true;
       }
      }
      if (!cookieFound)
       ccContainer.Add(retCookie);
      
     }     
     // Handle redirection headers
     if ((webResponse.StatusCode == HttpStatusCode.Found) ||
      (webResponse.StatusCode == HttpStatusCode.Redirect) ||
      (webResponse.StatusCode == HttpStatusCode.Moved) ||
      (webResponse.StatusCode == HttpStatusCode.MovedPermanently))
     {    
      WebHeaderCollection headers = webResponse.Headers;
      return SendRequestTo(requestBytes,new Uri(headers["location"]),credential); 
     }
     // Read response
     StreamReader stream = new StreamReader(webResponse.GetResponseStream());
     string responseString = stream.ReadToEnd();
     stream.Close();
   
     return responseString;
    }
    // No response
    throw new ApplicationException("No response received from host.");
   }
   catch(WebException e)
   {
    // Error occured
    Trace.WriteLine("Exception occured " + e.Message);
    throw new ApplicationException("Exception occured while sending request."+e.Message,e);
   }
   
  }
 }
}
using System;
using System.Diagnostics;
using System.Net;
using System.Xml;

namespace Hotmail
{
 public class HotmailClient
 {
  #region Class Instances and Properties
  /// <summary>
  /// The Http proxy used for Hotmail
  /// </summary>
  private HotmailProxy hHttp   = null;
  /// <summary>
  /// Indicator if connected to remote host.
  /// </summary>
  private bool connected    = false;
  #endregion

  #region Public Interface( Constructor, Connect, Disconnect, RetrieveFilledMailBox)
  /// <summary>
  /// Create a new instance of HotmailClient.
  /// </summary>
  public HotmailClient()
  {
  }

  /// <summary>
  /// Connect this client to the remote hotmail host and
  /// retrieve a list of mailboxes.
  /// </summary>
  /// <param name="username">The username to connect with.</param>
  /// <param name="password">The password to connect with.</param>
  public void Connect(string username, string password)
  {
   // Verify input
   if (username == null || username.Trim().Length == 0)
    throw new ArgumentNullException("username");
   if (password == null || password.Trim().Length == 0)
    throw new ArgumentNullException("password");
   if (username.IndexOf("@") == -1)
    throw new ArgumentException("Illegal username, must contain an @ sign: (user@hotmail.com).");
   // Create the specialized Http client and the neccesary credentials
   hHttp = new HotmailProxy();
   NetworkCredential credentials = new NetworkCredential(username,password,null);
   // Build the query for the msgfolderroot
   string query = "<?xml version='1.0'?>" +
    "<D:propfind xmlns:D='DAV:' " +
    "xmlns:h='http://schemas.microsoft.com/hotmail/' " +
    "xmlns:hm='urn:schemas:httpmail:'>" +
    "<D:prop>"     +
    "<hm:msgfolderroot/>" +
    "</D:prop>"     +
    "</D:propfind>";
   // Connect
   try
   {
    // Get a response from the query, connect to the hotmail entry page.
    string hotmailEntryPoint = "http://services.msn.com/svcs/hotmail/httpmail.asp";
    string response = hHttp.SendRequest(query, new Uri(hotmailEntryPoint),credentials);
    // Verify response
    if (response == null || response.Trim().Length == 0)
     throw new ApplicationException("No response received from host.");
    // Parse the response, further verifying it.
    Uri folderRootUri = ParseConnectResponse(response);
    // Obtain available folders using folderRootUrl
    RetrieveMailboxes(folderRootUri);
    // Now we're connected
    connected = true;
   }
   catch(Exception e)
   {
    // Something went wrong.
    throw new ApplicationException("Exception occured while connecting to remote host.",e);
   }
  }
  #endregion

  #region Private Interface( ParseConnectResponse, ParseFillResponse, RetrieveMailboxes, CreateNamespaceManager)

  /// <summary>
  /// This method parses the response from the server from
  /// the Connect() call, and returns the Uri contained in
  /// the msgfolderroot. This is the root for all mailboxes.
  /// </summary>
  /// <param name="response">The response from the remote host.</param>
  /// <returns>The Uri contained in msgfolderroot.</returns>
  private Uri ParseConnectResponse(string response)
  {
   try
   {
    // Load response into XmlDocument
    XmlDocument dom = new XmlDocument();
    dom.LoadXml(response);
    // Query XmlDocument for msgfolderroot node.
    string xpath = "//hm:msgfolderroot";
    XmlNamespaceManager context = CreateNamespaceManager(dom.NameTable);
    XmlNode folderRoot = dom.SelectSingleNode(xpath,context);
    // Verify node
    if (folderRoot == null)
     throw new ApplicationException("Node '" + xpath + "' not found.");
    // Get node text and verify,
    string folderRootUrl = folderRoot.InnerText;
    if ((folderRootUrl == null) || (folderRootUrl.Trim().Length == 0))
     throw new ApplicationException("No url found in node '" + xpath + "'.");
    try
    {
     // Return the uri, this may result in a UriFormatException
     return new Uri(folderRootUrl);
    }
    catch
    {
     throw new ApplicationException("Url found in node '" + xpath + "' is invalid:" + folderRootUrl);
    }
   }
   catch(Exception e)
   {
    // Something went wrong.
    throw new ApplicationException("Error occured while parsing connect response.",e);
   }
  }
  
  /// <summary>
  /// Requests available mailboxes from the remote host using the
  /// given msgfolderroot url, and parses the response into
  /// the mailBoxes container.
  /// </summary>
  /// <param name="folderRootUrl">The Uri of the msgfolderroot.</param>
  private void RetrieveMailboxes(Uri folderRootUrl)
  {
   try
   {
    // Build the needed query
    string query = "<?xml version='1.0'?>" +
     "<D:propfind xmlns:D='DAV:' xmlns:hm='urn:schemas:httpmail:'>" +
     "<D:prop>"    +
     "<D:displayname/>" +
     "<hm:special/>"  +
     "<hm:unreadcount/>" +
     "<D:visiblecount/>" +
     "</D:prop>"    +
     "</D:propfind>";
    // Get a response from server
    string response = hHttp.SendRequest(query,folderRootUrl);
    // Verify response
    if (response == null || response.Trim().Length == 0)
     throw new ApplicationException("No response received from host."); 
    // Load response into XmlDocument
    XmlDocument dom = new XmlDocument();
    dom.LoadXml(response);
    // Query XmlDocument for all mailboxes using XPath
    string xpath = "//D:response";
    XmlNamespaceManager context = CreateNamespaceManager(dom.NameTable);
    XmlNodeList mailBoxNodes = dom.SelectNodes(xpath,context);
    // Parse each node found
    foreach(XmlNode mailBoxNode in mailBoxNodes)
    {  
     try
     {
      // Direct mapping using XPath, should not result in any errors
      // as long as Hotmail keeps it protocol the same.
      string type = mailBoxNode.SelectSingleNode("descendant::hm:special",context).InnerText;     
      string nameUrl = mailBoxNode.SelectSingleNode("descendant::D:href",context).InnerText;
      int visibleCount = Int32.Parse(mailBoxNode.SelectSingleNode("descendant::D:visiblecount",context).InnerText);
      int unreadCount = Int32.Parse(mailBoxNode.SelectSingleNode("descendant::hm:unreadcount",context).InnerText);
      // Add the mailbox
      Console.WriteLine("MailBox found: " + type + "/r/n" +
       "/turl: " + nameUrl + "/r/n" +
       "/tVisible: " + visibleCount + "/r/n" +
       "/tUnread: " + unreadCount + "/r/n");

     }
     catch(Exception e)
     {
      Console.WriteLine("Exception occured while obtaining mailbox info: " + e.Message);
     }
    }
   }
   catch(Exception e)
   {
    // Something went wrong.
    throw new ApplicationException("Error occured while retrieving available mailboxes.",e);
   }
  }
  
  /// <summary>
  /// Helper method to create the XmlNamespaceManager needed for
  /// correctly querying the response using XPath.
  /// </summary>
  /// <param name="table"></param>
  /// <returns></returns>
  private XmlNamespaceManager CreateNamespaceManager(XmlNameTable table)
  {
   XmlNamespaceManager m = new XmlNamespaceManager(table);
   m.AddNamespace("hm","urn:schemas:httpmail:");
   m.AddNamespace("D","DAV:");
   m.AddNamespace("m","urn:schemas:mailheader:");
   m.AddNamespace("c","urn:schemas:contacts:");
   m.AddNamespace("h","http://schemas.microsoft.com/hotmail/");
   return m;
  }
  #endregion

 }
}

程序进入点

private void button1_Click(object sender, System.EventArgs e)
  {
   HotmailClient client=new HotmailClient();
   client.Connect("xxxx@hotmail.com","urPassword");
  }