自己写Web服务器(续)

前几天写了篇有关写Web服务器的博文，写得不好，多亏园友们的意见，给了我继续探究的动力。这篇就关于上次做的Web服务器做了些更改。

　　1.支持ASPX页面的访问

多亏了园友的提点，使用了ApplicationHost类，使得宿主程序能够处理ASP.NET请求。后来上网搜了一下，原来就是写一个ASP.NET的宿主程序。上MSDN看了一下还不怎么明白，终究还是找了一些博文来看才明白。

ApplicationHost属于System.Web.Hosting命名空间，要使用这个类要添加System.Web.dll引用。先上一点代码再解释吧

             private AspxCreator _aspxHost;
            _aspxHost = (AspxCreator)ApplicationHost.CreateApplicationHost
                (typeof(AspxCreator), "/",
                AppDomain.CurrentDomain.BaseDirectory);

ApplicationHost通过调用CreateApplication方法构造一个Object的实例，这个实例实际上是AspxCreator类型的，CreateApplication方法有三个参数，第一个是AspxCreater的Type类型的对象，第二个是虚拟目录，一般是”/”，第三个是物理路径，这个参数跟配置在IIS配置网站是一样的。当初不明白的就是第一个参数，那个Type究竟是什么东西？其实它是一个自定义的类而已，不过这个类是继承MarshalByRefObject这个类的，通过aspx生成html的方法就定义在AspxCreater里面。还是看看AspxCreator的定义吧

    internal class AspxCreator:MarshalByRefObject
    {       
        public byte[] CreateAspxPage(string fileName,string qs)
        {
            byte[] datas=null;
            MemoryStream ms = null;
            StreamWriter sw = null;
            try
            {
                ms = new MemoryStream();
                sw = new StreamWriter(ms, Encoding.UTF8);
                sw.AutoFlush = true;
                HttpWorkerRequest worker = new ChineseRequest(fileName, qs, sw);
                HttpRuntime.ProcessRequest(worker);
                datas = new byte[ms.Length];
                ms.Position = 0;
                sw.BaseStream.Read(datas, 0, datas.Length);
            }
            catch (Exception e) 
            {
            
            }
            finally
            {
                if (sw != null)
                {
                    sw.Close();
                    sw.Dispose();
                    sw = null;
                }
                if (ms != null)
                {
                    ms.Close();
                    ms.Dispose();
                    ms = null;
                }
            }
            return datas;
        }
    }

整个类就定义了AspxCreator就只定义了一个方法，而在这个方法里，核心的就是这两行

                HttpWorkerRequest worker = new ChineseRequest(fileName, qs, sw);
                HttpRuntime.ProcessRequest(worker);

把一个aspx页面转成html，其余的都是流的操作。这里考虑到内容里头有中文就会造成乱码，就继承了一下SimpleWorkerRequest这个类，把里面的方法重写一下，改成UTF8的编码。使得伟大的中国方体字能正确的在浏览器中显示。

    internal class ChineseRequest:SimpleWorkerRequest
    {
        private TextWriter Output;
        public ChineseRequest(string fileName, string queryString, TextWriter textWirter)
            : base(fileName, queryString, textWirter)
        {
            Output = textWirter;
        }
        public override void SendResponseFromMemory(byte[] data, int length)
        {
            Output.Write(System.Text.Encoding.UTF8.GetChars(data, 0, length));
        }
    }

在浏览器发了一个ASP.NET请求时，利用之前构造的_aspxHost实例，调用CreateAspxPage方法，把相关的aspx页面转成html，通过byte[]返回回来，传到浏览器中去

                byte[] aspxHtml = _aspxHost.CreateAspxPage(requestFile, queryString);
                SendResponse(uid, aspxHtml, response);

结果如下图

生成成功之后，要在程序所在的目录下新建一个bin文件夹，把程序的一个副本放到bin文件夹里，这样程序才能正常运行。这样就可让aspx页面脱离IIS运行了。

　　2.对URL进行解码

这个问题是后来自己发现的。在发送请求的URL中，如果带有中文字符的时候，一律会自动转码的，转成一串又有百分号又有字母的字符串。如果服务器单纯用正则提取了请求的URL，不对其解码的话，后果不用我说都知道了吧，之前一直没考虑这方面的问题。

想改也不难，一行代码即可，调用System.Web.HttpUtility类的UrlDecode方法，就可以得到正常的中文字符了。在虚拟目录下的确有个 “我.htm”的文件

这里有几对编码/解码的方法。

UrlDecode和UrlEncode，用于URL的解码和编码

HtmlDecode和HtmlEncode用于对Html的解码和编码

而对于js，只有编码一个方法

　　3.稍提高了响应的速度

