C# 利用HttpWebRequest、HttpWebResponse封装http请求

class HttpHelper
{
    #region 预定义变量
    //默认的编码
    private Encoding encoding = Encoding.Default;
    /// <summary>
    /// HttpWebRequest对象用来发起请求
    /// </summary>
    public HttpWebRequest request = null;
    /// <summary>
    /// 获取影响流的数据对象
    /// </summary>
    private HttpWebResponse response = null;
    /// <summary>
    /// 设置本地的出口ip和端口
    /// </summary>
    private IPEndPoint _IPEndPoint = null;
    /// <summary>
    /// 分隔符
    /// multipart/form-data是必须的.---------------------------7d33a816d302b6 是分隔符
    /// 分隔多个文件、表单项
    /// 其中7d33a816d302b6 是即时生成的字符串，用以确保整个分隔符不会在文件或表单项的内容中出现。
    /// </summary>
    private string cMultiPartBoundary = "---------------------------7d33a816d302b6";
    #endregion

    /// <summary>
    /// 发送请求
    /// </summary>
    /// <param name="item"></param>
    /// <returns></returns>
    public HttpResult SendRequest(RequestItem item)
    {
        //返回对象
        HttpResult res = new HttpResult();
        #region 设置参数
        try
        {
            SetCertificateAndInitRequestObject(item);
            if (item.IPEndPoint != null)
            {
                _IPEndPoint = item.IPEndPoint;
                request.ServicePoint.BindIPEndPointDelegate = new BindIPEndPoint(BindIPEndPointCallback);
            }
            if (item.Headers != null && item.Headers.Count > 0)
            {
                foreach (string key in item.Headers.AllKeys)
                {
                    request.Headers.Add(key, item.Headers[key]);
                }
            }
            // 设置代理
            SetProxy(item);
            //协议版本
            if (item.ProtocolVersion != null) request.ProtocolVersion = item.ProtocolVersion;
            //100-Continue 行为
            request.ServicePoint.Expect100Continue = item.Expect100Continue;
            //设置最大连接
            if (item.Connectionlimit > 0) request.ServicePoint.ConnectionLimit = item.Connectionlimit;
            //方法
            request.Method = item.Method;
            request.Timeout = item.Timeout;
            request.KeepAlive = item.KeepAlive;
            request.ReadWriteTimeout = item.ReadWriteTimeout;
            if (!string.IsNullOrWhiteSpace(item.Host))
            {
                request.Host = item.Host;
            }
            if (item.IfModifiedSince != null)
            {
                request.IfModifiedSince = Convert.ToDateTime(item.IfModifiedSince);
            }
            request.Accept = item.Accept;
            if (item.PostDataType == PostDataType.Form)
            {
                request.ContentType = "multipart/form-data; boundary=" + this.cMultiPartBoundary;
            }
            else
            {
                request.ContentType = item.ContentType;
            }
            //UserAgent客户端的访问类型，包括浏览器版本和操作系统信息
            request.UserAgent = item.UserAgent;
            //编码
            encoding = item.Encoding;
            //设置安全凭证
            request.Credentials = item.Credentials;
            //设置Cookie
            if (!string.IsNullOrEmpty(item.Cookie)) { request.Headers[HttpRequestHeader.Cookie] = item.Cookie; };
            if (item.ResultCookieType == ResultCookieType.CookieCollection)
            {
                item.CookieContainer = item.CookieContainer;
            }
            //来源地址
            request.Referer = item.Referer;
            //是否执行跳转功能
            request.AllowAutoRedirect = item.AllowAutoRedirect;
            if (item.MaximumAutomaticRedirections > 0)
            {
                request.MaximumAutomaticRedirections = item.MaximumAutomaticRedirections;
            }
            //设置Post数据
            if (request.Method.ToLower() == "post")
            {
                SetPostData(item);
            }
        }
        catch (Exception ex)
        {
            //配置参数时出错
            res.Cookie = string.Empty;
            res.Header = null;
            res.Html = ex.Message;
            res.StatusDescription = "配置参数时出错：" + ex.Message;
            return res;
        }
        #endregion

        #region 发请求并处理响应
        try
        {
            using (response = (HttpWebResponse)request.GetResponse())
            {
                GetData(item, ref res);
            }

        }
        catch (WebException wex)
        {
            if (wex.Response != null)
            {
                using (response = (HttpWebResponse)wex.Response)
                {
                    GetData(item, ref res);
                }
            }
            else
            {
                res.Html = wex.Message;
            }
        }
        catch (Exception ex)
        {
            res.Html = ex.Message;
        }
        if (item.IsToLower) res.Html = res.Html.ToLower();
        #endregion

        return res;
    }

