using System;
using System.IO;
using System.IO.Compression;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.RegularExpressions;

namespace MAX.Core.Helpers;


/// <summary>
/// Http连接操作帮助类
/// </summary>
public class HttpHelper
{
	public static HttpResult Get(string Url)
	{
		return new HttpHelper().GetHtml(new HttpItem
		{
			URL = Url,
			Method = MethodType.Get,
		});
	}

	public static HttpResult Post(string Url, string PostData)
	{
		return new HttpHelper().GetHtml(new HttpItem
		{
			URL = Url,
			Method = MethodType.Get,
			Postdata = PostData,
			PostDataType = PostDataType.String
		});
	}
	public static HttpResult Request(HttpItem item)
	{
		return new HttpHelper().GetHtml(item);
	}
	/// <summary>
	/// 下载文件
	/// </summary>
	/// <param name="address"></param>
	/// <param name="fileName"></param>
	public static byte[] DownloadFile(string address)
	{
		HttpItem item = new()
		{
			URL = address,
			Timeout = 3000,
			ResultType = ResultType.Byte
		};
		HttpHelper http = new();
		HttpResult result = http.GetHtml(item);
		if (result.StatusCode == HttpStatusCode.OK)
		{
			return result.ResultByte;
		}
		else
		{
			throw new HttpListenerException((int)result.StatusCode, result.StatusDescription);
		}
	}

	/// <summary>
	/// 下载文件
	/// </summary>
	/// <param name="address"></param>
	/// <param name="fileName"></param>
	public static bool DownloadFile(string address, string fileName)
	{
		HttpItem item = new()
		{
			URL = address,
			Timeout = 3000,
			ResultType = ResultType.Byte
		};
		HttpHelper http = new();
		HttpResult result = http.GetHtml(item);
		if (result.StatusCode == HttpStatusCode.OK)
		{
			FileStream fs = new(fileName, FileMode.CreateNew);
			BinaryWriter bw = new(fs);
			bw.Write(result.ResultByte);
			fs.Close();
			bw.Close();
		}
		else
		{
			throw new HttpListenerException((int)result.StatusCode, result.StatusDescription);
		}

		return true;
	}

	#region 预定义方法或者变更
	//默认的编码
	private Encoding encoding = Encoding.Default;
	//Post数据编码
	private Encoding postencoding = Encoding.Default;
	//HttpWebRequest对象用来发起请求
	private HttpWebRequest request = null;
	//获取影响流的数据对象
	private HttpWebResponse response = null;
	/// <summary>
	/// 根据相传入的数据，得到相应页面数据
	/// </summary>
	/// <param name="item">参数类对象</param>
	/// <returns>返回HttpResult类型</returns>
	public HttpResult GetHtml(HttpItem item)
	{
		//返回参数
		HttpResult result = new()
		{
			item = item
		};
		try
		{
			//准备参数
			SetRequest(item);
		}
		catch (Exception ex)
		{
			result = new HttpResult
			{
				Cookie = string.Empty,
				Header = null,
				Html = ex.Message,
				StatusDescription = "配置参数时出错：" + ex.Message
			};
			return result;
		}
		try
		{
			//请求数据
			using (response = (HttpWebResponse)request.GetResponse())
			{
				GetData(item, result);
			}
			//#region 得到请求的response
			//using (response = (HttpWebResponse)request.GetResponse())
			//{
			//    result.StatusCode = response.StatusCode;
			//    result.StatusDescription = response.StatusDescription;
			//    result.Header = response.Headers;
			//    if (response.Cookies != null) result.CookieCollection = response.Cookies;
			//    if (response.Headers["set-cookie"] != null) result.Cookie = response.Headers["set-cookie"];
			//    MemoryStream _stream = new MemoryStream();
			//    //GZIIP处理
			//    if (response.ContentEncoding != null && response.ContentEncoding.Equals("gzip", StringComparison.InvariantCultureIgnoreCase))
			//    {
			//        //开始读取流并设置编码方式
			//        //new GZipStream(response.GetResponseStream(), CompressionMode.Decompress).CopyTo(_stream, 10240);
			//        //.net4.0以下写法
			//        _stream = GetMemoryStream(new GZipStream(response.GetResponseStream(), CompressionMode.Decompress));

			//    }
			//    else
			//    {
			//        //开始读取流并设置编码方式
			//        //response.GetResponseStream().CopyTo(_stream, 10240);
			//        //.net4.0以下写法
			//        _stream = GetMemoryStream(response.GetResponseStream());
			//    }
			//    //获取Byte
			//    byte[] ResponseByte = _stream.ToArray();
			//    _stream.Close();
			//    if (ResponseByte != null & ResponseByte.Length > 0)
			//    {
			//        //是否返回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 = (meta.Groups.Count > 1) ? meta.Groups[2].Value.ToLower().Trim() : string.Empty;
			//            if (c.Length > 2)
			//            {
			//                try
			//                {
			//                    if (c.IndexOf(" ") > 0) c = c.Substring(0, c.IndexOf(" "));
			//                    encoding = Encoding.GetEncoding(c.Replace("\"", "").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);
			//            }
			//        }
			//        //得到返回的HTML
			//        result.Html = encoding.GetString(ResponseByte);
			//    }
			//    else
			//    {
			//        //得到返回的HTML
			//        result.Html = "本次请求并未返回任何数据";
			//    }
			//}
			//#endregion
		}
		catch (WebException ex)
		{
			if (ex.Response != null)
			{
				using (response = (HttpWebResponse)ex.Response)
				{
					GetData(item, result);
				}
			}
			else
			{
				result.Html = ex.Message;
			}

		}
		catch (Exception ex)
		{
			result.Html = ex.Message;
		}
		if (item.IsToLower)
		{
			result.Html = result.Html.ToLower();
		}

		return result;
	}

