C# IOThread

在看微软的ASP.NET - 将 ASP.NET 用作高性能文件下载器 示例里面用到了IO 线程，以前打算自己撸的，这里贴出来 已标记一下：

////////////////////////////////////////////////////    // A delegate's BeginInvoke runs on a "worker thread" inside the CLR ThreadPool.    // This allows you to run a delegate on a "completion port thread" inside the CLR ThreadPool    // instead of a "worker thread" by calling IOBeginInvoke instead of BeginInvoke.    // In a nut shell, this mechanism basically skips the actual system I/O and simply posts a    // completion delegate to the completion port queue so the completion delegate will be     // executed by a "completion port thread" that is working the completion port queue.    //    // Example:    // delegate.BeginInvoke => executes delegate on "worker thread".    // delegate.IOBeginInvoke => executes delegate on "completion port thread".    //     //    // Extremely simplified explanation:    //    // CLR ThreadPool is made up of two pools of threads: "worker threads" and "completion port threads".    //    // Basically you can either queue a user work item which runs the delegate on a "worker thread",    // or queue a native overlapped item which runs the completion delegate on a "completion port thread".    // ThreadPool.QueueUserWorkItem (and delegate.BeginInvoke) => executes delegate on "worker thread".    // ThreadPool.UnsafeQueueNativeOverlapped => executes completion delegate on "completion port thread".    //    //             (CLR ThreadPool)    //               /        \    // [worker threads]      [completion port threads]    //    //  o o  oo  o  oo                    _____________post to queue using ThreadPool.UnsafeQueueNativeOverlapped    //    o o oo o  o                    |             (i.e. PostQueuedCompletionStatus)    //   o  o o  o o                     v    //  oo o  oo  o o                  |  |    //    o  oo oo o                   |  | <----------completion port queue (one per process)    //                                 |__|    //       ^                         oo o    //       |                        o o oo <---------completion port threads (work the completion port queue)    //       |                 (cpu)(cpu)(cpu)(cpu)                            (i.e. GetQueuedCompletionStatus in loop)    //       |                                   //       |                               ^    //       |                               |    //       |                               |    //       |                               |    //       |                               |    //       |    Each individual completion delegate is given to the completion port queue to execute,    //       |    and the "completion port threads" working the completion port queue execute the delegate.    //       |    (This has much less risk of thread explosion because each delegate just gets posted to the    //       |     completion port queue, instead of being given to its own individual thread. Basically    //       |     the queue grows, not the threads.)    //       |    //       |    The completion delegate is supplied in the overlapped structure that is posted to the    //       |    completion port queue.    //       |    //       |    Posting to queue (PostQueuedCompletionStatus) => done by ThreadPool.UnsafeQueueNativeOverlapped.    //       |    Working queue (GetQueuedCompletionStatus in loop) => done by "completion port thread" working queue.    //       |    //       |    // Each individual delegate is given to its own individual "worker thread" to execute,    // and the OS schedules the "worker thread" to run on a cpu.    // (This has the risk of thread explosion because each new delegate executes on its own    //  individual "worker thread". If the number of threads grows to large the entire OS can    //  grind to a hault, with all the memory used and the cpu's spending all their time    //  just trying to schedule the threads to run but not actually doing any work.)    //    ////////////////////////////////////////////////////    public static class IOThread    {        public delegate void ProcessRequestDelegate(HttpContext context);        public class IOAsyncResult : IAsyncResult        {            public object AsyncState { get; set; }            public WaitHandle AsyncWaitHandle { get; set; }            public Delegate AsyncDelegate { get; set; }            public bool CompletedSynchronously { get; set; }            public bool IsCompleted { get; set; }            public Exception Exception { get; set; }        }        unsafe public static IAsyncResult IOBeginInvoke(this ProcessRequestDelegate value, HttpContext context, AsyncCallback callback, object data)        {            ManualResetEvent evt = new ManualResetEvent(false);            IOAsyncResult ar = new IOAsyncResult();            ar.AsyncState = new object[] { context, callback, data };            ar.AsyncDelegate = value;            ar.AsyncWaitHandle = evt;            Overlapped o = new Overlapped(0, 0, IntPtr.Zero, ar);            NativeOverlapped* no = o.Pack(new IOCompletionCallback(ProcessRequestCompletionCallback), data);            ThreadPool.UnsafeQueueNativeOverlapped(no);            return ar;        }        unsafe private static void ProcessRequestCompletionCallback(uint errorCode, uint numBytes, NativeOverlapped* no)        {            try            {                Overlapped o = Overlapped.Unpack(no);                ProcessRequestDelegate d = (ProcessRequestDelegate)((IOAsyncResult)o.AsyncResult).AsyncDelegate;                object[] state = (object[])o.AsyncResult.AsyncState;                HttpContext context = (HttpContext)state[0];                AsyncCallback callback = (AsyncCallback)state[1];                object data = state[2];                try                {                    d(context);                }                catch(Exception ex)                {                    ((IOAsyncResult)o.AsyncResult).Exception = ex;                }                ((IOAsyncResult)o.AsyncResult).IsCompleted = true;                ((ManualResetEvent)o.AsyncResult.AsyncWaitHandle).Set();                if (callback != null)                    callback(o.AsyncResult);            }            finally            {                Overlapped.Free(no);            }        }        unsafe public static void IOEndInvoke(this ProcessRequestDelegate value, IAsyncResult result)        {            IOAsyncResult ar = (IOAsyncResult)result;            ar.AsyncWaitHandle.WaitOne(Timeout.Infinite);            if (ar.Exception != null)                throw ar.Exception;        }    }