    /// <summary>
    /// 处理响应内容
    /// </summary>
    /// <param name="item"></param>
    /// <param name="res"></param>
    private void GetData(RequestItem item, ref HttpResult res)
    {
        if (response == null)
        {
            return;
        }
        #region base
        //返回状态码
        res.StatusCode = response.StatusCode;
        //返回状态码对应的描述
        res.StatusDescription = response.StatusDescription;
        //响应头
        res.Header = response.Headers;
        //获取最后访问你的uri
        res.ResponseUri = response.ResponseUri.ToString();
        //获取CookieCollection
        if (response.Cookies != null)
        {
            res.CookieCollection = response.Cookies;
        }
        //获取set-cookie
        if (response.Headers["set-cookie"] != null)
        {
            res.Cookie = response.Headers["set-cookie"];
        }
        #endregion

        #region byte
        //处理网页Byte
        byte[] ResponseByte = GetByte();
        #endregion

        #region Html
        if (ResponseByte != null && ResponseByte.Length > 0)
        {
            //设置编码
            SetEncoding(item, res, ResponseByte);
            //得到返回的HTML
            res.Html = encoding.GetString(ResponseByte);
        }
        else
        {
            res.Html = string.Empty;
        }
        #endregion
    }

    /// <summary>
    /// 设置Post数据
    /// </summary>
    /// <param name="item"></param>
    private void SetPostData(RequestItem item)
    {
        Encoding postencoding = item.PostEncoding;
        MemoryStream oPostStream;
        BinaryWriter oPostData;
        oPostStream = new MemoryStream();
        oPostData = new BinaryWriter(oPostStream);
        //写入Byte类型
        if (item.PostDataType == PostDataType.Byte && item.PostdataByte != null && item.PostdataByte.Length > 0)
        {
            //验证在得到结果时是否有传入数据
            oPostData.Write(item.PostdataByte);

        }//写入表单
        else if (item.PostDataType == PostDataType.Form && item.PostFormData != null && item.PostFormData.Count > 0)
        {
            foreach (FormItem f in item.PostFormData)
            {
                if (f.IsFile)
                {
                    if (File.Exists(f.Value))
                    {
                        FileStream fs = new FileStream(f.Value, FileMode.Open, FileAccess.Read);
                        byte[] fbyte = new byte[fs.Length];
                        fs.Read(fbyte, 0, (int)fs.Length);
                        fs.Close();
                        oPostData.Write(postencoding.GetBytes("--" + this.cMultiPartBoundary + "\r\n" + "Content-Disposition: form-data; name=\"media\"; filename=\"" + new FileInfo(f.Value).Name + "\"\r\nContent-Type: application/octet-stream\r\n\r\n"));
                        oPostData.Write(fbyte);
                        oPostData.Write(postencoding.GetBytes("\r\n"));
                    }
                }
                else
                {
                    oPostData.Write(postencoding.GetBytes("--" + this.cMultiPartBoundary + "\r\n" + "Content-Disposition: form-data; name=\"" + f.Key + "\"\r\n\r\n"));
                    oPostData.Write(postencoding.GetBytes(f.Value));
                    oPostData.Write(postencoding.GetBytes("\r\n"));
                }
                oPostData.Write(postencoding.GetBytes("--" + this.cMultiPartBoundary + "--\r\n"));
            }
        }//写入文件
        else if (item.PostDataType == PostDataType.FilePath && !string.IsNullOrWhiteSpace(item.Postdata))
        {
            StreamReader sr = new StreamReader(item.Postdata, postencoding);
            oPostData.Write(postencoding.GetBytes(sr.ReadToEnd()));
        }
        else
        {
            oPostData.Write(postencoding.GetBytes(item.Postdata));
        }
        if (oPostStream.Length > 0)
        {
            request.ContentLength = oPostStream.Length;
            Stream stream = request.GetRequestStream();
            oPostStream.WriteTo(stream);
            oPostStream.Close();
            oPostStream = null;
            oPostData.Close();
            oPostData = null;
            stream.Close();
        }
        else
        {
            request.ContentLength = 0;
        }

    }

