HttpWebRequest 的异步封装

最新推荐文章于 2023-08-31 10:07:04 发布
最新推荐文章于 2023-08-31 10:07:04 发布
阅读量3k 收藏 1
点赞数

在HttpWebRequest 的一个 异步封装 里面提到了对HttpWebRequest的异步封装，但是如果用户不断的创建实例，那么就会有很对实例在内存中，这样是不可取，于是乎我们创建一个对象池来来管理对象的使用。因此我们需要给对象添加一属性IsBusy来标记该对象向现在是否有任务。然后我们创建一个RequestFactory来管理对象。修改后的带代码：

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Data;
using System.Data.OleDb;
using System.Net;
using System.Xml;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;

namespace HttpRequest
{
    [Serializable]
    public class RequestInfo
    {
        public RequestInfo(string url)
        {
            Url = url;
            AllowAutoRedirect = true;
        }
        public string Url { private set; get; }
        public byte[] PostData { set; get; }
        public WebHeaderCollection Headers { set; get; }
        public bool AllowAutoRedirect { set; get; }
        public Dictionary<string, string> ExternalData { set; get; }
    }

    [Serializable]
    public class ResponseInfo
    {
        public RequestInfo RequestInfo { set; get; }
        public Stream ResponseContent { set; get; }
        public HttpStatusCode StatusCode { set; get; }
        public WebHeaderCollection Headers { set; get; }
        public string GetString(Encoding coding)
        {
            StringBuilder str = new StringBuilder();
            Stream sr = ResponseContent;
            sr.Seek(0, SeekOrigin.Begin);
            byte[] data = new byte[1024 * 1024];
            int readcount = sr.Read(data, 0, data.Length);
            while (readcount > 0)
            {
                str.Append(coding.GetString(data, 0, readcount));
                readcount = sr.Read(data, 0, data.Length);
            }
            return str.ToString();
        }
    }

    internal class StateObject
    {
        public byte[] Buffer { set; get; }
        public ResponseInfo ResponseInfo { set; get; }
        public Stream ReadStream { set; get; }
        public HttpWebRequest HttpWebRequest { set; get; }
        public Action<ResponseInfo> Action { set; get; }
        public bool IsBusy { set; get; }

    }

