C# 访问Http

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Net;

namespace Utility
{
    /// <summary>  
    /// 通过Http协议访问Web  
    /// </summary>  
    public class HttpClient
    {
        #region Cookie集合
        /// <summary>  
        /// Cookie集合  
        /// </summary>  
        private CookieContainer cookies;
        #endregion

        #region Http user-agent标头值
        /// <summary>  
        /// Http user-agent标头值  
        /// </summary>  
        public string UserAgent { get; set; }
        #endregion

        #region HttpClient构造函数
        public HttpClient()
        {
            this.cookies = new CookieContainer();
        }
        #endregion

        #region 获取HttpClient的Cookie集合
        /// <summary>  
        /// 获取HttpClient的Cookie集合  
        /// </summary>  
        /// <returns></returns>  
        public CookieContainer GetCookieContainer()
        {
            return this.cookies;
        }
        #endregion

        #region 设置HttpClient的Cookie集合
        /// <summary>  
        /// 设置HttpClient的Cookie集合  
        /// </summary>  
        /// <param name="_cookie">Cookie集合对象</param>  
        /// <returns>True设置成功 False设置失败</returns>  
        public bool SetCookieContainer(CookieContainer _cookie)
        {
            if (_cookie != null)
            {
                this.cookies = _cookie;
                return true;
            }
            return false;
        }
        #endregion

        #region 以GET方式打开一个Http连接
        /// <summary>  
        /// 以GET方式打开一个Http连接  
        /// </summary>  
        /// <param name="url">地址</param>  
        /// <param name="headers">请求头</param>  
        /// <returns></returns>  
        public ResultResponse OpenGetUrl(string url, Dictionary<string, string> headers)
        {
            HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
            request.CookieContainer = this.cookies;
            request.Method = HttpClient.ConnectionType.GET;
            request.KeepAlive = true;
            if (this.UserAgent != null && this.UserAgent != "")
            {
                request.UserAgent = this.UserAgent;
            }
            this.FillHeaders(request, headers);
            HttpWebResponse response = request.GetResponse() as HttpWebResponse;
            return new ResultResponse(response);
        }
        #endregion

        #region 以GET方式打开一个Http连接,302自定义处理行为
        /// <summary>  
        /// 以GET方式打开一个Http连接,302自定义处理行为  
        /// </summary>  
        /// <param name="url">地址</param>  
        /// <param name="headers">请求头</param>  
        /// <param name="action">302跳转处理</param>  
        /// <returns></returns>  
        public ResultResponse OpenGetUrlRedirect(string url, Dictionary<string, string> headers, HttpClient.RedirectAction action)
        {
            HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
            request.CookieContainer = this.cookies;
            request.Method = HttpClient.ConnectionType.GET;
            request.KeepAlive = true;
            request.AllowAutoRedirect = false; //302不采用默认行为处理  
            if (this.UserAgent != null && this.UserAgent != "")
            {
                request.UserAgent = this.UserAgent;
            }
            this.FillHeaders(request, headers);
            HttpWebResponse response = request.GetResponse() as HttpWebResponse;
            ResultResponse result = new ResultResponse(response);
            if (response.StatusCode == HttpStatusCode.Found)
            {
                bool ret = true;
                if (action != null)
                {
                    ret = action(result);
                }
                string locationurl = response.Headers["Location"];
                if (ret == true)
                {
                    return this.OpenGetUrlRedirect(locationurl, null, action);
                }
                return result;
            }
            return result;
        }
        #endregion

        #region Http 302跳转处理
        /// <summary>  
        /// Http 302跳转处理  
        /// </summary>  
        /// <param name="result">响应对象</param>  
        /// <returns>False 不继续跳转 True继续跳转</returns>  
        public delegate bool RedirectAction(ResultResponse result);
        #endregion

        #region 将Http标头值添加到Request对象中
        /// <summary>  
        /// 将Http标头值添加到Request对象中  
        /// </summary>  
        /// <param name="headers"></param>  
        private void FillHeaders(HttpWebRequest request, Dictionary<string, string> headers)
        {
            if (headers != null && headers.Count > 0)
            {
                Dictionary<string, string>.Enumerator em = headers.GetEnumerator();
                while (em.MoveNext())
                {
                    request.Headers.Add(em.Current.Key, em.Current.Value);
                }
            }
        }
        #endregion

        #region 以POST方式打开一个Http连接
        /// <summary>  
        /// 以POST方式打开一个Http连接  
        /// </summary>  
        /// <param name="url">地址</param>  
        /// <param name="headers">请求头</param>  
        /// <param name="data">发送的数据</param>  
        /// <returns></returns>  
        public ResultResponse OpenPostUrl(string url, Dictionary<string, string> headers, Dictionary<string, string> data)
        {
            HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
            request.CookieContainer = this.cookies;
            request.Method = HttpClient.ConnectionType.POST;
            request.KeepAlive = true;
            if (this.UserAgent != null && this.UserAgent != "")
            {
                request.UserAgent = this.UserAgent;
            }
            this.FillHeaders(request, headers);
            byte[] buff = DictToBytes(data);
            request.GetRequestStream().Write(buff, 0, buff.Length);
            request.GetRequestStream().Close();
            HttpWebResponse response = request.GetResponse() as HttpWebResponse;
            return new ResultResponse(response);
        }
        #endregion