    /// <summary>
    /// 提取网页Byte
    /// </summary>
    /// <returns></returns>
    private byte[] GetByte()
    {
        byte[] ResponseByte = null;
        using (MemoryStream _stream = new MemoryStream())
        {
            //GZIIP处理
            if (response.ContentEncoding != null && response.ContentEncoding.Equals("gzip", StringComparison.InvariantCultureIgnoreCase))
            {
                //开始读取流并设置编码方式
                new GZipStream(response.GetResponseStream(), CompressionMode.Decompress).CopyTo(_stream, 10240);
            }
            else
            {
                //开始读取流并设置编码方式
                response.GetResponseStream().CopyTo(_stream, 10240);
            }
            //获取Byte
            ResponseByte = _stream.ToArray();
        }
        return ResponseByte;
    }

    /// <summary>
    /// 设置编码
    /// </summary>
    /// <param name="item">HttpItem</param>
    /// <param name="result">HttpResult</param>
    /// <param name="ResponseByte">byte[]</param>
    private void SetEncoding(RequestItem item, HttpResult result, byte[] ResponseByte)
    {
        //是否返回Byte类型数据
        if (item.ResultType == ResultType.Byte) result.ResultByte = ResponseByte;
        //从这里开始我们要无视编码了
        if (encoding == null)
        {
            Match meta = Regex.Match(Encoding.Default.GetString(ResponseByte), "<meta[^<]*charset=([^<]*)[\"']", RegexOptions.IgnoreCase);
            string c = string.Empty;
            if (meta != null && meta.Groups.Count > 0)
            {
                c = meta.Groups[1].Value.ToLower().Trim();
            }
            if (c.Length > 2)
            {
                try
                {
                    encoding = Encoding.GetEncoding(c.Replace("\"", string.Empty).Replace("'", "").Replace(";", "").Replace("iso-8859-1", "gbk").Trim());
                }
                catch
                {
                    if (string.IsNullOrEmpty(response.CharacterSet))
                    {
                        encoding = Encoding.UTF8;
                    }
                    else
                    {
                        encoding = Encoding.GetEncoding(response.CharacterSet);
                    }
                }
            }
            else
            {
                if (string.IsNullOrEmpty(response.CharacterSet))
                {
                    encoding = Encoding.UTF8;
                }
                else
                {
                    encoding = Encoding.GetEncoding(response.CharacterSet);
                }
            }
        }
    }

    /// <summary>
    /// 设置代理
    /// </summary>
    /// <param name="item">参数对象</param>
    private void SetProxy(RequestItem item)
    {
        bool isIeProxy = false;
        if (!string.IsNullOrWhiteSpace(item.ProxyIp))
        {
            isIeProxy = item.ProxyIp.ToLower().Contains("ieproxy");
        }
        if (!string.IsNullOrWhiteSpace(item.ProxyIp) && !isIeProxy)
        {
            //设置代理服务器
            if (item.ProxyIp.Contains(":"))
            {
                string[] plist = item.ProxyIp.Split(':');
                WebProxy myProxy = new WebProxy(plist[0].Trim(), Convert.ToInt32(plist[1].Trim()));
                //建议连接
                myProxy.Credentials = new NetworkCredential(item.ProxyUserName, item.ProxyPwd);
                //给当前请求对象
                request.Proxy = myProxy;
            }
            else
            {
                WebProxy myProxy = new WebProxy(item.ProxyIp, false);
                //建议连接
                myProxy.Credentials = new NetworkCredential(item.ProxyUserName, item.ProxyPwd);
                //给当前请求对象
                request.Proxy = myProxy;
            }
        }
        else if (isIeProxy)
        {
            //设置为IE代理
        }
        else
        {
            request.Proxy = item.WebProxy;
        }
    }