我之前也说过我这个Web服务器的速度要比IIS的慢，也有园友指出我的线程没处理好，对象构造了过多，但以我现时的水平我看不出有什么对象可以削减的。我最近也查阅过有关GC的文章和一些.NET性能优化的文章。其实找到要更改的地方不多，而且本人认为响应慢的原因是我的连接池的效率问题，故找问题都在连接池里找。

最后只找到了这个地方：在接收成功绑定的方法里头，每接收完一次数据之后，我都会调用两个方法

                    buffer.FreeBuffer(unit.RecArg);
                    buffer.SetBuffer(unit.RecArg);

 

作用分别是释放缓冲区和设置缓冲区，方法的内部机制是先清空缓冲区的数据，把缓冲区的偏移量放入空闲栈中供下次调用，然后马上又从栈把空闲的缓冲区取出来(方法的定义在在Socket连接池一文中有源码，本文底端也有源码)，这样的方法不是不好，但在这里调用先得不合适，反正都是继续用回那个缓冲区，干脆直接把缓冲区的内容清空了就可以了。

        /// <summary>
        /// 清除缓冲区里的数据
        /// </summary>
        internal void RefreshBuffer(SocketAsyncEventArgs e)
        {
            for (int i = e.Offset; i < e.Offset + bufferSize; i++)
            {
                if (buffers[i] == 0) break;
                buffers[i] = 0;
            }
        }

 

然后就调用了这个方法，不知是否这里的原因，经测试这个Web服务的速度不会比IIS慢一截了，有时还比IIS快。经过本地访问的测试和局域网内测试的结果图

　　4.信号量及阻塞

　　之前对信号量和各种实现互斥的方法不是太理解，某些地方使用互斥体和信号量没什么作用。现在更改过来了。

　　在开启服务和停止服务，一个服务开启了不能再开启的，要关闭了之后才能开启，所以这里我认为应该使用信号量才对。

        public void RunPool(string ipAddress, int port)
        {
            IPEndPoint endpoint = new IPEndPoint(IPAddress.Parse(ipAddress), port);
            server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            server.Bind(endpoint);
            server.Listen(100);

            //调用方法异步Accept客户端的连接
            MyAsyncAccept();
            //设置信号，防止再池在已经启动的情况下再次启动
            //mutex.WaitOne();
            semaphoreRun.WaitOne();
        }
        public void StopPool()
        {
            //把服务端的socket关了
            if (server != null)
                server.Close();
            //释放互斥信号，等待下次启动
            //mutex.ReleaseMutex();
            semaphoreRun.Release();
            //释放资源
            Dispose();
        }

 

　　此外，异步发送数据在发送成功之前不能再次发送别的数据，否则会抛异常，由于之前的程序在这个地方没有处理好，导致服务器在运行过程中会不稳定。但是如果这里用了信号量的话会导致整个服务器的数据发送只能以排着队逐条发送的形式进行发送，延长了响应时间，于是考虑使用Monitor。

        public void SendMessage(string uid, byte[] messageByteArray)
        {
            ConnectionUnit unit = pool.GetConnectionUnitByUID(uid); 

            if (unit == null)
            {
                if (OnSend != null) OnSend(uid, "100");
                return;
            }
            unit.SendArg.SetBuffer(messageByteArray, 0, messageByteArray.Length);
            unit.client.SendAsync(unit.SendArg);
            lock (uid)
            {
                Monitor.Wait(uid);
            }
        }

        void SendArg_Completed(object sender, SocketAsyncEventArgs e)
        {
            Socket client = sender as Socket;
            ConnectionUnit unit = e.UserToken as ConnectionUnit;
            //这里的消息码有三个，2字头的是成功的，1字头是不成功的
            //101是未知错误，100是客户端不在线
            lock (unit.Uid)
            {
                Monitor.Pulse(unit.Uid);
                if (e.SocketError == SocketError.Success)
                {
                    if (OnSend != null) OnSend(unit.Uid, "200");
                }
                else if (OnSend != null) OnSend(unit.Uid, "101");
                Monitor.Wait(unit.Uid, 1);
            }
        }

 

　　可是这回真发现这个服务器的性能与IIS有天渊之别了，在浏览器输入一个URL之后狂按F5，IIS的响应很快的，可我这个服务器的响应这个这堆请求显得力不从心，提高性能的办法还没想到，不过在这里同时也发现了另一个问题。

　　5.关闭连接

在狂按F5之后，服务器接收了不少连接，可是这些连接基本上是无效了，就只有最后的连接才是有效的。可是关闭连接的方法只会在接收数据的方法里调用，其实这样去回收空闲连接远远不够，经检查这样服务器中有大量未经回收的空闲连接，这样迟早会白白耗尽服务器的连接资源。因此每次异步方法调用之后都会进行一次判定，如果客户端已经断开了，就把连接关掉，回收。