	#region GetData
	/// <summary>
	/// 获取数据的并解析的方法
	/// </summary>
	/// <param name="item"></param>
	/// <param name="result"></param>
	private void GetData(HttpItem item, HttpResult result)
	{
		if (response == null)
		{
			return;
		}
		#region base
		//获取StatusCode
		result.StatusCode = response.StatusCode;
		//获取最后访问的URl
		//获取StatusDescription
		result.StatusDescription = response.StatusDescription;
		//获取Headers
		result.Header = response.Headers;
		//获取CookieCollection
		if (response.Cookies != null)
		{
			result.CookieCollection = response.Cookies;
		}
		//获取set-cookie
		if (response.Headers["set-cookie"] != null)
		{
			result.Cookie = response.Headers["set-cookie"];
		}

		#endregion
		#region 用户设置用编码
		//处理网页Byte
		byte[] ResponseByte = GetByte(item);

		if (ResponseByte != null && ResponseByte.Length > 0)
		{
			//设置编码
			SetEncoding(item, result, ResponseByte);

			//设置返回的Byte
			SetResultByte(item, result, ResponseByte);
		}
		else
		{
			//没有返回任何Html代码
			result.Html = string.Empty;
		}

		#endregion
	}
	/// <summary>
	/// 设置返回的Byte
	/// </summary>
	/// <param name="item">HttpItem</param>
	/// <param name="result">result</param>
	/// <param name="enByte">byte</param>
	private void SetResultByte(HttpItem item, HttpResult result, byte[] enByte)
	{
		//是否返回Byte类型数据
		if (item.ResultType == ResultType.Byte)
		{
			//Byte数据
			result.ResultByte = enByte;
		}
		else if (item.ResultType == ResultType.String)
		{
			//得到返回的HTML
			result.Html = encoding.GetString(enByte);
		}

	}
	/// <summary>
	/// 设置编码
	/// </summary>
	/// <param name="item">HttpItem</param>
	/// <param name="result">HttpResult</param>
	/// <param name="ResponseByte">byte[]</param>
	private void SetEncoding(HttpItem item, HttpResult result, byte[] 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();
			}
			string cs = string.Empty;
			if (!string.IsNullOrWhiteSpace(response.CharacterSet))
			{
				cs = response.CharacterSet.Trim().Replace("\"", "").Replace("\'", "");
			}