    /// <summary>
    /// 请求model
    /// </summary>
    public class RequestItem
    {
        /// <summary>
        /// 请求链接地址
        /// </summary>
        public string URL { get; set; }
        private string _Method = "GET";
        /// <summary>
        /// 用于联系 Internet 资源的请求方法。 默认值为 GET。
        /// </summary>
        public string Method
        {
            get { return _Method; }
            set { _Method = value; }
        }

        #region 请求为post时要发送的数据
        /// <summary>
        /// Post请求时要发送的字符串Post数据--仅适用于字符串类型或文件（文件时用于存放文件路径）
        /// </summary>
        public string Postdata { get; set; }
        /// <summary>
        /// Post请求时要发送的Byte类型的Post数据
        /// </summary>
        public byte[] PostdataByte { get; set; }
        /// <summary>
        /// 提交表单数据
        /// </summary>
        public List<FormItem> PostFormData { get; set; }
        #endregion

        #region 响应重要内容是否设置为全文小写
        private Boolean isToLower = false;
        /// <summary>
        /// 是否设置为全文小写，默认为不转化
        /// </summary>
        public Boolean IsToLower
        {
            get { return isToLower; }
            set { isToLower = value; }
        }
        #endregion

        #region ResultType  返回类型
        private ResultType _resulttype = ResultType.String;
        /// <summary>
        /// 设置返回类型String和Byte
        /// </summary>
        public ResultType ResultType
        {
            get { return _resulttype; }
            set { _resulttype = value; }
        }
        #endregion

        #region Accept  HTTP 标头的值
        /// <summary>
        /// 标头默认值
        /// </summary>
        string _Accept = "text/html, application/xhtml+xml, */*";
        /// <summary>
        /// Accept HTTP 标头的值。 默认值是 null。
        /// </summary>
        public string Accept
        {
            get { return _Accept; }
            set { _Accept = value; }
        }
        #endregion

        #region AllowAutoRedirect  是否支持重定向
        /// <summary>
        /// 默认是不跳转
        /// </summary>
        private Boolean _AllowAutoRedirect = false;
        /// <summary>
        /// 获取或设置一个值，该值指示请求是否应跟随重定向响应。(支持跳转页面，查询结果将是跳转后的页面，默认是不跳转)
        /// </summary>
        public Boolean AllowAutoRedirect
        {
            get { return _AllowAutoRedirect; }
            set { _AllowAutoRedirect = value; }
        }
        #endregion

        #region X509CertificateCollection 获取或设置与此请求关联的安全证书集合。
        /// <summary>
        /// 设置509证书集合
        /// </summary>
        public X509CertificateCollection ClentCertificates { get; set; }
        #endregion

        #region ContentType  请求数据内容编码类型
        string _ContentType = "text/html";
        /// <summary>
        /// Content-type HTTP 标头的值。
        /// </summary>
        public string ContentType
        {
            get { return _ContentType; }
            set { _ContentType = value; }
        }
        #endregion

        #region Encoding 编码方式
        /// <summary>
        /// 返回数据编码默认为NUll,可以自动识别,一般为utf-8,gbk,gb2312
        /// </summary>
        public Encoding Encoding { get; set; }
        #endregion

        #region CookieContainer 获取或设置与请求关联的 Cookie。
        /// <summary>
        /// 请求时的Cookie(字符串--单个cookie)
        /// </summary>
        public string Cookie { get; set; }
        /// <summary>
        /// 请求时的Cookie(容器--多个cookie)
        /// </summary>
        public CookieContainer CookieContainer { get; set; }
        #endregion

        #region Credentials  包含与该请求关联的身份验证凭据的 ICredentials
        private ICredentials _Credentials = CredentialCache.DefaultCredentials;
        /// <summary>
        /// 获取或设置请求的身份验证信息。默认为 null。
        /// </summary>
        public ICredentials Credentials
        {
            get { return _Credentials; }
            set { _Credentials = value; }
        }
        #endregion

        #region Header 请求头
        public WebHeaderCollection Headers { get; set; }
        #endregion

        #region _IfModifiedSince  包含HTTP If-Modified-Since 标头内容的 DateTime。
        private DateTime? _IfModifiedSince = null;
        /// <summary>
        /// 获取和设置IfModifiedSince，默认为当前日期和时间
        /// </summary>
        public DateTime? IfModifiedSince
        {
            get { return _IfModifiedSince; }
            set { _IfModifiedSince = value; }
        }
        #endregion