我会继续探究，有新的改动会追加到本文中去。还请各位园友多给些意见，多指点一下。谢谢。下面则是Web服务器和连接池的最新源码

 

    /// <summary>
    /// 连接单元
    /// </summary>
    class ConnectionUnit:IDisposable
    {
        private string _uid;//单元的编号，默认为-1
        private bool _state;//单元的状态，true表示使用，false表示空闲
        private SocketAsyncEventArgs _sendArg;//专用于发送
        private SocketAsyncEventArgs _recArg;//专用于接收
        internal Socket client { get; set; }//客户端的socket实例
        internal List<byte> tempArray { get; set; }//暂存已接收的数据，避免粘包用的

        public string Uid
        {
            get { return _uid; }
            set { _uid = value; }
        }

        public ConnectionUnit(string UID)
        {
            _uid = UID;
            tempArray = new List<byte>();
        }

        public ConnectionUnit() : this("-1") { }

        public ConnectionUnit(int defaultSiez)
        {
            _uid = "-1";
            tempArray = new List<byte>(defaultSiez);
        }

        public bool State
        {
            get { return _state; }
            set { _state = value; }
        }

        public SocketAsyncEventArgs SendArg
        {
            get { return _sendArg; }
            set { _sendArg = value; }
        }

        public SocketAsyncEventArgs RecArg
        {
            get { return _recArg; }
            set { _recArg = value; }
        }

        public void Dispose()
        {
            if (_sendArg != null)
                _sendArg.Dispose();
            if (_recArg != null)
                _recArg.Dispose();

            _sendArg = null;
            _recArg = null;
        }
    }

    class BufferManager:IDisposable
    {
        private byte[] buffers;
        private int bufferSize;
        private int allSize;
        private int currentIndex;
        private Stack<int> freeIndexs;

        /// <summary>
        /// 构造缓存池
        /// </summary>
        /// <param name="buffersSize">池总大小</param>
        /// <param name="defaultSize">默认单元大小</param>
        internal BufferManager(int buffersSize, int defaultSize) 
        {
            this.bufferSize=defaultSize;
            this.allSize=buffersSize;
            currentIndex=0;
            this.buffers = new byte[allSize];
            freeIndexs = new Stack<int>(buffersSize/defaultSize);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        /// <param name="offSet"></param>
        /// <returns></returns>
        internal bool SetBuffer(SocketAsyncEventArgs e)
        {
            if (freeIndexs.Count > 0)
            {
                e.SetBuffer(buffers, freeIndexs.Pop(), bufferSize);
            }
            else
            {
                if ((allSize - currentIndex) < bufferSize) return false;
                e.SetBuffer(buffers, currentIndex, bufferSize);
                currentIndex += bufferSize;
            }
            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="e"></param>
        internal void FreeBuffer(SocketAsyncEventArgs e)
        {
            freeIndexs.Push(e.Offset);
            for (int i = e.Offset; i < e.Offset + bufferSize; i++)
            {
                if (buffers[i] == 0) break;
                buffers[i] = 0;
            }
            e.SetBuffer(null, 0, 0);
        }

        /// <summary>
        /// 清除缓冲区里的数据
        /// </summary>
        /// <param name="e"></param>
        internal void RefreshBuffer(SocketAsyncEventArgs e)
        {
            for (int i = e.Offset; i < e.Offset + bufferSize; i++)
            {
                if (buffers[i] == 0) break;
                buffers[i] = 0;
            }
        }

        public void Dispose()
        {
            buffers = null;
            freeIndexs = null;
        }
    }

    class SocketAsyncEventArgsPool:IDisposable
    {
        private Dictionary<string, ConnectionUnit> busyCollection;
        private Stack<ConnectionUnit> freeCollecton;

        internal SocketAsyncEventArgsPool(int maxConnect)
        {
            busyCollection = new Dictionary<string, ConnectionUnit>(maxConnect);
            freeCollecton = new Stack<ConnectionUnit>(maxConnect);
        }

        /// <summary>
        /// 取出
        /// </summary>
        internal ConnectionUnit Pop(string uid)
        {
            ConnectionUnit unit = freeCollecton.Pop();
            unit.State = true;
            unit.Uid = uid;
            busyCollection.Add(uid, unit);
            return unit;
        }

        /// <summary>
        /// 放回
        /// </summary>
        internal void Push(ConnectionUnit unit)
        {
            if (!string.IsNullOrEmpty(unit.Uid) && unit.Uid != "-1")
                busyCollection.Remove(unit.Uid);
            unit.Uid = "-1";
            unit.State = false;
            freeCollecton.Push(unit);
        }

        /// <summary>
        /// 获取
        /// </summary>
        internal ConnectionUnit GetConnectionUnitByUID(string uid)
        {
            if (busyCollection.ContainsKey(uid))
                return busyCollection[uid];
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        internal string[] GetOnLineList()
        {
            return busyCollection.Keys.ToArray();
        }

        public void Dispose()
        {
            foreach (KeyValuePair<string,ConnectionUnit> item in busyCollection)
                item.Value.Dispose();

            busyCollection.Clear();

            while (freeCollecton.Count > 0)
                freeCollecton.Pop().Dispose();
        }
    }

    public class SocketPoolController:IDisposable
    {

        #region 字段

        /// <summary>
        /// 初始化池的互斥体
        /// </summary>
        private Mutex mutex = new Mutex();

        /// <summary>
        /// Accept限制信号
        /// </summary>
        private Semaphore semaphoreAccept;

        /// <summary>
        /// Accept信号
        /// </summary>
        private static ManualResetEvent acceptLock = new ManualResetEvent(false);

        /// <summary>
        /// Send信号
        /// </summary>
        //private static ManualResetEvent sendLock = new ManualResetEvent(false);

        private Semaphore semaphoreRun;

        /// <summary>
        /// 最大并发数(连接数)
        /// </summary>
        private int maxConnect;

        /// <summary>
        /// 当前连接数(并发数)
        /// </summary>
        private int currentConnect;

        /// <summary>
        /// 缓冲区单元大小
        /// </summary>
        private int defaultSize;

        /// <summary>
        /// 缓冲池
        /// </summary>
        private BufferManager buffer;

        /// <summary>
        /// SocketasyncEventArgs池
        /// </summary>
        private SocketAsyncEventArgsPool pool;

        /// <summary>
        /// 服务端Socket
        /// </summary>
        private Socket server;

        /// <summary>
        /// 完成接受的委托
        /// </summary>
        public delegate void AcceptHandler(string uid);

        /// <summary>
        /// 完成发送的委托
        /// </summary>
        public delegate void SendHandler(string uid, string result);

        /// <summary>
        /// 完成接收的委托
        /// </summary>
        public delegate void RecevieHandler(string uid, string data);

        /// <summary>
        /// 完成接受事件
        /// </summary>
        public event AcceptHandler OnAccept;

        /// <summary>
        /// 完成发送事件
        /// </summary>
        public event SendHandler OnSend;

        /// <summary>
        /// 完成接收事件
        /// </summary>
        public event RecevieHandler OnReceive;

        #endregion

        #region 构造函数

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="buffersize">单元缓冲区大小</param>
        /// <param name="maxCount">并发总数</param>
        public SocketPoolController(int buffersize, int maxCount)
        {
            buffer = new BufferManager(buffersize * maxCount,buffersize);
            this.currentConnect = 0;
            this.maxConnect = maxCount;
            this.currentConnect = 0;
            this.defaultSize = buffersize;
            this.pool = new SocketAsyncEventArgsPool(maxConnect);
            //设置并发数信号，经试验过是并发数-1才对
            this.semaphoreAccept = new Semaphore(maxCount-1, maxCount-1);
            this.semaphoreRun = new Semaphore(1, 1);
            InitPool();
        }

        #endregion

        #region 公共方法

        /// <summary>
        /// 启动池
        /// </summary>
        /// <param name="ipAddress">服务端的IP</param>
        /// <param name="port">端口</param>
        public void RunPool(string ipAddress, int port)
        {
            IPEndPoint endpoint = new IPEndPoint(IPAddress.Parse(ipAddress), port);
            server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            server.Bind(endpoint);
            server.Listen(100);

            //调用方法异步Accept客户端的连接
            MyAsyncAccept();
            //设置信号，防止再池在已经启动的情况下再次启动
            //mutex.WaitOne();
            semaphoreRun.WaitOne();
        }

        /// <summary>
        /// 停止池
        /// </summary>
        public void StopPool()
        {
            //把服务端的socket关了
            if (server != null)
                server.Close();
            //释放互斥信号，等待下次启动
            //mutex.ReleaseMutex();
            semaphoreRun.Release();
            //释放资源
            Dispose();
        }

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="uid"></param>
        /// <param name="message"></param>
        public void SendMessage(string uid, string message)
        {
            //sendLock.Reset();
            //ConnectionUnit unit=pool.GetConnectionUnitByUID(uid);
            ////如果获取不了连接单元就不发送了，
            //if (unit == null)
            //{ 
            //    if(OnSend!=null) OnSend(uid,"100");
            //    sendLock.Set();
            //    return;
            //}
            //byte[] datas = Encoding.ASCII.GetBytes(message);
            //unit.SendArg.SetBuffer(datas, 0, datas.Length);
            //unit.client.SendAsync(unit.SendArg);
            ////阻塞当前线程，等到发送完成才释放
            //sendLock.WaitOne();
            byte[] datas = Encoding.ASCII.GetBytes(message);
            SendMessage(uid, datas);
        }

        public void SendMessage(string uid, byte[] messageByteArray)
        {
            //sendLock.Reset();
            ConnectionUnit unit = pool.GetConnectionUnitByUID(uid);
            //如果获取不了连接单元就不发送了，

            if (unit == null)
            {
                if (OnSend != null) OnSend(uid, "100");
                //sendLock.Set();
                return;
            }
            unit.SendArg.SetBuffer(messageByteArray, 0, messageByteArray.Length);
            bool sendResult= unit.client.SendAsync(unit.SendArg);
            if (!sendResult)
            {
                CloseSocket(unit);
                if (OnSend != null) OnSend(uid, "100");
                return;
            }
            //阻塞当前线程，等到发送完成才释放
            Console.WriteLine("wait--------------"+uid);
            //sendLock.WaitOne();
            lock (uid)
            {
                Monitor.Wait(uid);
            }
        }

        #endregion

        #region 异步事件回调

        void SendArg_Completed(object sender, SocketAsyncEventArgs e)
        {
            Socket client = sender as Socket;
            ConnectionUnit unit = e.UserToken as ConnectionUnit;
            //这里的消息码有三个，2字头的是成功的，1字头是不成功的
            //101是未知错误，100是客户端不在线
            lock (unit.Uid)
            {
                Monitor.Pulse(unit.Uid);
                if (e.SocketError == SocketError.Success)
                {
                    if (OnSend != null) OnSend(unit.Uid, "200");
                }
                else if (OnSend != null) OnSend(unit.Uid, "101");
                //释放信号，以便下次发送消息执行
                Console.WriteLine("set>>>>>>>" + unit.Uid);
                //sendLock.Set();
                Monitor.Wait(unit.Uid, 1);
            }
        }

        void RecArg_Completed(object sender, SocketAsyncEventArgs e)
        {
            bool recResult = true;
            Socket client = sender as Socket;
            ConnectionUnit unit = e.UserToken as ConnectionUnit;
            //这里大致与上一篇异步通信的一样，只是对缓冲区的处理有一点差异
            if (e.SocketError == SocketError.Success)
            {
                int rec = e.BytesTransferred;
                if (rec == 0)
                {
                    CloseSocket(unit);
                    return;
                }
                if (client.Available > 0)
                {
                    unit.tempArray.AddRange(e.Buffer);
                    //buffer.FreeBuffer(unit.RecArg);
                    //buffer.SetBuffer(unit.RecArg);
                    buffer.RefreshBuffer(unit.RecArg);
                    recResult = client.SendAsync(unit.RecArg);
                    if (!recResult) CloseSocket(unit);
                    return;
                }
                byte[] data = e.Buffer;
                int len = rec;
                int offset = e.Offset;
                if (unit.tempArray.Count != 0)
                {
                    foreach (byte item in data)
                    {
                        if (item == 0) break;
                        unit.tempArray.Add(item);
                    }
                    data = unit.tempArray.ToArray();
                    rec = data.Length;
                    offset = 0;
                    unit.tempArray.Clear();
                }

                string dataStr = Encoding.ASCII.GetString(data,offset,len);
                if (OnReceive != null)
                    OnReceive(unit.Uid, dataStr);

                if (!unit.State) return;
                //buffer.FreeBuffer(e);
                //buffer.SetBuffer(e);
                buffer.RefreshBuffer(e);
                recResult = client.ReceiveAsync(e);
                if (!recResult) CloseSocket(unit);
            }
            //这里还多个了一个关闭当前连接
            else
            {
                CloseSocket(unit);
            }
        }

        void Accept_Completed(object sender, SocketAsyncEventArgs e)
        {
            Socket client = e.AcceptSocket;
            try
            {
                if (client.Connected)
                {
                    IPEndPoint point = client.RemoteEndPoint as IPEndPoint;
                    string uid = point.Address + ":" + point.Port;
                    ConnectionUnit unit = pool.Pop(uid);
                    unit.client = client;
                    unit.State = true;
                    unit.Uid = uid;
                    unit.RecArg.UserToken = unit;
                    unit.SendArg.UserToken = unit;
                    buffer.SetBuffer(unit.RecArg);

                    //在接受成功之后就开始接收数据了
                    bool recResult = client.ReceiveAsync(unit.RecArg);
                    //设置并发限制信号和增加当前连接数
                    semaphoreAccept.WaitOne();
                    Interlocked.Increment(ref currentConnect);
                    if (!recResult)
                    {
                        CloseSocket(unit);
                        return;
                    }
                    if (OnAccept != null) OnAccept(uid);
                }
                else if (client != null)
                {
                    client.Close();
                    client.Dispose();
                    client = null;
                }
            }
            catch (Exception ex) { Console.WriteLine(ex.ToString()); }
            //设置Accept信号，以便下次Accept的执行
            acceptLock.Set();
            e.Dispose();
        }

        #endregion

        #region 内部辅助方法

        /// <summary>
        /// 初始化SocketAsyncEventArgs池
        /// 这里主要是给空闲栈填充足够的实例
        /// </summary>
        private void InitPool()
        {
            ConnectionUnit unit = null;
            for (int i = 0; i < maxConnect; i++)
            {
                unit = new ConnectionUnit(defaultSize);
                unit.Uid = "-1";
                unit.RecArg = new SocketAsyncEventArgs();
                unit.RecArg.Completed += new EventHandler<SocketAsyncEventArgs>(RecArg_Completed);
                unit.SendArg = new SocketAsyncEventArgs();
                unit.SendArg.Completed += new EventHandler<SocketAsyncEventArgs>(SendArg_Completed);
                this.pool.Push(unit);
            }
        }

        /// <summary>
        /// 异步Accept客户端的连接
        /// </summary>
        void MyAsyncAccept()
        {
            //这里使用Action的方式异步循环接受客户端的连接
            //模仿同事的做法没开线程，不知这种方式是好是坏
            Action callback = new Action(delegate()
            {
                while (true)
                {
                    //每次接受都要新开一个SocketAsyncEventArgs,否则会报错
                    //其实我也想重复利用的
                    SocketAsyncEventArgs e = new SocketAsyncEventArgs();
                    e.Completed += new EventHandler<SocketAsyncEventArgs>(Accept_Completed);
                    
                    acceptLock.Reset();
                    server.AcceptAsync(e);
                    //在异步接受完成之前阻塞当前线程
                    acceptLock.WaitOne();
                }
            });
            callback.BeginInvoke(null, null);
        }

        /// <summary>
        /// 关闭一个连接单元
        /// </summary>
        private void CloseSocket( ConnectionUnit unit )
        {
            //关闭并释放客户端socket的字眼
            if (unit.client != null)
            {
                unit.client.Shutdown(SocketShutdown.Both);
                unit.client.Dispose();
                unit.client = null;
            }
            //Console.WriteLine(unit.Uid+" disconnect ");
            //把连接放回连接池
            pool.Push(unit);
            //释放并发信号
            semaphoreAccept.Release();
            //减少当前连接数
            Interlocked.Decrement(ref currentConnect);
        }

        #endregion

        public void Dispose()
        {
            if (pool != null)
            {
                pool.Dispose();
                pool = null;
            }
            if (buffer != null)
            {
                buffer.Dispose();
                buffer = null;
            }
            if (server != null)
            {
                server.Dispose();
                server = null;
            }

        }
    }

 

    class RequestHeader
    {
        public string ActionName { get; set; }
        public string URL { get; set; }
        public string Host { get; set; }
        public string Accept { get; set; }
        public string Connection { get; set; }
        public string Accept_Language { get; set; }
        public string User_Agent { get; set; }
        public string Accept_Encoding { get; set; }

        public string Form { get; set; }
        public int Content_Length { get; set; }
        public string Referer { get; set; }
        public string Content_Type { get; set; }

        public static RequestHeader ConvertRequestHander(string headerStr)
        {
            string regActionName = "GET|POST";
            string regURL = "(?<=GET|POST).*?(?=HTTP/1.1)";
            string regHost = @"(?<=Host\:\s).*(?=\r\n)";
            string regAccept = @"(?<=Accept\:\s).*(?=\r\n)";
            string regConnection = @"(?<=Connection\:\s).*(?=\r\n)";
            string regAcceptLanguage = @"(?<=Accept-Language\:\s).*(?=\r\n)";
            string regUserAgent = @"(?<=User-Agent\:\s).*(?=\r\n)";
            string regAcceptEncoding = @"(?<=Accept-Encoding\:\s).*(?=\r\n)";

            string regForm = @"(?<=\r\n\r\n).*";
            string regConntenLength = @"(?<=Connten-Length\:\s).*(?=\r\n)";
            string regRefere = @"(?<=Refere\:\s).*(?=\r\n)";
            string regContentType = @"(?<=Content-Type\:\s).*(?=\r\n)";

            RequestHeader hander = new RequestHeader();
            hander.ActionName = Regex.Match(headerStr, regActionName).Value;
            hander.URL = Regex.Match(headerStr, regURL).Value;
            hander.URL = System.Web.HttpUtility.UrlDecode(hander.URL).Trim();
            hander.Host = Regex.Match(headerStr, regHost).Value;
            hander.Accept = Regex.Match(headerStr, regAccept).Value;
            hander.Connection = Regex.Match(headerStr, regConnection).Value;
            hander.Accept_Language = Regex.Match(headerStr, regAcceptLanguage).Value;
            hander.Accept_Encoding = Regex.Match(headerStr, regAcceptEncoding).Value;
            hander.User_Agent = Regex.Match(headerStr, regUserAgent).Value;
            string tempStr = Regex.Match(headerStr, regConntenLength).Value;
            hander.Content_Length = Convert.ToInt32(tempStr == "" ? "0" : tempStr);
            hander.Referer = Regex.Match(headerStr, regRefere).Value;
            hander.Content_Type = Regex.Match(headerStr, regContentType).Value;
            hander.Form = Regex.Match(headerStr, regForm).Value;
            return hander;
        }
    }

    class ResponseHeader
    {
        public string ResponseCode { get; set; }
        public string Server { get; set; }
        public int Content_Length { get; set; }
        public string Connection { get; set; }
        public string Content_Type { get; set; }

        public override string ToString()
        {
            string result = string.Empty;
            result += "HTTP/1.1 " + this.ResponseCode + "\r\n";
            result += "Server: "+this.Server+"\r\n";
            result += "Content-Length: " + this.Content_Length + "\r\n";
            result += "Connection: "+this.Connection+"\r\n";
            result += "Content-Type: " + this.Content_Type + "\r\n\r\n";
            return result;
        }

        public string CreateErrorHtml()
        {
            string html = @"<html><head><meta http-equiv=""Content-Type"" content=""text/html;charset=utf-8""></head><body>{0}</body></html>";
            html = html.Replace("{0}", "<h2>My Web Server</h2><div>{0}</div>");
            html = string.Format(html, this.ResponseCode);
            return html;
        }
    }

    public class ServerConfigEntity 
    {
        public string IP { get; set; }
        public int Port { get; set; }
        public int MaxConnect { get; set; }
        public string VirtualPath { get; set; }
        public string DefaultPage { get; set; }
    }

    public class HttpProtocolServer 
    {
        private SocketPoolController _pool;
        private Dictionary<string, string> _supportExtension;
        private ServerConfigEntity config;
        private bool _runFlag;
        private AspxCreator _aspxHost;

        public HttpProtocolServer(ServerConfigEntity config)
        {
            this.config = config;
            _pool = new SocketPoolController(32768, config.MaxConnect);
            _supportExtension = new Dictionary<string, string>() 
            {
                { "htm", "text/html" },
                { "html", "text/html" },
                { "xml", "text/xml" },
                { "txt", "text/plain" },
                { "css", "text/css" },
                { "png", "image/png" },
                { "gif", "image/gif" },
                { "jpg", "image/jpg" },
                { "jpeg", "image/jpeg" },
                { "zip", "application/zip"},
                {"js","text/javascript"},
                { "dll", "text/plain" },
                {"aspx","text/html"}
            };
            _aspxHost = (AspxCreator)ApplicationHost.CreateApplicationHost
                (typeof(AspxCreator), "/",
                AppDomain.CurrentDomain.BaseDirectory);
            _runFlag = false;
        }

        public void RunServer()
        {
            if (_runFlag) return;
            _pool.OnReceive += new SocketPoolController.RecevieHandler(HandleRequest);
            _pool.RunPool(config.IP, config.Port);
            _runFlag = true;
        }

        public void StopServer()
        {
            _pool.StopPool();
            _pool = null;
            _runFlag = false;
        }

        private void HandleRequest(string uid, string header)
        {
            RequestHeader request = RequestHeader.ConvertRequestHander(header);
            ResponseHeader response = new ResponseHeader();
            response.Server = "My Test WebSite";
            response.Connection = "close";

            //暂时只支持POST和GET的请求，其他的请求就视为未实现，发501响应
            if (request.ActionName != "GET" && request.ActionName != "POST")
            {
                response.ResponseCode = "501 Not Implemented";
                response.Content_Type = "text/html";
                SendErrorResponse(uid, response);
                return;
            }

            //对请求资源名称经行处理。主要是去除GET时带的参数，还有把斜杠换过来
            string fullURL = config.VirtualPath + request.URL;
            bool containQM=fullURL.Contains('?');
            string fileName =(containQM? Regex.Match(fullURL, @".*(?=\?)").Value:fullURL).Replace('/','\\');

            //如果请求的只是一个斜杠的，那证明请求的是默认页面
            if (fileName == fullURL + "\\")
            {
                //如果配置中有默认页的，发200的响应
                string defaultFile = Path.Combine(config.VirtualPath, config.DefaultPage);
                if (File.Exists(defaultFile))
                {
                    response.Content_Type = "text/html";
                    response.ResponseCode = "200 OK";
                    SendResponse(uid, File.ReadAllText(defaultFile), response);
                    return;
                }
                //如果不存在的，当404处理了
                else
                {
                    response.ResponseCode = "404 Not Found";
                    response.Content_Type = "text/html";
                    SendErrorResponse(uid, response);
                    return;
                }
            }

            //如果请求的资源不存在的，那就发送404
            FileInfo fileInfo = new FileInfo(fileName);
            if (!fileInfo.Exists)
            {
                response.ResponseCode = "404 Not Found";
                response.Content_Type = "text/html";
                SendErrorResponse(uid, response);
                return;
            }

            //如果请求的资源不在支持的范围内，也当作404了，感觉不是404的，貌似是403的
            string extension = fileInfo.Extension.TrimStart('.');
            if (string.IsNullOrEmpty(extension) || !_supportExtension.ContainsKey(extension))
            {
                response.ResponseCode = "404 Not Found";
                response.Content_Type = "text/html";
                SendErrorResponse(uid, response);
                return;
            }

            //既然也不是请求起始页的，也没发生上面列的错误的，就正常响应
            response.Content_Type = _supportExtension[extension];
            response.ResponseCode = "200 OK";

            if (string.Compare(extension, "aspx") == 0)
            {
                string queryString = containQM ? Regex.Match(fullURL, @"(?<=\?).*").Value : string.Empty;
                string requestFile = containQM ? Regex.Match(request.URL, @"(?<=/).*(?=\?)").Value : Regex.Match(request.URL, @"(?<=/).*").Value;
                //byte[] aspxHtml = _aspxHost.CreateAspxPage("AJAX.aspx", string.Empty);

                byte[] aspxHtml = _aspxHost.CreateAspxPage(requestFile, queryString);
                SendResponse(uid, aspxHtml, response);
                return;
            }

            FileStream fs =null;
            try
            {
                fs = File.OpenRead(fileInfo.FullName);
                byte[] datas = new byte[fileInfo.Length];
                fs.Read(datas, 0, datas.Length);
                SendResponse(uid, datas, response);
            }
            finally
            {
                fs.Close();
                fs.Dispose();
                fs = null;
            }
            return;
        }

        private void SendErrorResponse(string uid,ResponseHeader header)
        {
            string errorPageContent = header.CreateErrorHtml();
            header.Content_Length = errorPageContent.Length;
            SendResponse(uid, errorPageContent, header);
        }

        private void SendResponse(string uid,string content,ResponseHeader header)
        {
            header.Content_Length = content.Length;
            _pool.SendMessage(uid, header.ToString());
            _pool.SendMessage(uid, content);
        }

        private void SendResponse(string uid, byte[] content, ResponseHeader header)
        {
            header.Content_Length = content.Length;
            _pool.SendMessage(uid, header.ToString());
            _pool.SendMessage(uid, content);
        }
    }

 

    internal class AspxCreator:MarshalByRefObject
    {       
        public byte[] CreateAspxPage(string fileName,string qs)
        {
            byte[] datas=null;
            MemoryStream ms = null;
            StreamWriter sw = null;
            try
            {
                ms = new MemoryStream();
                sw = new StreamWriter(ms, Encoding.UTF8);
                sw.AutoFlush = true;
                HttpWorkerRequest worker = new ChineseRequest(fileName, qs, sw);
                HttpRuntime.ProcessRequest(worker);
                datas = new byte[ms.Length];
                ms.Position = 0;
                sw.BaseStream.Read(datas, 0, datas.Length);
            }
            catch (Exception e) 
            {
            
            }
            finally
            {
                if (sw != null)
                {
                    sw.Close();
                    sw.Dispose();
                    sw = null;
                }
                if (ms != null)
                {
                    ms.Close();
                    ms.Dispose();
                    ms = null;
                }
            }
            return datas;
        }
    }

    internal class ChineseRequest:SimpleWorkerRequest
    {
        private TextWriter Output;
        public ChineseRequest(string fileName, string queryString, TextWriter textWirter)
            : base(fileName, queryString, textWirter)
        {
            Output = textWirter;
        }
        public override void SendResponseFromMemory(byte[] data, int length)
        {
            Output.Write(System.Text.Encoding.UTF8.GetChars(data, 0, length));
        }
    }

 

若要查看连接池和Web服务器的实现详情，请查看这里篇博文《Socket连接池》和《自己写的Web服务器》