    public class RequestHttpWebRequest
    {
        static RequestHttpWebRequest()
        {
            ServicePointManager.DefaultConnectionLimit = 100;
        }
        public RequestHttpWebRequest()
        {
            ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
        }
        private bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
        {
            //直接确认，否则打不开  
            return true;
        }
        public void GetResponseAsync(RequestInfo info, Action<ResponseInfo> act)
        {
            HttpWebRequest webRequest;
            StateObject state;
            InitWebRequest(info, act, out webRequest, out state);
            try
            {
                if (info.PostData != null && info.PostData.Length > 0)
                {
                    webRequest.Method = "POST";
                    webRequest.ContentType = "application/x-www-form-urlencoded";
                    webRequest.BeginGetRequestStream(EndRequest, state);
                }
                else
                {
                    webRequest.BeginGetResponse(EndResponse, state);
                }

            }
            catch (Exception ex)
            {
                HandException(ex, state);
            }
        }
        void EndRequest(IAsyncResult ar)
        {
            StateObject state = ar.AsyncState as StateObject;
            try
            {
                HttpWebRequest webRequest = state.HttpWebRequest as HttpWebRequest;
                using (Stream stream = webRequest.EndGetRequestStream(ar))
                {
                    byte[] data = state.ResponseInfo.RequestInfo.PostData;
                    stream.Write(data, 0, data.Length);
                }
                webRequest.BeginGetResponse(EndResponse, state);

            }
            catch (Exception ex)
            {
                HandException(ex, state);
            }
        }
        void EndResponse(IAsyncResult ar)
        {
            StateObject state = ar.AsyncState as StateObject;
            try
            {
                HttpWebResponse webResponse = state.HttpWebRequest.EndGetResponse(ar) as HttpWebResponse;
                state.ResponseInfo.StatusCode = webResponse.StatusCode;
                state.ResponseInfo.Headers = new WebHeaderCollection();
                foreach (string key in webResponse.Headers.AllKeys)
                {
                    state.ResponseInfo.Headers.Add(key, webResponse.Headers[key]);
                }
                state.ReadStream = webResponse.GetResponseStream();
                state.ReadStream.BeginRead(state.Buffer, 0, state.Buffer.Length, ReadCallBack, state);
            }
            catch (Exception ex)
            {
                HandException(ex, state);

            }
        }
        void ReadCallBack(IAsyncResult ar)
        {
            StateObject state = ar.AsyncState as StateObject;
            try
            {
                int read = state.ReadStream.EndRead(ar);
                if (read > 0)
                {
                    state.ResponseInfo.ResponseContent.Write(state.Buffer, 0, read);
                    state.ReadStream.BeginRead(state.Buffer, 0, state.Buffer.Length, ReadCallBack, state);
                }
                else
                {
                    state.ReadStream.Close();
                    state.HttpWebRequest.Abort();
                    if (state.Action != null)
                    {
                        state.Action(state.ResponseInfo);
                    }
                    state.IsBusy = false;
                }
            }
            catch (Exception ex)
            {
                HandException(ex, state);
            }
        }
        private void InitWebRequest(RequestInfo info, Action<ResponseInfo> act, out HttpWebRequest webRequest, out StateObject state)
        {

            webRequest = HttpWebRequest.CreateDefault(new Uri(info.Url)) as HttpWebRequest;
            webRequest.KeepAlive = true;
            webRequest.AllowAutoRedirect = info.AllowAutoRedirect;
            if (info.Headers != null && info.Headers.Count > 0)
            {
                foreach (string key in info.Headers.Keys)
                {
                    webRequest.Headers.Add(key, info.Headers[key]);
                }
            }
            //webRequest.Proxy = WebProxy.GetDefaultProxy();
            //webRequest.Proxy.Credentials = CredentialCache.DefaultCredentials;  
            // webResponse.Headers.Get("Set-Cookie");
            state = new StateObject
            {
                Buffer = new byte[1024 * 1024],
                HttpWebRequest = webRequest,
                Action = act,
                IsBusy = true,
                ResponseInfo = new ResponseInfo
                {
                    RequestInfo = info,
                    ResponseContent = new MemoryStream()
                }
            };
        }
        StateObject State { set; get; }
        public bool IsBusy
        {
            get
            {
                if (State != null)
                    return State.IsBusy;
                return false;
            }
        }
        private void HandException(Exception ex, StateObject state)
        {
            string message = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " : " + state.ResponseInfo.RequestInfo.Url + " : " + ex.Message;
            Console.WriteLine(message);
            //LogManager.LogException(message);
        }
    }
}
View Code 
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace HttpRequest
{
    public  class RequestFactory
    {
        static RequestFactory()
        {
            MaxRequestCount = 10;
            ThreadPool.QueueUserWorkItem(new WaitCallback(Process));
        }
        class RequestTask
        {
            public RequestInfo Request { set; get; }
            public Action<ResponseInfo> Action { set; get; }
        }

        static List<RequestTask> requestTask = new List<RequestTask>();
        static readonly object Lockobj = new object();
        static List<RequestHttpWebRequest> Handlers = new List<RequestHttpWebRequest>();

        public static void AddRequestTask(RequestInfo info, Action<ResponseInfo> act)
        {
            if (!string.IsNullOrEmpty(info.Url))
            {
                lock (Lockobj)
                {
                    requestTask.Add(new RequestTask() { Request = info, Action = act });
                }
            }
        }

        private static RequestHttpWebRequest GetAvailableHttpRequest()
        {
            RequestHttpWebRequest handler = null;
            for (int i = 0; i < Handlers.Count; i++)
            {
                if (!Handlers[i].IsBusy)
                {
                    handler = Handlers[i];
                    break;
                }
            }
            if (handler != null)
                return handler;
            if (Handlers.Count < MaxRequestCount)
            {
                handler = new RequestHttpWebRequest();
                lock (Lockobj)
                {
                    Handlers.Add(handler);
                }
                return handler;
            }
            Thread.Sleep(100);
            return GetAvailableHttpRequest();
        }

        private static RequestTask GetTask()
        {
            RequestTask task = null;
            if (requestTask.Count > 0)
            {
                lock (Lockobj)
                {
                    task = requestTask[0];
                    requestTask.RemoveAt(0);
                }
                return task;
            }
            else if (Closed)
            {
                return null;
            }
            else
            {
                Thread.Sleep(10);
                while (task == null)
                {
                    return GetTask();
                }

            }
            return task;
        }

        private static void Process(object obj)
        {
            while (!Closed || requestTask.Count > 0)
            {
                RequestHttpWebRequest handler = GetAvailableHttpRequest();
                RequestTask task = GetTask();
                if (task != null && handler != null)
                {
                    handler.GetResponseAsync(task.Request, task.Action);
                }
            }
            Thread.Sleep(10);
        }

        static int MaxRequestCount { set; get; }
        static bool Closed { set; get; }

    }
}
View Code

