Asp.net异步IHttpAsyncHandler示例

/// <summary>
    /// 异步IHttpHandler,实现了一个简单的统计流量的功能，
    /// 由于是示例代码，所以没有判断IP或者MAC
    /// </summary>
    public class Handler1 : IHttpAsyncHandler
    {
        //默认访问量是0
        static int visitCount = 0;
        /// <summary>
        /// 这个HttpHandler的同步方法
        /// </summary>

        /// <param name="context"></param>
        public void ProcessRequest(HttpContext context)
        {
        }

        public bool IsReusable
        {
            get
            {
                return false;
            }
        }

        /// <summary>
        /// 实现IHttpAsyncHandler 接口方法
        /// </summary>
        /// <param name="context">当前HttpContext</param>
        /// <param name="cb">回调函数</param>
        /// <param name="extraData"></param>
        /// <returns></returns>
        public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
        {
            //这里可以加上判断IP或mac的方法
            visitCount++;
            //实例化AsyncUserVisiteCounterResult对象
            AsyncUserVisiteCounterResult result = new AsyncUserVisiteCounterResult(cb, visitCount, context);
            result.Display();
            return result;
        }

       /// <summary>
        ///  结束本次IHttpAsyncHandler工作时触发的request方法
       /// </summary>
       /// <param name="result"></param>
        public void EndProcessRequest(IAsyncResult result)
        {
          
        }
    }

    /// <summary>
    /// 自定义IAsyncResult 实现我们额外的Display方法
    /// </summary>
    public class AsyncUserVisiteCounterResult : IAsyncResult
    {
        //回调参数
        private object _param;
        //是否异步执行完成
        private bool _asyncIsComplete;
        //回调方法
        private AsyncCallback _callBack;
        //当前上下文
        private HttpContext _context;

        public AsyncUserVisiteCounterResult(AsyncCallback callBack, object stateParam, HttpContext context)
        {
            this._callBack = callBack;
            this._param = stateParam;
            _asyncIsComplete = false;
            this._context = context;
        }


        public object AsyncState
        {
            get { return this._param; }
        }

        /// <summary>
        /// 等待句柄用于同步功能，关于等待句柄会在后续章节陈述
/// </summary>
        public System.Threading.WaitHandle AsyncWaitHandle
        {
            get
            {
                return null;
            }
        }

        /// <summary>
        /// 该属性表示不需要异步任务同步完成
        /// </summary>
        public bool CompletedSynchronously
        {
            get { return false; }
        }
        /// <summary>
        /// 该属性表示异步任务是否已经执行完成
        /// </summary>
        public bool IsCompleted
        {
            get
            {
                return this._asyncIsComplete;
            }
        }

        /// <summary>
        /// 自定义的额外功能,需要注意的是，执行完异步功能后
        /// 要将_asyncIsComplete设置为true表示任务执行完毕而且
        /// 执行回调方法，否则异步工作无法结束页面会卡死
        /// </summary>
        public void Display()
        {
            //这里先不用waitHandle句柄来实现同步
            lock (this)
            {
                this._context.Response.Write("你是第" + (int)this._param + "位访问者，访问时间:"+DateTime.Now.ToString());
                this._asyncIsComplete = true;
                this._callBack(this);
            }
        }



    }

 实例2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Threading;
namespace Comet_Handler
{
    /// <summary>
    /// Handler2 的摘要说明
    /// </summary>
    public class  Handler2 : IHttpAsyncHandler 
    {
  Func<int> f =() =>
        {
            Thread.Sleep(5000);
            int sum = 0;
            for (int i = 1; i <= 100; i++)
            {
                sum += i;
            }
            return sum;
        };

        public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
        {
            context.Response.ContentType = "text/plain";
            IAsyncResult areault = f.BeginInvoke(cb, context);
            return areault;
        }

        public void EndProcessRequest(IAsyncResult result)
        {
            var context = result.AsyncState as HttpContext;
            context.Response.Write(f.EndInvoke(result));
        }

        public bool IsReusable
        {
            get { throw new NotImplementedException(); }
        }

        public void ProcessRequest(HttpContext context)
        {
            throw new NotImplementedException();
        }
    } 
}

 实例三

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Threading;
namespace Comet_Handler
{
    /// <summary>
    /// Handler2 的摘要说明
    /// </summary>
    public class  Handler2 : IHttpAsyncHandler 
    {


        public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
        {
            context.Response.ContentType = "text/plain";
            AsyncOperation areault = new AsyncOperation(context,cb, extraData);
            areault.StartAsyncWork();
            return areault;
        }

        public void EndProcessRequest(IAsyncResult result)
        {
           // AsyncOperation res = (AsyncOperation)result;

            //var context = result.AsyncState as HttpContext;
            //context.Response.Write(f.EndInvoke(result));
        }

        public bool IsReusable
        {
            get { throw new NotImplementedException(); }
        }

        public void ProcessRequest(HttpContext context)
        {
            throw new NotImplementedException();
        }
    }
    public class AsyncOperation : IAsyncResult
    {
        HttpContext _context; //保存context的引用 
        AsyncCallback _cb;//保存回调委托的引用 
        object _state;//保存额外的信息 
        bool _iscomplate;//保存异步操作是否完成 


        /// <summary> 
        /// 构造函数，将AsyncHttpHandler的参数全部传递进来 
        /// </summary> 
        /// <param name="context"></param> 
        /// <param name="cb"></param> //该回调不可被重写，否则将会出现客户端永久等待的状态 
        /// <param name="state"></param> //构造时该值可以传递任意自己需要的数据 
        public AsyncOperation(HttpContext context, AsyncCallback cb, object state)
        {
            _context = context;
            _cb = cb;
            _state = state;
            _iscomplate = false; //表明当前异步操作未完成 
        }

        /// <summary> 
        /// 实现获得当前异步处理的状态 
        /// </summary> 
        bool IAsyncResult.IsCompleted
        {
            get
            {
                return _iscomplate;
            }
        }

        /// <summary> 
        /// 返回 false 即可 
        /// </summary> 
        bool IAsyncResult.CompletedSynchronously
        {
            get
            {
                return false;
            }
        }

        /// <summary> 
        /// 将返回额外的信息 
        /// </summary> 
        object IAsyncResult.AsyncState
        {
            get
            {
                return _state;
            }
        }

        /// <summary> 
        /// 为空 
        /// </summary> 
        WaitHandle IAsyncResult.AsyncWaitHandle
        {
            get
            {
                return null;
            }
        }
        public void send(string str)
        {
            _context.Response.Write(str);
        }
        /// <summary> 
        /// 表明开始异步处理的主函数（方法名可以改，但上面的调用也需要一起改） 
        /// </summary> 
        public void StartAsyncWork()
        {
            ThreadPool.QueueUserWorkItem(new WaitCallback(StartAsyncTask), null);//相信很多玩国.net winform 开发的一定认识 
        }

        private void StartAsyncTask(Object workItemState)
        {
            lock (this)
            {
                Thread.Sleep(5000);
                int sum = 0;
                for (int i = 1; i <= 100; i++)
                {
                    sum += i;
                }
                _context.Response.Write(sum.ToString());

                _iscomplate = true;
                _cb(this);
            }
        }

    }
}