			if (c.Length > 2)
			{
				try
				{
					encoding = Encoding.GetEncoding(c.Replace("\"", string.Empty).Replace("'", "").Replace(";", "").Replace("iso-8859-1", "gbk").Trim());
				}
				catch
				{
					if (string.IsNullOrEmpty(cs))
					{
						encoding = Encoding.UTF8;
					}
					else
					{
						encoding = Encoding.GetEncoding(cs);
					}
				}
			}
			else
			{
				if (string.IsNullOrEmpty(cs))
				{
					encoding = Encoding.UTF8;
				}
				else
				{
					encoding = Encoding.GetEncoding(cs);
				}
			}
		}
	}
	/// <summary>
	/// 提取网页Byte
	/// </summary>
	/// <returns></returns>
	private byte[] GetByte(HttpItem item)
	{
		byte[] ResponseByte = null;
		using (MemoryStream _stream = new())
		{

			//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;
	}
	#endregion


	/// <summary>
	/// 4.0以下.net版本取数据使用
	/// </summary>
	/// <param name="streamResponse">流</param>
	private MemoryStream GetMemoryStream(Stream streamResponse)
	{
		MemoryStream _stream = new();
		int Length = 256;
		Byte[] buffer = new Byte[Length];
		int bytesRead = streamResponse.Read(buffer, 0, Length);
		while (bytesRead > 0)
		{
			_stream.Write(buffer, 0, bytesRead);
			bytesRead = streamResponse.Read(buffer, 0, Length);
		}
		return _stream;
	}
	/// <summary>
	/// 为请求准备参数
	/// </summary>
	///<param name="item">参数列表</param>
	private void SetRequest(HttpItem item)

	{
		// 验证证书
		SetCer(item);
		//设置Header参数
		if (item.Header != null && item.Header.Count > 0)
		{
			foreach (string key in item.Header.AllKeys)
			{
				request.Headers.Add(key, item.Header[key]);
			}
		}
		// 设置代理
		SetProxy(item);
		if (item.ProtocolVersion != null)
		{
			request.ProtocolVersion = item.ProtocolVersion;
		}

		request.ServicePoint.Expect100Continue = item.Expect100Continue;
		//请求方式Get或者Post
		request.Method = item.Method.ToString();
		request.Timeout = item.Timeout;
		request.KeepAlive = item.KeepAlive;
		request.ReadWriteTimeout = item.ReadWriteTimeout;
		//Accept
		request.Accept = item.Accept;
		//ContentType返回类型
		request.ContentType = item.ContentType;
		//UserAgent客户端的访问类型，包括浏览器版本和操作系统信息
		request.UserAgent = item.UserAgent;
		// 编码
		encoding = item.Encoding;
		//设置安全凭证
		request.Credentials = item.ICredentials;
		//设置Cookie
		SetCookie(item);
		//来源地址
		request.Referer = item.Referer;
		//是否执行跳转功能
		request.AllowAutoRedirect = item.Allowautoredirect;
		//设置Post数据
		SetPostData(item);
		//设置最大连接
		if (item.Connectionlimit > 0)
		{
			request.ServicePoint.ConnectionLimit = item.Connectionlimit;
		}
	}
	/// <summary>
	/// 设置证书
	/// </summary>
	/// <param name="item"></param>
#pragma warning disable SYSLIB0014 // Type or member is obsolete
	private void SetCer(HttpItem item)
	{
		if (!string.IsNullOrEmpty(item.CerPath))
		{
			//这一句一定要写在创建连接的前面。使用回调的方法进行证书验证。
			ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
			//初始化对像，并设置请求的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);
		}
	}
#pragma warning restore SYSLIB0014 // Type or member is obsolete
	/// <summary>
	/// 设置多个证书
	/// </summary>
	/// <param name="item"></param>
	private void SetCerList(HttpItem item)
	{
		if (item.ClentCertificates != null && item.ClentCertificates.Count > 0)
		{
			foreach (X509Certificate c in item.ClentCertificates)
			{
				request.ClientCertificates.Add(c);
			}
		}
	}
	/// <summary>
	/// 设置Cookie
	/// </summary>
	/// <param name="item">Http参数</param>
	private void SetCookie(HttpItem item)
	{
		if (!string.IsNullOrEmpty(item.Cookie))
		{
			request.Headers[HttpRequestHeader.Cookie] = item.Cookie;
		}
		//设置CookieCollection
		if (item.ResultCookieType == ResultCookieType.CookieCollection)
		{
			request.CookieContainer = new CookieContainer();
			if (item.CookieCollection != null && item.CookieCollection.Count > 0)
			{
				request.CookieContainer.Add(item.CookieCollection);
			}
		}
	}
	/// <summary>
	/// 设置Post数据
	/// </summary>
	/// <param name="item">Http参数</param>
	private void SetPostData(HttpItem item)
	{
		//验证在得到结果时是否有传入数据
		if (request.Method.Trim().ToLower().Contains("post"))
		{
			if (item.PostEncoding != null)
			{
				postencoding = item.PostEncoding;
			}
			byte[] buffer = null;
			//写入Byte类型
			if (item.PostDataType == PostDataType.Byte && item.PostdataByte != null && item.PostdataByte.Length > 0)
			{
				//验证在得到结果时是否有传入数据
				buffer = item.PostdataByte;
			}//写入文件
			else if (item.PostDataType == PostDataType.FilePath && !string.IsNullOrEmpty(item.Postdata))
			{
				StreamReader r = new(item.Postdata, postencoding);
				buffer = postencoding.GetBytes(r.ReadToEnd());
				r.Close();
			} //写入字符串
			else if (!string.IsNullOrEmpty(item.Postdata))
			{
				buffer = postencoding.GetBytes(item.Postdata);
			}
			if (buffer != null)
			{
				request.ContentLength = buffer.Length;
				request.GetRequestStream().Write(buffer, 0, buffer.Length);
			}
		}
	}
	/// <summary>
	/// 设置代理
	/// </summary>
	/// <param name="item">参数对象</param>
	private void SetProxy(HttpItem item)
	{
		bool isIeProxy = item.ProxyIp.ToLower().Contains("ieproxy");
		if (!string.IsNullOrEmpty(item.ProxyIp) && !isIeProxy)
		{
			//设置代理服务器
			if (item.ProxyIp.Contains(":"))
			{
				string[] plist = item.ProxyIp.Split(':');
				WebProxy myProxy = new(plist[0].Trim(), Convert.ToInt(plist[1].Trim()))
				{
					//建议连接
					Credentials = new NetworkCredential(item.ProxyUserName, item.ProxyPwd)
				};
				//给当前请求对象
				request.Proxy = myProxy;
			}
			else
			{
				WebProxy myProxy = new(item.ProxyIp, false)
				{
					//建议连接
					Credentials = new NetworkCredential(item.ProxyUserName, item.ProxyPwd)
				};
				//给当前请求对象
				request.Proxy = myProxy;
			}
		}
		else if (isIeProxy)
		{
			//设置为IE代理
		}
		else
		{
			request.Proxy = item.WebProxy;
		}
	}
	/// <summary>
	/// 回调验证证书问题
	/// </summary>
	/// <param name="sender">流对象</param>
	/// <param name="certificate">证书</param>
	/// <param name="chain">X509Chain</param>
	/// <param name="errors">SslPolicyErrors</param>
	/// <returns>bool</returns>
	public bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) { return true; }
	#endregion
}
/// <summary>
/// Http请求参考类
/// </summary>
public class HttpItem
{
	private string _URL = string.Empty;
	/// <summary>
	/// 请求URL必须填写
	/// </summary>
	public string URL
	{
		get { return _URL; }
		set { _URL = value; }
	}