        #region KeepAlive  获取或设置一个值，该值指示是否与 Internet 资源建立持续型连接。
        private Boolean _KeepAlive = true;
        /// <summary>
        /// 如果对 Internet 资源的请求所包含的 HTTP Connection 标头带有 Keep-alive 这一值，则为 true；否则为 false。 默认为 true。
        /// </summary>
        public Boolean KeepAlive
        {
            get { return _KeepAlive; }
            set { _KeepAlive = value; }
        }
        #endregion

        #region MaximumAutomaticRedirections  获取或设置请求将跟随的重定向的最大数目。
        /// <summary>
        /// 请求将跟随的重定向响应的最大数目。 默认值为“50”。
        /// </summary>
        public int MaximumAutomaticRedirections { get; set; }
        #endregion

        #region ProtocolVersion和Expect100Continue  用于请求的 HTTP 版本
        /// <summary>
        /// 用于请求的 HTTP 版本。 默认为 Version11。
        /// </summary>
        public Version ProtocolVersion { get; set; }
        private Boolean _expect100continue = true;
        /// <summary>
        ///  获取或设置一个 System.Boolean 值，该值确定是否使用 100-Continue 行为。如果 POST 请求需要 100-Continue 响应，则为 true；否则为 false。默认值为 true。
        /// </summary>
        public Boolean Expect100Continue
        {
            get { return _expect100continue; }
            set { _expect100continue = value; }
        }
        private int _connectionlimit = 1024;
        /// <summary>
        /// 获取或设置此 ServicePoint 对象上允许的最大连接数。
        /// </summary>
        public int Connectionlimit
        {
            get { return _connectionlimit; }
            set { _connectionlimit = value; }
        }
        #endregion

        #region HTTP 请求中的 Host 标头值。
        /// <summary>
        /// 设置Host的标头信息
        /// Host 属性可用于设置要在 HTTP 请求中独立于请求 URI 使用的主机标头值。 Host 属性可以包括主机名和可选端口号。 
        /// 不带端口信息的主机标头表示请求的服务的默认端口（例如，HTTP URL 的端口80）
        /// 如果未设置 Host 属性，则在 HTTP 请求中使用的主机标头值基于请求 URI。
        /// </summary>
        public string Host { get; set; }
        #endregion

        #region PostDataType
        private PostDataType _PostDataType = PostDataType.String;
        /// <summary>
        /// Post的数据类型
        /// </summary>
        public PostDataType PostDataType
        {
            get { return _PostDataType; }
            set { _PostDataType = value; }
        }
        #endregion

        #region  PostEncoding   Post参数编码
        /// <summary>
        /// 设置或获取Post参数编码,默认的为Default编码
        /// </summary>
        public Encoding PostEncoding { get; set; }
        #endregion

        #region ReadWriteTimeout  获取或设置写入或读取流时的超时
        int _ReadWriteTimeout = 30000;
        /// <summary>
        /// 获取或设置写入或读取流时的超时（以毫秒为单位）。
        /// </summary>
        public int ReadWriteTimeout
        {
            get { return _ReadWriteTimeout; }
            set { _ReadWriteTimeout = value; }
        }
        #endregion

        #region Referer
        /// <summary>
        /// 获取或设置 Referer HTTP 标头的值。
        /// </summary>
        public string Referer { get; set; }
        #endregion

        #region Timeout  获取或设置 GetResponse() 和 GetRequestStream() 方法的超时值（以毫秒为单位）。
        private int _Timeout = 100000;
        /// <summary>
        /// 请求超时前等待的毫秒数。默认值为100000毫秒（100秒）。
        /// </summary>
        public int Timeout
        {
            get { return _Timeout; }
            set { _Timeout = value; }
        }
        #endregion

        #region UserAgent  获取或设置 User-agent HTTP 标头的值
        string _UserAgent = "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)";
        /// <summary>
        /// 客户端访问信息默认Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)
        /// </summary>
        public string UserAgent
        {
            get { return _UserAgent; }
            set { _UserAgent = value; }
        }
        #endregion

