HttpWebRequest

新增了证书信息的添加

Request

封装一个请求信息类

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

using Notify.Solution.Code.Common.Enum;

namespace Notify.Solution.Code.Common.Model
{
/// <summary>
/// The request.
/// </summary>
public class Request
{
/// <summary>
/// Initializes a new instance of the <see cref="Request"/> class.
/// </summary>
/// <param name="url">
/// The url.
/// </param>
public Request(string url)
{
this.Url = url;
}

/// <summary>
/// 请求目标地址
/// </summary>
public string Url { get; private set; }

/// <summary>
/// Referer HTTP 标头的值
/// </summary>
public string Referer { get; set; }

/// <summary>
/// Cookie
/// </summary>
public CookieContainer Cookie { get; set; }

/// <summary>
/// 代理
/// </summary>
public WebProxy Proxy { get; set; }

/// <summary>
/// 请求方式
/// </summary>
public HttpMethod HttpMethod { get; set; }

/// <summary>
/// 参数编码格式
/// </summary>
private Encoding encoding = Encoding.UTF8;

/// <summary>
/// 参数编码格式
/// </summary>
public Encoding Encoding
{
get
{
return this.encoding;
}

set
{
this.encoding = value;
}
}

/// <summary>
/// 是否与 Internet 资源建立持久性连接。
/// </summary>
public bool KeepAlive { get; set; }

/// <summary>
/// 请求超时时间
/// </summary>
private int timeout = 30 * 0x3e8;

/// <summary>
/// 请求超时时间(单位毫秒)
/// </summary>
public int Timeout
{
get
{
return this.timeout;
}

set
{
this.timeout = value;
}
}

/// <summary>
/// 请求参数
/// </summary>
public IDictionary<string, string> Parameters { get; set; }

/// <summary>
/// 证书
/// </summary>
public Certificate Certificate { get; set; }
}

/// <summary>
/// 证书
/// </summary>
public class Certificate
{
/// <summary>
/// 证书地址
/// </summary>
public string CertFile { get; set; }

/// <summary>
/// 证书密码
/// </summary>
public string CertPasswd { get; set; }
}
}

请求类返回一个Stream 对象

GetStream

该方法主要创建 一个http请求 和响应http内容处理

var httpWebRequest = GetHttpWebRequest(request);

创建http请求 和响应参数设置

response = (HttpWebResponse)httpWebRequest.GetResponse();

响应http内容

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

using Notify.Solution.Code.Common.Enum;
using Notify.Solution.Code.Common.Model;
using Notify.Solution.Code.Extension;