	private MethodType _Method = MethodType.Get;
	/// <summary>
	/// 请求方式默认为GET方式,当为POST方式时必须设置Postdata的值
	/// </summary>
	public MethodType Method
	{
		get { return _Method; }
		set
		{
			_Method = value;
			if (_Method == MethodType.Post)
			{
				_ContentType = "application/x-www-form-urlencoded";
			}
		}
	}

	private int _Timeout = 100000;
	/// <summary>
	/// 默认请求超时时间
	/// </summary>
	public int Timeout
	{
		get { return _Timeout; }
		set { _Timeout = value; }
	}

	private int _ReadWriteTimeout = 30000;
	/// <summary>
	/// 默认写入Post数据超时间
	/// </summary>
	public int ReadWriteTimeout
	{
		get { return _ReadWriteTimeout; }
		set { _ReadWriteTimeout = value; }
	}

	private Boolean _KeepAlive = true;
	/// <summary>
	///  获取或设置一个值，该值指示是否与 Internet 资源建立持久性连接默认为true。
	/// </summary>
	public Boolean KeepAlive
	{
		get { return _KeepAlive; }
		set { _KeepAlive = value; }
	}

	private string _Accept = "text/html, application/xhtml+xml, */*";
	/// <summary>
	/// 请求标头值 默认为text/html, application/xhtml+xml, */*
	/// </summary>
	public string Accept
	{
		get { return _Accept; }
		set { _Accept = value; }
	}

