using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.IO;
using System.Net;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.IO.Compression;
using System.Net.Cache; namespace Translate.Core.HTTP
{
/// <summary>
/// 上传数据参数
/// </summary>
public class UploadEventArgs : EventArgs
{
int bytesSent;
int totalBytes;
/// <summary>
/// 已发送的字节数
/// </summary>
public int BytesSent
{
get { return bytesSent; }
set { bytesSent = value; }
}
/// <summary>
/// 总字节数
/// </summary>
public int TotalBytes
{
get { return totalBytes; }
set { totalBytes = value; }
}
}
/// <summary>
/// 下载数据参数
/// </summary>
public class DownloadEventArgs : EventArgs
{
int bytesReceived;
int totalBytes;
byte[] receivedData;
/// <summary>
/// 已接收的字节数
/// </summary>
public int BytesReceived
{
get { return bytesReceived; }
set { bytesReceived = value; }
}
/// <summary>
/// 总字节数
/// </summary>
public int TotalBytes
{
get { return totalBytes; }
set { totalBytes = value; }
}
/// <summary>
/// 当前缓冲区接收的数据
/// </summary>
public byte[] ReceivedData
{
get { return receivedData; }
set { receivedData = value; }
}
} public class HttpWebClient
{
Encoding encoding = Encoding.Default;
string respHtml = "";
WebProxy proxy;
static CookieContainer cc;
WebHeaderCollection requestHeaders;
WebHeaderCollection responseHeaders;
int bufferSize = ;
public event EventHandler<UploadEventArgs> UploadProgressChanged;
public event EventHandler<DownloadEventArgs> DownloadProgressChanged;
static HttpWebClient()
{
LoadCookiesFromDisk();
}
/// <summary>
/// 创建WebClient的实例
/// </summary>
public HttpWebClient()
{
requestHeaders = new WebHeaderCollection();
responseHeaders = new WebHeaderCollection();
}
/// <summary>
/// 设置发送和接收的数据缓冲大小
/// </summary>
public int BufferSize
{
get { return bufferSize; }
set { bufferSize = value; }
}
/// <summary>
/// 获取响应头集合
/// </summary>
public WebHeaderCollection ResponseHeaders
{
get { return responseHeaders; }
}
/// <summary>
/// 获取请求头集合
/// </summary>
public WebHeaderCollection RequestHeaders
{
get { return requestHeaders; }
}
/// <summary>
/// 获取或设置代理
/// </summary>
public WebProxy Proxy
{
get { return proxy; }
set { proxy = value; }
}
/// <summary>
/// 获取或设置请求与响应的文本编码方式
/// </summary>
public Encoding Encoding
{
get { return encoding; }
set { encoding = value; }
}
/// <summary>
/// 获取或设置响应的html代码
/// </summary>
public string RespHtml
{
get { return respHtml; }
set { respHtml = value; }
}
/// <summary>
/// 获取或设置与请求关联的Cookie容器
/// </summary>
public CookieContainer CookieContainer
{
get { return cc; }
set { cc = value; }
}
/// <summary>
/// 获取网页源代码
/// </summary>
/// <param name="url">网址</param>
/// <returns></returns>
public string GetHtml(string url)
{
HttpWebRequest request = CreateRequest(url, "GET");
respHtml = encoding.GetString(GetData(request));
return respHtml;
}
/// <summary>
/// 下载文件
/// </summary>
/// <param name="url">文件URL地址</param>
/// <param name="filename">文件保存完整路径</param>
public void DownloadFile(string url, string filename)
{
FileStream fs = null;
try
{
HttpWebRequest request = CreateRequest(url, "GET");
byte[] data = GetData(request);
fs = new FileStream(filename, FileMode.Create, FileAccess.Write);
fs.Write(data, , data.Length);
}
finally
{
if (fs != null) fs.Close();
}
}
/// <summary>
/// 从指定URL下载数据
/// </summary>
/// <param name="url">网址</param>
/// <returns></returns>
public byte[] GetData(string url)
{
HttpWebRequest request = CreateRequest(url, "GET");
return GetData(request);
} /// <summary>
/// 发送短文本参数
/// </summary>
/// <param name="url"></param>
/// <param name="postData"></param>
/// <returns></returns>
public string PostTextString(string url, string postData)
{
var encod = System.Text.Encoding.UTF8;
// byte[] postBytes = encoding.GetBytes(data);
byte[] data = encod.GetBytes(postData); HttpWebRequest request = CreateRequest(url, "POST");
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = data.Length;
request.KeepAlive = true;
request.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8";
request.Timeout = ; using (Stream st = request.GetRequestStream())
{
st.Write(data, , data.Length);
st.Close();
} System.Net.ServicePointManager.ServerCertificateValidationCallback += (se, cert, chain, sslerror) =>
{
return true;
}; HttpWebResponse res = (HttpWebResponse)request.GetResponse();
Stream resst = res.GetResponseStream();
StreamReader sr = new StreamReader(resst, encod);
string str = sr.ReadToEnd(); res.Close();
resst.Dispose();
sr.Dispose();
return str;
} /// <summary>
/// 向指定URL发送数据
/// </summary>
/// <param name="url">网址</param>
/// <param name="postData">urlencode编码的文本数据</param>
/// <returns></returns>
public string Post(string url, string postData)
{
byte[] data = encoding.GetBytes(postData);
return Post(url, data);
}
/// <summary>
/// 向指定URL发送字节数据
/// </summary>
/// <param name="url">网址</param>
/// <param name="postData">发送的字节数组</param>
/// <returns></returns>
public string Post(string url, byte[] postData)
{
HttpWebRequest request = CreateRequest(url, "POST");
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = postData.Length;
request.KeepAlive = true;
PostData(request, postData);
respHtml = encoding.GetString(GetData(request));
return respHtml;
}
/// <summary>
/// 向指定网址发送mulitpart编码的数据
/// </summary>
/// <param name="url">网址</param>
/// <param name="mulitpartForm">mulitpart form data</param>
/// <returns></returns>
public string Post(string url, MultipartForm mulitpartForm)
{
HttpWebRequest request = CreateRequest(url, "POST");
request.ContentType = mulitpartForm.ContentType;
request.ContentLength = mulitpartForm.FormData.Length;
request.KeepAlive = true;
PostData(request, mulitpartForm.FormData);
respHtml = encoding.GetString(GetData(request));
return respHtml;
} /// <summary>
/// 读取请求返回的数据
/// </summary>
/// <param name="request">请求对象</param>
/// <returns></returns>
private byte[] GetData(HttpWebRequest request)
{
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
Stream stream = response.GetResponseStream();
responseHeaders = response.Headers;
//SaveCookiesToDisk(); DownloadEventArgs args = new DownloadEventArgs();
if (responseHeaders[HttpResponseHeader.ContentLength] != null)
args.TotalBytes = Convert.ToInt32(responseHeaders[HttpResponseHeader.ContentLength]); MemoryStream ms = new MemoryStream();
int count = ;
byte[] buf = new byte[bufferSize];
while ((count = stream.Read(buf, , buf.Length)) > )
{
ms.Write(buf, , count);
if (this.DownloadProgressChanged != null)
{
args.BytesReceived += count;
args.ReceivedData = new byte[count];
Array.Copy(buf, args.ReceivedData, count);
this.DownloadProgressChanged(this, args);
}
}
stream.Close();
//解压
if (ResponseHeaders[HttpResponseHeader.ContentEncoding] != null)
{
MemoryStream msTemp = new MemoryStream();
count = ;
buf = new byte[];
switch (ResponseHeaders[HttpResponseHeader.ContentEncoding].ToLower())
{
case "gzip":
GZipStream gzip = new GZipStream(ms, CompressionMode.Decompress);
while ((count = gzip.Read(buf, , buf.Length)) > )
{
msTemp.Write(buf, , count);
}
return msTemp.ToArray();
case "deflate":
DeflateStream deflate = new DeflateStream(ms, CompressionMode.Decompress);
while ((count = deflate.Read(buf, , buf.Length)) > )
{
msTemp.Write(buf, , count);
}
return msTemp.ToArray();
default:
break;
}
}
return ms.ToArray();
}
/// <summary>
/// 发送请求数据
/// </summary>
/// <param name="request">请求对象</param>
/// <param name="postData">请求发送的字节数组</param>
private void PostData(HttpWebRequest request, byte[] postData)
{
int offset = ;
int sendBufferSize = bufferSize;
int remainBytes = ;
Stream stream = request.GetRequestStream();
UploadEventArgs args = new UploadEventArgs();
args.TotalBytes = postData.Length;
while ((remainBytes = postData.Length - offset) > )
{
if (sendBufferSize > remainBytes) sendBufferSize = remainBytes;
stream.Write(postData, offset, sendBufferSize);
offset += sendBufferSize;
if (this.UploadProgressChanged != null)
{
args.BytesSent = offset;
this.UploadProgressChanged(this, args);
}
}
stream.Close();
}
/// <summary>
/// 创建HTTP请求
/// </summary>
/// <param name="url">URL地址</param>
/// <returns></returns>
private HttpWebRequest CreateRequest(string url, string method)
{
Uri uri = new Uri(url); if (uri.Scheme == "https")
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(this.CheckValidationResult); // Set a default policy level for the "http:" and "https" schemes.
HttpRequestCachePolicy policy = new HttpRequestCachePolicy(HttpRequestCacheLevel.Revalidate);
HttpWebRequest.DefaultCachePolicy = policy; HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
request.AllowAutoRedirect = false;
request.AllowWriteStreamBuffering = false;
request.Method = method;
if (proxy != null)
request.Proxy = proxy;
request.CookieContainer = cc;
foreach (string key in requestHeaders.Keys)
{
request.Headers.Add(key, requestHeaders[key]);
}
requestHeaders.Clear();
return request;
}
private bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
{
return true;
}
/// <summary>
/// 将Cookie保存到磁盘
/// </summary>
private static void SaveCookiesToDisk()
{
string cookieFile = System.Environment.GetFolderPath(Environment.SpecialFolder.Cookies) + "\\webclient.cookie";
FileStream fs = null;
try
{
fs = new FileStream(cookieFile, FileMode.Create);
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formater = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
formater.Serialize(fs, cc);
}
finally
{
if (fs != null) fs.Close();
}
}
/// <summary>
/// 从磁盘加载Cookie
/// </summary>
private static void LoadCookiesFromDisk()
{
cc = new CookieContainer();
string cookieFile = System.Environment.GetFolderPath(Environment.SpecialFolder.Cookies) + "\\webclient.cookie";
if (!File.Exists(cookieFile))
return;
FileStream fs = null;
try
{
fs = new FileStream(cookieFile, FileMode.Open, FileAccess.Read, FileShare.Read);
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formater = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
cc = (CookieContainer)formater.Deserialize(fs);
}
finally
{
if (fs != null) fs.Close();
}
}
} /// <summary>
/// 对文件和文本数据进行Multipart形式的编码
/// </summary>
public class MultipartForm
{
private Encoding encoding;
private MemoryStream ms;
private string boundary;
private byte[] formData;
/// <summary>
/// 获取编码后的字节数组
/// </summary>
public byte[] FormData
{
get
{
if (formData == null)
{
byte[] buffer = encoding.GetBytes("--" + this.boundary + "--\r\n");
ms.Write(buffer, , buffer.Length);
formData = ms.ToArray();
}
return formData;
}
}
/// <summary>
/// 获取此编码内容的类型
/// </summary>
public string ContentType
{
get { return string.Format("multipart/form-data; boundary={0}", this.boundary); }
}
/// <summary>
/// 获取或设置对字符串采用的编码类型
/// </summary>
public Encoding StringEncoding
{
set { encoding = value; }
get { return encoding; }
}
/// <summary>
/// 实例化
/// </summary>
public MultipartForm()
{
boundary = string.Format("--{0}--", Guid.NewGuid());
ms = new MemoryStream();
encoding = Encoding.Default;
}
/// <summary>
/// 添加一个文件
/// </summary>
/// <param name="name">文件域名称</param>
/// <param name="filename">文件的完整路径</param>
public void AddFlie(string name, string filename)
{
if (!File.Exists(filename))
throw new FileNotFoundException("尝试添加不存在的文件。", filename);
FileStream fs = null;
byte[] fileData = { };
try
{
fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
fileData = new byte[fs.Length];
fs.Read(fileData, , fileData.Length);
this.AddFlie(name, Path.GetFileName(filename), fileData, fileData.Length);
}
catch (Exception)
{
throw;
}
finally
{
if (fs != null) fs.Close();
}
}
/// <summary>
/// 添加一个文件
/// </summary>
/// <param name="name">文件域名称</param>
/// <param name="filename">文件名</param>
/// <param name="fileData">文件二进制数据</param>
/// <param name="dataLength">二进制数据大小</param>
public void AddFlie(string name, string filename, byte[] fileData, int dataLength)
{
if (dataLength <= || dataLength > fileData.Length)
{
dataLength = fileData.Length;
}
StringBuilder sb = new StringBuilder();
sb.AppendFormat("--{0}\r\n", this.boundary);
sb.AppendFormat("Content-Disposition: form-data; name=\"{0}\";filename=\"{1}\"\r\n", name, filename);
sb.AppendFormat("Content-Type: {0}\r\n", this.GetContentType(filename));
sb.Append("\r\n");
byte[] buf = encoding.GetBytes(sb.ToString());
ms.Write(buf, , buf.Length);
ms.Write(fileData, , dataLength);
byte[] crlf = encoding.GetBytes("\r\n");
ms.Write(crlf, , crlf.Length);
}
/// <summary>
/// 添加字符串
/// </summary>
/// <param name="name">文本域名称</param>
/// <param name="value">文本值</param>
public void AddString(string name, string value)
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("--{0}\r\n", this.boundary);
sb.AppendFormat("Content-Disposition: form-data; name=\"{0}\"\r\n", name);
sb.Append("\r\n");
sb.AppendFormat("{0}\r\n", value);
byte[] buf = encoding.GetBytes(sb.ToString());
ms.Write(buf, , buf.Length);
}
/// <summary>
/// 从注册表获取文件类型
/// </summary>
/// <param name="filename">包含扩展名的文件名</param>
/// <returns>如：application/stream</returns>
private string GetContentType(string filename)
{
Microsoft.Win32.RegistryKey fileExtKey = null; ;
string contentType = "application/stream";
try
{
fileExtKey = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(Path.GetExtension(filename));
contentType = fileExtKey.GetValue("Content Type", contentType).ToString();
}
finally
{
if (fileExtKey != null) fileExtKey.Close();
}
return contentType;
}
}
}