写自己的Socket框架(一)

public override bool Start()
        {
            this._socket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //设置KeeyAlive，如果客户端不主动发消息时，Tcp本身会发一个心跳包，来通知服务器，这是一个保持通讯的链接。
            //避免等到下一次通讯时，才知道链接已经断开。
            this._socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
            this._socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
            try
            {
                this._socket.Bind(base.SocketConfig.Point);
                this._socket.Listen(base.SocketConfig.Backlog);

                this._socket_args = new SocketAsyncEventArgs();
                this._socket_args.Completed += new EventHandler<SocketAsyncEventArgs>(AcceptSocketCompleted);

                //在链接过来的时候，如果IO没有挂起，则AcceptAsync为False，表明同步完成。
                if (!this._socket.AcceptAsync(this._socket_args))
                {
                    AcceptSocketCompleted(this._socket, this._socket_args);
                }
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }


void AcceptSocketCompleted(object sender, SocketAsyncEventArgs e)
        {
            System.Net.Sockets.Socket socket = null;
            if (e.SocketError != SocketError.Success)
            {
                    return;
            }
            else
            {
                socket = e.AcceptSocket;
            }
            e.AcceptSocket = null;
            bool willRaiseEvent = false;
            try
            {
                //继续监听该端口，在处理逻辑时，不影响其他链接的数据传送。
                willRaiseEvent = this._socket.AcceptAsync(e);
            }
            catch (Exception ex)
            {
                willRaiseEvent = true;
            }

            if (socket != null)
                OnNewClientAccepted(socket, null);

            if (!willRaiseEvent)
                AcceptSocketCompleted(null, e);
        }

public class SocketProxy
    {
        public System.Net.Sockets.Socket Client;

        public DateTime Timeout = DateTime.Now;

    }


public class SocketConnectionQueue : IDisposable
    {
        private Queue<SocketProxy> _queue;

        private readonly object _syncObject = new object();

        private bool _isStop = false;

        private Thread _thread;

        public Action<SocketProxy> Connected;

        public SocketConnectionQueue()
        {
            if (_queue == null)
            {
                _queue = new Queue<SocketProxy>();
            }

            if (_thread == null)
            {
                _thread = new Thread(Thread_Work)
                {
                    IsBackground = true,
                    Priority = ThreadPriority.Highest

                };
                _thread.Start();
            }
        }

        public void Push(SocketProxy connect)
        {
            lock (_syncObject)
            {
                if (_queue != null)
                {
                    _queue.Enqueue(connect);
                }
            }
        }

        public void Thread_Work()
        {
            while (!_isStop)
            {
                SocketProxy[] socketConnect = null;
                lock (_syncObject)
                {
                    if (_queue.Count > 0)
                    {
                        socketConnect = new SocketProxy[_queue.Count];
                        _queue.CopyTo(socketConnect, 0);
                        _queue.Clear();
                    }
                }

                if (socketConnect != null && socketConnect.Length > 0)
                {
                    foreach (var client in socketConnect)
                    {
                        if (Connected != null)
                        {
                            Connected.Invoke(client);
                        }
                    }
                }
                Thread.Sleep(10);
            }
        }

        public void Dispose()
        {
            _isStop = true;
            if (_thread != null)
            {
                _thread.Join();
            }
        }
    }

public class SocketConnectionPool : IDisposable
    {
        private ServerConfig _serverConfig;

        public IAppServer AppServer;

        private ConcurrentStack<SocketConnection> _connectPool;

        private long connect_id = 0;
        private byte[] _buffer;
        private readonly object _syncObject = new object();

        private SocketConnectionQueue _queue;

        public Action<System.Net.Sockets.Socket, SocketConnection> Connected;

        public long GenerateId()
        {
            if (connect_id == long.MaxValue)
            {
                connect_id = 0;
            }
            connect_id++;
            return connect_id;
        }

        public SocketConnectionPool(IAppServer server)
        {
            this.AppServer = server;
            this._serverConfig = server.AppConfig;

        }

        public void Init()
        {
            var connects = new List<SocketConnection>(this._serverConfig.MaxConnectionNumber);
            _buffer = new byte[this._serverConfig.BufferSize];
            SocketAsyncEventArgs arg;
            for (var i = 0; i < this._serverConfig.MaxConnectionNumber; i++)
            {
                arg = new SocketAsyncEventArgs();
                arg.SetBuffer(_buffer, 0, _buffer.Length);
                connects.Add(new SocketConnection(arg, this));
            }
            _connectPool = new ConcurrentStack<SocketConnection>(connects);
            if (_queue == null)
            {
                _queue = new SocketConnectionQueue();
            }
            
            _queue.Connected = OnConnected;
        }

        public void Push(System.Net.Sockets.Socket socket)
        {
            SocketProxy proxy = new SocketProxy()
            {
                Client = socket
            };
            _queue.Push(proxy);
        }

        public void OnConnected(SocketProxy proxy)
        {
            //如果发现队列里面的链接，在Timeout时间内，都没有分配到资源，则关掉链接并丢弃。
            int timeout = (int)(DateTime.Now - proxy.Timeout).TotalSeconds;
            if (timeout >= this._serverConfig.Timeout)
            {
                proxy.Client.Close();
                return;
            }
            else
            {
                //没有分配到资源重新入列。
                SocketConnection connect = this.GetConnectionFromPool();
                if (connect == null)
                {
                    _queue.Push(proxy);
                }
                else
                {
                    if (this.Connected != null)
                    {
                        this.Connected(proxy.Client, connect);
                    }
                }
            }
        }

        /// <summary>
        /// 从链接池去取链接(LIFO)
        /// </summary>
        /// <returns></returns>
        public SocketConnection GetConnectionFromPool()
        {
            //_queue.Push();
            SocketConnection connect;
            if (!_connectPool.TryPop(out connect))
            {
                return null;
            }
            lock (_syncObject)
            {
                long connect_id = this.GenerateId();
                connect.ConnectId = connect_id;
            }
            return connect;
        }
        /// <summary>
        /// 释放链接，并放回链接池
        /// </summary>
        /// <param name="connect"></param>
        public void ReleaseConnection(SocketConnection connect)
        {
            _connectPool.Push(connect);
            LogHelper.Debug(connect.ConnectId + "放回ConnectPool");
        }

        public void Dispose()
        {
            _queue.Dispose();
        }
    }

public class SocketConnection
    {
        public SocketFlag Flag { get; private set; }
        
        public SocketConnectionPool Pool { get { return _pool; } private set { } }
        private SocketConnectionPool _pool;

        public SocketAsyncEventArgs RecevieEventArgs { get; set; }

        public long ConnectId { get; set; }

        public SocketConnection()
        {
            this.Flag = SocketFlag.Error;
        }

        public SocketConnection(SocketAsyncEventArgs args, SocketConnectionPool pool)
        {
            RecevieEventArgs = args;
            RecevieEventArgs.Completed += new EventHandler<SocketAsyncEventArgs>(SocketEventArgs_Completed);
            
            this.Flag = SocketFlag.Busy;
            this._pool = pool;
        }

        void SocketEventArgs_Completed(object sender, SocketAsyncEventArgs e)
        {
            var socketSession = e.UserToken as SocketSession;
            if (socketSession == null)
            {
                this.Flag = SocketFlag.Error;
                this.Close();
                return;
            }

            switch (e.LastOperation)
            { 
                case SocketAsyncOperation.Receive:
                    socketSession.ReceiveData(e);
                    break;
                default:
                    break;
            }
        }

        public void Initialise(SocketSession session)
        {
            this.RecevieEventArgs.UserToken = session;
            this.Flag = SocketFlag.Busy;

            session.Closed += () =>
            {
                this.Close();
            };
        }

        public void Reset()
        {
            //ConnectId = 0;
            this.RecevieEventArgs.UserToken = null;
            this.Flag = SocketFlag.Idle;
        }

        private void Close()
        {
            this.Reset();
            LogHelper.Debug(ConnectId + " reset");
            this._pool.ReleaseConnection(this);
        }
    }