	private string _ContentType = "text/html";
	/// <summary>
	/// 请求返回类型默认 text/html
	/// </summary>
	public string ContentType
	{
		get { return _ContentType; }
		set { _ContentType = value; }
	}

	private 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; }
	}

	private Encoding _Encoding = null;
	/// <summary>
	/// 返回数据编码默认为NUll,可以自动识别,一般为utf-8,gbk,gb2312
	/// </summary>
	public Encoding Encoding
	{
		get { return _Encoding; }
		set { _Encoding = value; }
	}
	private PostDataType _PostDataType = PostDataType.String;
	/// <summary>
	/// Post的数据类型
	/// </summary>
	public PostDataType PostDataType
	{
		get { return _PostDataType; }
		set { _PostDataType = value; }
	}

	private string _Postdata = string.Empty;
	/// <summary>
	/// Post请求时要发送的字符串Post数据
	/// </summary>
	public string Postdata
	{
		get { return _Postdata; }
		set { _Postdata = value; }
	}
	private byte[] _PostdataByte = null;
	/// <summary>
	/// Post请求时要发送的Byte类型的Post数据
	/// </summary>
	public byte[] PostdataByte
	{
		get { return _PostdataByte; }
		set { _PostdataByte = value; }
	}
	private WebProxy _WebProxy;
	/// <summary>
	/// 设置代理对象，不想使用IE默认配置就设置为Null，而且不要设置ProxyIp
	/// </summary>
	public WebProxy WebProxy
	{
		get { return _WebProxy; }
		set { _WebProxy = value; }
	}

	private CookieCollection cookiecollection = null;
	/// <summary>
	/// Cookie对象集合
	/// </summary>
	public CookieCollection CookieCollection
	{
		get { return cookiecollection; }
		set { cookiecollection = value; }
	}

	private string _Cookie = string.Empty;
	/// <summary>
	/// 请求时的Cookie
	/// </summary>
	public string Cookie
	{
		get { return _Cookie; }
		set { _Cookie = value; }
	}

	private string _Referer = string.Empty;
	/// <summary>
	/// 来源地址，上次访问地址
	/// </summary>
	public string Referer
	{
		get { return _Referer; }
		set { _Referer = value; }
	}

	private string _CerPath = string.Empty;
	/// <summary>
	/// 证书绝对路径
	/// </summary>
	public string CerPath
	{
		get { return _CerPath; }
		set { _CerPath = value; }
	}
	private Boolean isToLower = false;
	/// <summary>
	/// 是否设置为全文小写，默认为不转化
	/// </summary>
	public Boolean IsToLower
	{
		get { return isToLower; }
		set { isToLower = value; }
	}
	private Boolean allowautoredirect = true;
	/// <summary>
	/// 支持跳转页面，查询结果将是跳转后的页面
	/// </summary>
	public Boolean Allowautoredirect
	{
		get { return allowautoredirect; }
		set { allowautoredirect = value; }
	}
	private int connectionlimit = 1024;
	/// <summary>
	/// 最大连接数
	/// </summary>
	public int Connectionlimit
	{
		get { return connectionlimit; }
		set { connectionlimit = value; }
	}
	private string proxyusername = string.Empty;
	/// <summary>
	/// 代理Proxy 服务器用户名
	/// </summary>
	public string ProxyUserName
	{
		get { return proxyusername; }
		set { proxyusername = value; }
	}
	private string proxypwd = string.Empty;
	/// <summary>
	/// 代理 服务器密码
	/// </summary>
	public string ProxyPwd
	{
		get { return proxypwd; }
		set { proxypwd = value; }
	}
	private string proxyip = string.Empty;
	/// <summary>
	/// 代理 服务IP ,如果要使用IE代理就设置为ieproxy
	/// </summary>
	public string ProxyIp
	{
		get { return proxyip; }
		set { proxyip = value; }
	}
	private ResultType resulttype = ResultType.String;
	/// <summary>
	/// 设置返回类型String和Byte
	/// </summary>
	public ResultType ResultType
	{
		get { return resulttype; }
		set { resulttype = value; }
	}
	private WebHeaderCollection header = [];
	/// <summary>
	/// header对象
	/// </summary>
	public WebHeaderCollection Header
	{
		get { return header; }
		set { header = value; }
	}

	private Version _ProtocolVersion;

	/// <summary>
	///     获取或设置用于请求的 HTTP 版本。返回结果:用于请求的 HTTP 版本。默认为 System.Net.HttpVersion.Version11。
	/// </summary>
	public Version ProtocolVersion
	{
		get { return _ProtocolVersion; }
		set { _ProtocolVersion = value; }
	}
	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 X509CertificateCollection _ClentCertificates;
	/// <summary>
	/// 设置509证书集合
	/// </summary>
	public X509CertificateCollection ClentCertificates
	{
		get { return _ClentCertificates; }
		set { _ClentCertificates = value; }
	}
	private Encoding _PostEncoding;
	/// <summary>
	/// 设置或获取Post参数编码,默认的为Default编码
	/// </summary>
	public Encoding PostEncoding
	{
		get { return _PostEncoding; }
		set { _PostEncoding = value; }
	}
	private ResultCookieType _ResultCookieType = ResultCookieType.String;
	/// <summary>
	/// Cookie返回类型,默认的是只返回字符串类型
	/// </summary>
	public ResultCookieType ResultCookieType
	{
		get { return _ResultCookieType; }
		set { _ResultCookieType = value; }
	}

	private ICredentials _ICredentials = CredentialCache.DefaultCredentials;
	/// <summary>
	/// 获取或设置请求的身份验证信息。
	/// </summary>
	public ICredentials ICredentials
	{
		get { return _ICredentials; }
		set { _ICredentials = value; }
	}

}
/// <summary>
/// Http返回参数类
/// </summary>
public class HttpResult
{
	private string _Cookie;
	/// <summary>
	/// Http请求返回的Cookie
	/// </summary>
	public string Cookie
	{
		get { return _Cookie; }
		set { _Cookie = value; }
	}