        #region ip-port
        private IPEndPoint _IPEndPoint = null;
        /// <summary>
        /// 设置本地的出口ip和端口
        /// </summary>]
        /// <example>
        ///item.IPEndPoint = new IPEndPoint(IPAddress.Parse("192.168.1.1"),80);
        /// </example>
        public IPEndPoint IPEndPoint
        {
            get { return _IPEndPoint; }
            set { _IPEndPoint = value; }
        }
        #endregion

        #region 代理Proxy
        /// <summary>
        /// 代理Proxy 服务器用户名
        /// </summary>
        public string ProxyUserName { get; set; }
        /// <summary>
        /// 代理 服务器密码
        /// </summary>
        public string ProxyPwd { get; set; }
        /// <summary>
        /// 代理 服务IP,如果要使用IE代理就设置为ieproxy
        /// </summary>
        public string ProxyIp { get; set; }
        /// <summary>
        /// 设置代理对象，不想使用IE默认配置就设置为Null，而且不要设置ProxyIp
        /// </summary>
        public WebProxy WebProxy { get; set; }
        /// <summary>
        /// 证书绝对路径
        /// </summary>
        public string CerPath { get; set; }
        #endregion

        #region ResultCookieType  cookie类型
        private ResultCookieType _ResultCookieType = ResultCookieType.String;
        /// <summary>
        /// Cookie返回类型,默认的是只返回字符串类型
        /// </summary>
        public ResultCookieType ResultCookieType
        {
            get { return _ResultCookieType; }
            set { _ResultCookieType = value; }
        }
        #endregion

        #region 不常用的参数区
        /// <summary>
        /// 获取或设置一个值，该值指示是否对发送到 Internet 资源的数据进行缓冲处理。
        /// </summary>
        public bool AllowWriteStreamBuffering { get; set; }
        /// <summary>
        /// 获取或设置所使用的解压缩类型。
        /// </summary>
        public DecompressionMethods AutomaticDecompression { get; set; }
        /// <summary>
        /// Connection HTTP 标头的值。 默认值是 null。
        /// </summary>
        public string Connection { get; set; }
        /// <summary>
        /// 获取或设置请求的连接组的名称。
        /// </summary>
        public string ConnectionGroupName { get; set; }
        /// <summary>
        /// 要发送到 Internet 资源的数据的字节数。 默认值为 -1，该值指示尚未设置该属性，并且没有要发送的请求数据。
        /// </summary>
        public long ContentLength { get; set; }
        /// <summary>
        /// 在接收到 100-Continue 之前要等待的超时（以毫秒为单位）。
        /// </summary>
        public int ContinueTimeout { get; set; }
        /// <summary>
        /// HTTP 请求中的 Date 标头值。
        /// </summary>
        public DateTime Date { get; set; }
        #endregion
    }

    /// <summary>
    /// Http返回参数类
    /// </summary>
    public class HttpResult
    {
        /// <summary>
        /// Http请求返回的Cookie
        /// </summary>
        public string Cookie { get; set; }
        /// <summary>
        /// Cookie对象集合
        /// </summary>
        public CookieCollection CookieCollection { get; set; }
        private string _html = string.Empty;
        /// <summary>
        /// 返回的String类型数据 只有ResultType.String时才返回数据，其它情况为空
        /// </summary>
        public string Html
        {
            get { return _html; }
            set { _html = value; }
        }
        /// <summary>
        /// 返回的Byte数组 只有ResultType.Byte时才返回数据，其它情况为空
        /// </summary>
        public byte[] ResultByte { get; set; }
        /// <summary>
        /// header对象
        /// </summary>
        public WebHeaderCollection Header { get; set; }
        /// <summary>
        /// 返回状态说明
        /// </summary>
        public string StatusDescription { get; set; }
        /// <summary>
        /// 返回状态码,默认为OK
        /// </summary>
        public HttpStatusCode StatusCode { get; set; }
        /// <summary>
        /// 最后访问的URl
        /// </summary>
        public string ResponseUri { get; set; }
        /// <summary>
        /// 获取重定向的URl
        /// </summary>
        public string RedirectUrl
        {
            get
            {
                try
                {
                    if (Header != null && Header.Count > 0)
                    {
                        if (Header.AllKeys.Any(k => k.ToLower().Contains("location")))
                        {
                            string locationurl = Header["location"].ToString().ToLower();

                            if (!string.IsNullOrWhiteSpace(locationurl))
                            {
                                bool b = locationurl.StartsWith("http://") || locationurl.StartsWith("https://");
                                if (!b)
                                {
                                    locationurl = new Uri(new Uri(ResponseUri), locationurl).AbsoluteUri;
                                }
                            }
                            return locationurl;
                        }
                    }
                }
                catch { }
                return string.Empty;
            }
        }
    }