        #region 以POST方式打开一个Http连接,302自定义处理行为
        /// <summary>  
        /// 以POST方式打开一个Http连接,302自定义处理行为  
        /// </summary>  
        /// <param name="url">地址</param>  
        /// <param name="headers">请求头</param>  
        /// <param name="data">发送的数据</param>  
        /// <param name="action">302自定义处理</param>  
        /// <returns></returns>  
        public ResultResponse OpenPostUrlRedirect(string url, Dictionary<string, string> headers, Dictionary<string, string> data, HttpClient.RedirectAction action)
        {
            HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
            request.CookieContainer = this.cookies;
            request.Method = HttpClient.ConnectionType.POST;
            request.KeepAlive = true;
            request.AllowAutoRedirect = false;
            if (this.UserAgent != null && this.UserAgent != "")
            {
                request.UserAgent = this.UserAgent;
            }
            this.FillHeaders(request, headers);
            byte[] buff = DictToBytes(data);
            request.GetRequestStream().Write(buff, 0, buff.Length);
            request.GetRequestStream().Close();
            HttpWebResponse response = request.GetResponse() as HttpWebResponse;
            ResultResponse result = new ResultResponse(response);

            if (response.StatusCode == HttpStatusCode.Found)
            {
                bool ret = true;
                if (action != null)
                {
                    ret = action(result);
                }
                string locationurl = response.Headers["Location"];
                return result;
            }
            return result;
        }
        #endregion

        #region 将字典的key和value拼接成http参数
        /// <summary>  
        /// 将字典的key和value拼接成http参数  
        /// </summary>  
        /// <param name="dic">参数</param>  
        /// <returns></returns>  
        private byte[] DictToBytes(Dictionary<string, string> dic)
        {
            StringBuilder sb = null;
            if (dic != null)
            {
                Dictionary<string, string>.Enumerator em = dic.GetEnumerator();
                sb = new StringBuilder();
                while (em.MoveNext())
                {
                    sb.Append(String.Format("{0}={1}&", em.Current.Key, em.Current.Value));
                }
                return System.Text.Encoding.UTF8.GetBytes(sb.ToString());
            }
            return null;
        }
        #endregion

        #region HttpClient打开连接的方式
        /// <summary>  
        /// HttpClient打开连接的方式  
        /// </summary>  
        public static class ConnectionType
        {
            public static string GET { get { return "GET"; } }
            public static string POST { get { return "POST"; } }
        }
        #endregion  
    }
}

 

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Net;

namespace Utility
{
    /// <summary>  
    ///包含服务器响应数据的对象  
    /// </summary>  
    public class ResultResponse
    {
        #region HttpWebResponse对象
        /// <summary>  
        /// HttpWebResponse对象  
        /// </summary>  
        private HttpWebResponse m_response;
        #endregion

        #region 创建一个HttpWebResponse对象
        /// <summary>  
        /// 创建一个HttpWebResponse对象  
        /// </summary>  
        /// <param name="_response">HttpWebResponse</param>  
        public ResultResponse(HttpWebResponse _response)
        {
            this.m_response = _response;
        }
        #endregion

        #region 获取响应内容的二进制流
        /// <summary>  
        /// 获取响应内容的二进制流   
        /// </summary>  
        /// <returns></returns>  
        public Stream GetResponseStream()
        {
            if (this.m_response != null)
            {
                return this.m_response.GetResponseStream();
            }
            return null;
        }
        #endregion

        #region Http版本
        /// <summary>  
        /// Http版本  
        /// </summary>  
        public string ProtocolVersion { get { return this.m_response != null ? this.m_response.ProtocolVersion.ToString() : ""; } }
        #endregion
        /// <summary>  
        /// 响应方法  
        /// </summary>  
        public string Method { get { return this.m_response != null ? this.m_response.Method : ""; } }
        /// <summary>  
        /// Http状态码  
        /// </summary>  
        public string StatusCode { get { return this.m_response != null ? this.m_response.StatusCode.ToString() : ""; } }
        /// <summary>  
        /// Http响应头  
        /// </summary>  
        public WebHeaderCollection Headers { get { return this.m_response != null ? this.m_response.Headers : null; } }

        /// <summary>  
        /// 响应流的字符编码  
        /// </summary>  
        /// <returns></returns>  
        public Encoding getResponseEncoding()
        {
            if (this.m_response != null)
            {
                return Encoding.GetEncoding(this.m_response.ContentEncoding);
            }
            return null;
        }

        /// <summary>  
        /// 获取响应内容的字符串  
        /// </summary>  
        /// <param name="encoding">字符串编码(默认utf8)</param>  
        /// <returns></returns>  
        public string GetContent(string encoding = "utf-8")
        {
            return System.Text.Encoding.GetEncoding(encoding).GetString(this.StreamtoBytes(this.GetResponseStream()));
        }

        /// <summary>  
        /// 获取原始的HttpWebResponse  
        /// </summary>  
        /// <returns></returns>  
        public HttpWebResponse GetRawResponse()
        {
            return this.m_response;
        }

        /// <summary>  
        /// 二进制流转换成字节数组  
        /// </summary>  
        /// <param name="_stream"></param>  
        /// <returns></returns>  
        private byte[] StreamtoBytes(Stream _stream)
        {
            byte[] buff;
            int rlen;
            MemoryStream _ms;
            if (_stream != null)
            {
                buff = new byte[1024];
                rlen = 0;
                _ms = new MemoryStream();
                while ((rlen = _stream.Read(buff, 0, 1024)) > 0)
                {
                    _ms.Write(buff, 0, rlen);
                }
                buff = _ms.ToArray();
                _ms.Close();
                _ms.Dispose();
                return buff;
            }
            return null;
        }
    }  
}