namespace Notify.Solution.Code.Utility
{
using System.Security.Cryptography.X509Certificates;

using Exception = System.Exception;

/// <summary>
/// The http utility.
/// </summary>
internal static class HttpRequestUtility
{
/// <summary>
/// GetStream
/// </summary>
/// <param name="request">request</param>
/// <returns>Stream</returns>
internal static Stream GetStream(Request request)
{
HttpWebResponse response = null;
Stream responseStream = null;
try
{
var httpWebRequest = GetHttpWebRequest(request);
response = (HttpWebResponse)httpWebRequest.GetResponse();
responseStream = response.GetResponseStream();
byte[] buffer = StreamToBytes(responseStream);
Stream memoryStream = new MemoryStream(buffer);
request.Cookie = httpWebRequest.CookieContainer;
return memoryStream;
}
catch (Exception)
{
return null;
}
finally
{
if (responseStream != null)
{
responseStream.Dispose();
responseStream.Close();
}

if (response != null)
{
response.Dispose();
response.Close();
}
}
}

/// <summary>
/// GteParameters
/// </summary>
/// <param name="parameters">parameters</param>
/// <returns>string</returns>
private static string GteParameters(IDictionary<string, string> parameters)
{
if (parameters == null || !parameters.Any())
{
return string.Empty;
}

return parameters.Join("&", p => p.Key + "=" + p.Value);
}

/// <summary>
/// CreateUri
/// </summary>
/// <param name="request">url</param>
/// <returns>Uri</returns>
private static Uri CreateUri(Request request)
{
if (string.IsNullOrEmpty(request.Url))
{
throw new ArgumentNullException("url");
}

string url = request.Url;
if (request.HttpMethod == HttpMethod.Get)
{
string parameters = GteParameters(request.Parameters);
url = url + "?" + parameters;
}

Uri uri;
if (Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out uri))
{
return uri;
}
else
{
throw new ArgumentException("请求目标地址格式错误");
}
}

/// <summary>
/// 设置请求基本信息
/// </summary>
/// <param name="request">request</param>
/// <returns>HttpWebRequest</returns>
private static HttpWebRequest GetHttpWebRequest(Request request)
{
Uri uri = CreateUri(request);
HttpWebRequest webRequest = WebRequest.CreateHttp(uri);
HttpRequestCachePolicy policy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
webRequest.CachePolicy = policy;
webRequest.Timeout = request.Timeout;
webRequest.KeepAlive = request.KeepAlive;
webRequest.Method = request.HttpMethod.ToString();
webRequest.CookieContainer = request.Cookie;
webRequest.Referer = request.Referer;
webRequest.UserAgent = "Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; SV1; .NET CLR 2.0.1124)";
webRequest.Headers.Add("Cache-Control", "no-cache");
webRequest.Accept = "*/*";
webRequest.Credentials = CredentialCache.DefaultCredentials;

SetProxy(webRequest, request);

SetCertificate(webRequest, request);

SetParameters(webRequest, request);

return webRequest;
}

/// <summary>
/// 设置代理信息
/// </summary>
/// <param name="webRequest">httpWebRequest</param>
/// <param name="request">request</param>
private static void SetProxy(WebRequest webRequest, Request request)
{
if (request.Proxy != null)
{
webRequest.Proxy = request.Proxy;
}
}

/// <summary>
/// 设置请求证书
/// </summary>
/// <param name="webRequest">httpWebRequest</param>
/// <param name="request">request</param>
private static void SetCertificate(HttpWebRequest webRequest, Request request)
{
if (request.Certificate != null)
{
try
{
webRequest.ClientCertificates.Add(new X509Certificate2(request.Certificate.CertFile, request.Certificate.CertPasswd, X509KeyStorageFlags.MachineKeySet));
}
catch (Exception)
{
X509Store store = new X509Store("My", StoreLocation.LocalMachine);
store.Open(OpenFlags.ReadOnly | OpenFlags.OpenExistingOnly);
X509Certificate2 cert = store.Certificates.Find(X509FindType.FindBySubjectName, request.Certificate.CertPasswd, false)[0];
webRequest.ClientCertificates.Add(cert);
}
}
}

/// <summary>
/// 设置请求参数信息
/// </summary>
/// <param name="webRequest">httpWebRequest</param>
/// <param name="request">request</param>
private static void SetParameters(WebRequest webRequest, Request request)
{
if (request.HttpMethod == HttpMethod.Post)
{
string parameters = GteParameters(request.Parameters);
byte[] bytes = request.Encoding.GetBytes(parameters);
webRequest.ContentType = "application/x-www-form-urlencoded";
webRequest.ContentLength = bytes.Length;
using (Stream requestStream = webRequest.GetRequestStream())
{
requestStream.Write(bytes, 0, bytes.Length);
}
}
}

/// <summary>
/// 数据流转换
/// </summary>
/// <param name="stream">数据流</param>
/// <returns>字节数组</returns>
private static byte[] StreamToBytes(Stream stream)
{
List<byte> bytes = new List<byte>();
int temp = stream.ReadByte();
while (temp != -1)
{
bytes.Add((byte)temp);
temp = stream.ReadByte();
}

return bytes.ToArray();
}
}
}

对应请求的内容处理

返回的内容可能是 超文本内容 或者 是图片等

/// <summary>
/// The http request html.
/// </summary>
public class HttpRequestService
{
/// <summary>
/// 获取一个文本内容
/// </summary>
/// <param name="request">
/// 请求信息
/// </param>
/// <returns>
/// 结果
/// </returns>
public static string GetHttpRequest(Request request)
{
try
{
var stream = HttpRequestUtility.GetStream(request);
using (StreamReader sr = new StreamReader(stream, request.Encoding))
{
StringBuilder builder = new StringBuilder();
while (sr.Peek() != -1)
{
builder.Append(sr.ReadLine());
}

return builder.ToString();
}
}
catch (System.Exception)
{
return null;
}
}

/// <summary>
/// 获取一张图片
/// </summary>
/// <param name="request">请求信息</param>
/// <returns>图片</returns>
public static Bitmap GetImage(Request request)
{
Bitmap map = null;
Stream stream = null;
try
{
stream = HttpRequestUtility.GetStream(request);
byte[] buf = new byte[stream.Length];
stream.Read(buf, 0, (int)stream.Length);
map = new Bitmap(System.Drawing.Image.FromStream(stream));
return map;
}
catch (System.Exception)
{
return null;
}
finally
{
if (stream != null)
{
stream.Close();
}

if (map != null)
{
map.Dispose();
}
}
}
}

4.5处理方法