当然调用代码页非常简单：

   RequestInfo info = new RequestInfo("http://www.baidu.com/");
            Action<ResponseInfo> act=new Action<ResponseInfo>(x=>{
            Console.Write(x.GetString(Encoding.UTF8));
            });
            RequestFactory.AddRequestTask(info, act);

当然实际上应该把该程序部署成windows服务，他需要一直运行。

实际应该把

 static RequestFactory()
        {
            MaxRequestCount = 10;
            ThreadPool.QueueUserWorkItem(new WaitCallback(Process));
        }

抽取出来，这里只是演示，才把它放到构造函数里面。

有不对的地方还请大家拍砖！

 


<script type="text/javascript"> </script><script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js"></script>
Jlins
关注
C# HttpWebRequest人异步访问
雪后残阳
07-25 2035
----------------------------Un Test-------------------------using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Net;using System.Threading;using System.IO;na
如何对HttpWebRequest异步调用？
weixin_34261415的博客
07-27 264
    public static ManualResetEvent allDone = new ManualResetEvent(false);         static void Main(string[] args)         {                       HttpWebRequest request = (HttpWebRequest)WebRequest...
HttpWebRequest 的一个 异步封装
weixin_33841722的博客
04-28 180
相信大家对HttpWebRequest这个类应该非常熟悉了吧。主要用它来模拟http请求，在有些时候我们需要用到它的异步处理，每次用的时候都要写很多代码，于是今天把它简单的封装了一下。虽然在C#4和C#5中它提供了很新方法是的异步更加简单，但是在一些老项目（还在用vs2005）上我们只能用C#2.0的语法来实现它的异步功能。 如图1，这里的RequestInfo类是请求信息的一个封装，Respo...
httpwebrequest异步参考
weixin_34185512的博客
01-08 860
http://www.cnblogs.com/SanMaoSpace/archive/2011/07/27/2118133.html http://www.cnblogs.com/qianlifeng/archive/2010/04/23/1718343.html http://www.cnblogs.com/SanMaoSpace/archive/2011/07/27/2118128.htm...
C# HttpWebRequest 异步请求
热门推荐
JH_Wiki的专栏
10-28 1万+
异步请求：//定义委托 public delegate void Asyncdelegate(WebProxy objName); //异步调用完成时，执行回调方法 private void CallbackMethod(IAsyncResult ar) { Asyncdelegate dlgt = (Asyncdelegate)ar.AsyncState; dlgt.EndInvoke(a
C#基于HttpWebRequest实现发送HTTP请求的方法分析
08-26
HttpWebRequest httpWebRequest = (HttpWebRequest)HttpWebRequest.Create(url); httpWebRequest.Method = "GET"; httpWebRequest.Timeout = 20000; using (HttpWebResponse httpWebResponse = ...
C#使用HttpListener实现异步监听的demo
10-14
HttpListener、HttpWebRequest的应用，包括如何解析POST请求中Body的数据（multipart/form-data）、如何构造multipart/form-data; boundary=的ContentType等技巧
C#(Csharp)多线程HTTP并发请求(HttpWebRequest)采集蜘蛛
12-30
2. **HTTP请求与响应**：C#提供的HttpWebRequest和HttpWebResponse类提供了对HTTP协议的封装，使得我们能够方便地发起HTTP请求并接收响应。在C#中，可以利用这两个类实现异步请求，以并发方式下载多个URL资源，从而...
完成OSS.Http底层HttpClient重构封装 支持标准库
08-31
相较于旧的HttpWebRequest，HttpClient更适合现代的异步编程模型，并全面支持.NET Standard库，使得它能在多种.NET平台上运行，包括.NET Core、UWP等。 在HttpClient的设计中，有四个核心类： 1. **...
HttpTest操作HttpWebRequest
11-20
例如，可以使用`HttpWebResponse`的`GetResponseStream()`方法读取响应内容，或者通过`HttpWebRequest`的`BeginGetResponse()`和`EndGetResponse()`方法实现异步请求。 总的来说，`HttpWebRequest`是.NET Framework...
使用HttpWebRequest的POST取得网页内容(异步操作)2篇集合
Zfrong繁荣的IT技术、IT项目、解决方案专栏Blog-上海
01-09 8637
上次说了，如何通过post来取得网页内容。可是有一个问题出现了。当时用的方法是同步操作，如果我其中的一个IP或是在进行转化的过程中，出现了问题，哪么这个程序就会停下来，当然了，有的朋友可能会说，用try...catch也可以啊。因为我是循环取值，所以在catch里加一个continue就行了。可是以前没有搞过异步操作，所以想用这个机会搞一下。就看了一下。这一看不要紧，搞得我一头雾水。上网上
.Net(c#)模拟Http请求之HttpWebRequest封装
weixin_34376986的博客
01-15 722
一、需求： 　　向某个服务发起请求获取数据，如：爬虫，采集。 二、步骤（HttpWebRequest)： 无非在客户端Client（即程序）设置请求报文（如：Method,Content-Type,Agent,Cookie以及请求参数等信息）向服务端Server发送请求，服务端响应数据。 三、源码简介： ①.HttpUtil类:HttpWebRequest封装的核心 ②.Htt...
如何对HttpWebRequest和HttpWebRsponse异步调用？
weixin_34008933的博客
07-27 74
public void Post(string url) {   HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);             req.Method = "POST";             req.KeepAlive = true;             req.Timeout = 300000; ...
Unity C# 之 使用 HttpWebRequest 基础知识/HttpWebRequest 进行异步Post 网络访问/数据流形式获取数据(Task/async/await)的代码简单实现
最新发布
仙魁XAN
08-31 6606
可以使用 UnityWebRequest 访问，不过好似只能用协程的方式，并且访问只能在主线程中；所以这里使用 C# 中的 HttpWebRequest，进行网络访问，而且 HttpWebRequest，允许在子线程中访问，在一些情况下可以大大减少主线程的网络访问压力；这里使用 HttpWebRequest ，进行 Post 访问，并且Task 结合 async （await） 的进行异步访问，最后使用 Stream 流式的形式获取数据，在这里做一个简单的记录，以便后期使用的时候参考。
httpwebrequest java_HttpWebRequest 的一个 异步封装
weixin_35650074的博客
02-16 521
相信大家对HttpWebRequest这个类应该非常熟悉了吧。主要用它来模拟http请求，在有些时候我们需要用到它的异步处理，每次用的时候都要写很多代码，于是今天把它简单的封装了一下。虽然在C#4和C#5中它提供了很新方法是的异步更加简单，但是在一些老项目(还在用vs2005)上我们只能用C#2.0的语法来实现它的异步功能。如图1，这里的RequestInfo类是请求信息的一个封装，Respons...
ajax中同步和异步的区别
一身都是月
06-18 1073
Web请求中同步与异步的区别 2010-12-15 普通的B/S模式就是同步，而AJAX技术就是异步，当然XMLHttpReques有同步的选项。 同步：提交请求->等待服务器处理->处理完毕返回。这个期间客户端浏览器不能干任何事。 异步: 请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕。 举个生动的例子吧： 同步就是你叫我去吃饭
WebRequest实现异步页面请求
windflow的专栏
01-22 2914
WebRequest类的另一个特性就是可以异步请求页面。由于在给主机发送请求到接收响应之间有很长的延迟，因此，异步请求页面就显得比较重要。像WebClient.DownloadData()和WebRequest.GetResponse()等方法，在响应没有从服务器回来之前，是不会返回的。如果不希望在那段时间中应用程序处于等待状态，可以使用BeginGetResponse() 方法和 EndGetR
C#Web异步操作封装
weixin_33893473的博客
01-27 247
using System; using System.Collections.Generic; using System.Web; namespace HttpAsync { /// &lt;summary&gt; /// 封装web异步处理请求操作的方法 /// &lt;/summary&gt; public abstract class ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值