	private CookieCollection _CookieCollection;
	/// <summary>
	/// Cookie对象集合
	/// </summary>
	public CookieCollection CookieCollection
	{
		get { return _CookieCollection; }
		set { _CookieCollection = value; }
	}
	private string _Html;
	/// <summary>
	/// 返回的String类型数据 只有ResultType.String时才返回数据，其它情况为空
	/// </summary>
	public string Html
	{
		get { return _Html; }
		set { _Html = value; }
	}
	private byte[] _ResultByte;
	/// <summary>
	/// 返回的Byte数组 只有ResultType.Byte时才返回数据，其它情况为空
	/// </summary>
	public byte[] ResultByte
	{
		get { return _ResultByte; }
		set { _ResultByte = value; }
	}

	private WebHeaderCollection _Header;
	/// <summary>
	/// header对象
	/// </summary>
	public WebHeaderCollection Header
	{
		get { return _Header; }
		set { _Header = value; }
	}

	private string _StatusDescription;
	/// <summary>
	/// 返回状态说明
	/// </summary>
	public string StatusDescription
	{
		get { return _StatusDescription; }
		set { _StatusDescription = value; }
	}
	private HttpStatusCode _StatusCode;
	/// <summary>
	/// 返回状态码,默认为OK
	/// </summary>
	public HttpStatusCode StatusCode
	{
		get { return _StatusCode; }
		set { _StatusCode = value; }
	}
	/// <summary>
	/// HttpItem类，用于存储实际执行所用到的HttpItem对象
	/// </summary>
	public HttpItem item { get; set; }
}
/// <summary>
/// 返回类型
/// </summary>
public enum ResultType
{
	/// <summary>
	/// 表示只返回字符串 只有Html有数据
	/// </summary>
	String,
	/// <summary>
	/// 表示返回字符串和字节流 ResultByte和Html都有数据返回
	/// </summary>
	Byte
}
/// <summary>
/// Post的数据格式默认为string
/// </summary>
public enum PostDataType
{
	/// <summary>
	/// 字符串类型，这时编码Encoding可不设置
	/// </summary>
	String,
	/// <summary>
	/// Byte类型，需要设置PostdataByte参数的值编码Encoding可设置为空
	/// </summary>
	Byte,
	/// <summary>
	/// 传文件，Postdata必须设置为文件的绝对路径，必须设置Encoding的值
	/// </summary>
	FilePath
}
/// <summary>
/// Cookie返回类型
/// </summary>
public enum ResultCookieType
{
	/// <summary>
	/// 只返回字符串类型的Cookie
	/// </summary>
	String,
	/// <summary>
	/// CookieCollection格式的Cookie集合同时也返回String类型的cookie
	/// </summary>
	CookieCollection
}
public enum MethodType
{
	Get,
	Post
}