使用示例：

  ////////////////////////////////////////////////////    // Example URLs to call download handler and download a file:    //    //    https://localhost/DownloadPortal/Download?file=file.txt    //    https://localhost/DownloadPortal/Download?file=file.txt&chunksize=1000000    //    https://localhost/DownloadPortal/Download?file=customer1/file.txt    //    https://localhost/DownloadPortal/Download?file=customer1/file.txt&chunksize=1000000    //    //    Important!!!  Must replace 'localhost' in URL with actual machine name or SSL certificate will fail.    //    //    Can either include the 'Range' HTTP request header in the HTTP web request OR    //    supply the 'chunksize' parameter in the URL. If include the 'Range' HTTP request header,    //    it will transmit back that portion of the file identified by the 'Range'. If supply the    //    'chunksize' parameter, it will transmit back the entire file in separate pieces the size of    //    'chunksize'. If supply both, 'Range' will be used. If supply neither, it will transmit back    //    the entire file in one piece.    //    // Web.config on IIS 7.0:    //    <system.webServer>    //      <handlers>    //        <add name="Download" verb="*" path="Download" type="DownloadHandlers.DownloadHandler" />    //      </handlers>    //    </system.webServer>    //    // Put DownloadHandler.dll and IOThreads.dll in the /bin directory of the virtual directory on IIS.    //    // Put files to be downloaded into virtual directory or sub directory under virtual directory.    //    // To debug:    //    Debug \ Attach to Process \ w3wp.exe    //    // Note: Make sure the IIS virtual directory is using an AppPool that is using .NET Framework 4.0.    //       Define a new AppPool using .NET Framework 4.0, if no other AppPool exists that is using .NET Framework 4.0.    ////////////////////////////////////////////////////    public class DownloadHandler : IHttpAsyncHandler    {        public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)        {            //Offloads to "completion port threads" inside CLR ThreadPool            //instead of "worker threads" inside CLR ThreadPool, so that our            //work doesn't use up the "worker threads" that are needed for the            //IIS server's request processing. (see comment section at top of            //IOThread class for more details)            IOThread.ProcessRequestDelegate d = ProcessRequest;            return d.IOBeginInvoke(context, cb, extraData);        }        public void EndProcessRequest(IAsyncResult result)        {            IOThread.IOAsyncResult ar = (IOThread.IOAsyncResult)result;            IOThread.ProcessRequestDelegate d = (IOThread.ProcessRequestDelegate)ar.AsyncDelegate;            d.IOEndInvoke(result);        }        public void ProcessRequest(HttpContext context)        {            try            {                string file = context.Request.QueryString["File"];                if (string.IsNullOrEmpty(file))                    throw new Exception("Must specify file in query string.  (Example: Download?File=your file)");                string fileName = Path.GetFileName(file);                if (string.IsNullOrEmpty(fileName))                    throw new Exception("File name '" + fileName + "' is not valid.");                long chunkSize = 0;                if (!string.IsNullOrEmpty(context.Request.QueryString["ChunkSize"]))                    if (context.Request.QueryString["ChunkSize"].Trim().Length > 0)                        chunkSize = long.Parse(context.Request.QueryString["ChunkSize"]);                FileInfo fi = new FileInfo(context.Server.MapPath(file));                long fileLength = fi.Length;                if (chunkSize > 0 && chunkSize > fileLength)                    throw new Exception("ChunkSize is greater than file length.");                context.Response.ClearHeaders();                context.Response.ClearContent();                context.Response.Clear();                //request is just checking file length                if (context.Request.HttpMethod == "HEAD")                {                    context.Response.AddHeader("content-length", fileLength.ToString());                    context.Response.AddHeader("accept-ranges", "bytes");                    context.Response.Flush();                    return;                }                                //file save                context.Response.ContentEncoding = Encoding.UTF8;                context.Response.AddHeader("content-disposition", "attachment;filename=\"" + fileName + "\"");                //context.Response.AddHeader("content-disposition", "attachment;filename=\"" + HttpUtility.UrlEncode(fileName) + "\"");                context.Response.ContentType = "application/octet-stream";                context.Response.AddHeader("cache-control", "no-store, no-cache");                context.Response.ExpiresAbsolute = DateTime.Now.Subtract(new TimeSpan(1, 0, 0, 0));                context.Response.Expires = -1;                context.Response.AddHeader("Connection", "Keep-Alive");                context.Response.AddHeader("accept-ranges", "bytes");                //request is for byte range                if (!string.IsNullOrEmpty(context.Request.Headers["Range"]) && context.Request.Headers["Range"].Trim().Length > 0)                {                    string range = context.Request.Headers["Range"];                    range = range.Replace(" ", "");                    string[] parts = range.Split(new char[] { '=', '-' });                    long contentLength = long.Parse(parts[2]) - long.Parse(parts[1]);                    context.Response.AddHeader("content-length", contentLength.ToString());                    string contentRange = string.Format("bytes {0}-{1}/{2}", parts[1], parts[2], fileLength.ToString());                    context.Response.AddHeader("content-range", contentRange);                    context.Response.AddHeader("last-modified", DateTime.Now.ToString("ddd, dd MMM yyyy hh:mm:ss") + " GMT");                    byte[] bytes = Encoding.ASCII.GetBytes(string.Format("{0} : {1}", fi.Name, fi.LastAccessTimeUtc));                    string eTag = Convert.ToBase64String(MD5CryptoServiceProvider.Create().ComputeHash(bytes));                    context.Response.AddHeader("ETag", string.Format("\"{0}\"", eTag));                    context.Response.StatusCode = 206;  //partial content                    context.Response.TransmitFile(file, long.Parse(parts[1]), contentLength);                    context.Response.Flush();                }                else  //request is not for byte range                {                    context.Response.AddHeader("content-length", fileLength.ToString());                    if (chunkSize <= 0)                    {                        context.Response.TransmitFile(file);                        context.Response.Flush();                    }                    else                    {                        long index = 0;                        while (true)                        {                            if (index >= fileLength)                                break;                            if (index < fileLength && index + chunkSize > fileLength)                            {                                context.Response.TransmitFile(file, index, fileLength - index);                                context.Response.Flush();                                break;                            }                            context.Response.TransmitFile(file, index, chunkSize);                            context.Response.Flush();                            index += chunkSize;                        }                    }                }            }            catch (Exception ex)            {                context.Response.ClearHeaders();                context.Response.ClearContent();                context.Response.Clear();                context.Response.StatusCode = 500;                context.Response.Write("Download Error:  " + ex.GetBaseException().Message);                context.Response.Flush();                //throw ex;            }            finally            {                context.Response.End();                //context.ApplicationInstance.CompleteRequest();            }        }        public bool IsReusable        {            get { return false; }        }    }