    /// <summary>
    /// 表单请求参数类
    /// </summary>
    public class FormItem
    {
        /// <summary>  
        /// 表单键
        /// </summary>  
        public string Key { set; get; }
        /// <summary>  
        /// 表单值，但文件时，保存文件绝对路径
        /// </summary>  
        public string Value { set; get; }
        /// <summary>
        /// 是否文件
        /// </summary>
        public bool IsFile { get; set; }
    }

    #region 通用方法
    /// <summary>
    /// 设置证书和初始化请求对象
    /// </summary>
    /// <param name="item"></param>
    private void SetCertificateAndInitRequestObject(RequestItem item)
    {
        if (!string.IsNullOrWhiteSpace(item.CerPath))
        {
            //这一句一定要写在创建连接的前面。使用回调的方法进行证书验证。
            ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(RemoteCertificateValidationCallbackIm);
            //初始化对像，并设置请求的URL地址
            request = (HttpWebRequest)WebRequest.Create(item.URL);
            SetCerList(item);
            //将证书添加到请求里
            request.ClientCertificates.Add(new X509Certificate(item.CerPath));
        }
        else
        {
            //初始化对像，并设置请求的URL地址
            request = (HttpWebRequest)WebRequest.Create(item.URL);
            SetCerList(item);
        }
    }
    /// <summary>
    /// 设置多个证书
    /// </summary>
    /// <param name="item"></param>
    private void SetCerList(RequestItem item)
    {
        if (item.ClentCertificates != null && item.ClentCertificates.Count > 0)
        {
            foreach (X509Certificate c in item.ClentCertificates)
            {
                request.ClientCertificates.Add(c);
            }
        }
    }
    public bool RemoteCertificateValidationCallbackIm(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
    {
        return true;
    }
    /// <summary>
    /// 通过设置这个属性，可以在发出连接的时候绑定客户端发出连接所使用的IP地址。 
    /// </summary>
    /// <param name="servicePoint"></param>
    /// <param name="remoteEndPoint"></param>
    /// <param name="retryCount"></param>
    /// <returns></returns>
    private IPEndPoint BindIPEndPointCallback(ServicePoint servicePoint, IPEndPoint remoteEndPoint, int retryCount)
    {
        return _IPEndPoint;
    }
    #endregion

    #region 枚举
    /// <summary>
    /// Post的数据格式默认为string
    /// </summary>
    public enum PostDataType
    {
        /// <summary>
        /// 字符串类型，这时编码Encoding可不设置
        /// </summary>
        String,
        /// <summary>
        /// Byte类型，需要设置PostdataByte参数的值编码Encoding可设置为空
        /// </summary>
        Byte,
        /// <summary>
        /// 传文件，Postdata必须设置为文件的绝对路径，必须设置Encoding的值
        /// </summary>
        FilePath,
        /// <summary>
        /// 表单类型
        /// </summary>
        Form
    }
    /// <summary>
    /// Cookie返回类型
    /// </summary>
    public enum ResultCookieType
    {
        /// <summary>
        /// 只返回字符串类型的Cookie
        /// </summary>
        String,
        /// <summary>
        /// CookieCollection格式的Cookie集合同时也返回String类型的cookie
        /// </summary>
        CookieCollection
    }
    /// <summary>
    /// 返回类型
    /// </summary>
    public enum ResultType
    {
        /// <summary>
        /// 表示只返回字符串 只有Html有数据
        /// </summary>
        String,
        /// <summary>
        /// 表示返回字符串和字节流 ResultByte和Html都有数据返回
        /// </summary>
        Byte
    }
    #endregion
}