Common.TcpLibTcpServerY

using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Runtime.InteropServices;
using System.IO;

namespace Common.TcpLib
{
    /// <summary>
    /// 异步Socket处理服务器端
    /// </summary>
    public class TcpServerY : Common.TcpLib.ITcpServer
    {
        private Socket _listener;
        private string _listenerIp = "127.0.0.1";
        private int _port;
        private List<_Bgz_ConnectionState> _connections = new List<_Bgz_ConnectionState>();
        private int _maxConnections = 2000;
        private int _backlog = 100;
        private int _bufferSize = 1024;

        private AsyncCallback ConnectionReady;
        private WaitCallback  AcceptConnection;
        private AsyncCallback ReceivedDataReady;
        private ManualResetEvent sendDone = new ManualResetEvent(false);

        private bool _disposed;
        private bool _debug = false;
        private object _stopLock = new object();
        private bool _sotpMessage = false;

        #region define delegates
        /// <summary>
        /// 服务器绑定后处理事件 
        /// </summary>
        public _Bgz_OnBindEventDelegate FOnBindEventDelegate;

        /// <summary>
        /// Accept后处理事件
        /// </summary>
        public _Bgz_OnAcceptEventDelegate FOnAcceptEventDelegate;

        /// <summary>
        /// 接收到客户端数据后处理事件
        /// </summary>
        public _Bgz_OnReceiveBeginEventDelegate FOnReceiveBeginEventDelegate;
        public _Bgz_OnReceiveingEventDelegate FOnReceiveingEventDelegate;
        public _Bgz_OnReceiveEndEventDelegate FOnReceiveEndEventDelegate;

        /// <summary>
        /// 报错信息处理
        /// </summary>
        public _Bgz_OnErrorEventDelegate FOnErrorEventDelegate;

        /// <summary>
        /// 断掉与客户机的连接前处理事件 
        /// </summary>
        public _Bgz_OnDropConnectEventDelegate FOnDropConnectEventDelegate;
        #endregion

        #region Event
        private void OnBindEvent(_Bgz_ConnectionState state)
        {
            if (FOnBindEventDelegate != null) FOnBindEventDelegate(state);
        }
        private void OnAcceptEvent(_Bgz_ConnectionState state)
        {
            if (FOnAcceptEventDelegate != null) FOnAcceptEventDelegate(state);
        }
        private void OnReceiveBeginEvent(_Bgz_ConnectionState state)
        {
            if (FOnReceiveBeginEventDelegate != null) FOnReceiveBeginEventDelegate(state);
        }
        private void OnReceiveingEvent(_Bgz_ConnectionState state)
        {
            if (FOnReceiveingEventDelegate != null) FOnReceiveingEventDelegate(state);
        }
        private void OnReceiveEndEvent(_Bgz_ConnectionState state)
        {
            if (FOnReceiveEndEventDelegate != null) FOnReceiveEndEventDelegate(state);
        }
        private void OnErrorEvent(ErrorType errortype, string msg, _Bgz_ConnectionState state)
        {
            if (FOnErrorEventDelegate != null) FOnErrorEventDelegate(errortype, msg, state);
        }
        private void OnDropConnectEvent(_Bgz_ConnectionState state)
        {
            if (FOnDropConnectEventDelegate != null) FOnDropConnectEventDelegate(state);
        }
        #endregion

        #region Constructor and Destructor

        public TcpServerY(int port)
        {
            _port = port;
        }

        public TcpServerY(int port, int backlog)
        {
            _port = port;
            _backlog = backlog;
        }

        public TcpServerY(int port, int backlog, int maxConnection)
        {
            _port = port;
            _backlog = backlog;
            _maxConnections = maxConnection;
        }

        public TcpServerY(int port, int backlog, int maxConnection, int buffterSize)
        {
            _port = port;
            _backlog = backlog;
            _maxConnections = maxConnection;
            _bufferSize = buffterSize;
        }

        public TcpServerY(string listenerIp, int port)
        {
            _listenerIp = listenerIp;
            _port = port;
        }

        public TcpServerY(string listenerIp, int port, int backlog)
        {
            _listenerIp = listenerIp;
            _port = port;
            _backlog = backlog;
        }

        public TcpServerY(string listenerIp, int port, int backlog, int maxConnection)
        {
            _listenerIp = listenerIp;
            _port = port;
            _backlog = backlog;
            _maxConnections = maxConnection;
        }

        public TcpServerY(string listenerIp, int port, int backlog, int maxConnection, int buffterSize)
        {
            _listenerIp = listenerIp;
            _port = port;
            _backlog = backlog;
            _maxConnections = maxConnection;
            _bufferSize = buffterSize;
        }
        ~TcpServerY()
        {
            if (!_disposed)
            {
                Stop();
            }
        }
        #endregion

        #region Private Methods
        private void Dispose()
        {
            if (!_disposed)
            {
                Stop();
                GC.Collect();
                GC.WaitForPendingFinalizers();
                this.FOnAcceptEventDelegate = null;
                this.FOnBindEventDelegate = null;
                this.FOnDropConnectEventDelegate = null;
                this.FOnErrorEventDelegate = null;
                this.FOnReceiveBeginEventDelegate = null;
                this.FOnReceiveEndEventDelegate = null;
                this.FOnReceiveingEventDelegate = null;
                _disposed = true;
            }
        }
       
        private void ConnectionReady_Handler(IAsyncResult ar)
        {
            try
            {
                lock (this)
                {
                    _Bgz_ConnectionState stx = new _Bgz_ConnectionState();

                    if (_listener == null)
                    {
                        lock (_stopLock)
                        {
                            if (!_sotpMessage)
                            {
                                OnErrorEvent(ErrorType.DisAccept, "服务器关闭了监听！", null);
                                _sotpMessage = true;
                            }
                        }
                        return;
                    }
                   
                    stx._conn = _listener.EndAccept(ar);

                    #region 处理Socket网络异常断开
                    uint dummy = 0;
                    byte[] inOptionValues = new byte[Marshal.SizeOf(dummy) * 3];
                    BitConverter.GetBytes((uint)1).CopyTo(inOptionValues, 0);
                    BitConverter.GetBytes((uint)5000).CopyTo(inOptionValues, Marshal.SizeOf(dummy));
                    BitConverter.GetBytes((uint)5000).CopyTo(inOptionValues, Marshal.SizeOf(dummy) * 2);
                    _listener.IOControl(IOControlCode.KeepAliveValues, inOptionValues, null);
                    #endregion

                    if (_connections.Count >= _maxConnections)
                    {
                        OnErrorEvent(ErrorType.MaxConnect, "Server busy！", stx);

                        DropConnection(stx);
                    }
                    else
                    {
                        _connections.Add(stx);
                        ThreadPool.QueueUserWorkItem(AcceptConnection, stx);
                    }
                    _listener.BeginAccept(ConnectionReady, null);
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "ConnectionReady Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        private void AcceptConnection_Handler(object state)
        {
            try
            {
                _Bgz_ConnectionState stx = state as _Bgz_ConnectionState;
                try
                {
                    OnAcceptEvent(stx);

                    if (stx.Connected)
                        stx._conn.BeginReceive(stx._buffer, 0, 0, SocketFlags.None, ReceivedDataReady, stx);
                }
                catch (Exception ex)
                {
                    DropConnection(stx);

                    if (Debug)
                    {
                        OnErrorEvent(ErrorType.Catch, "AcceptConnection.1 Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", stx);
                    }
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "AcceptConnection.2 Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        private void ReceivedDataReady_Handler(IAsyncResult ar)
        {
            try
            {
                _Bgz_ConnectionState stx = ar.AsyncState as _Bgz_ConnectionState;

                if (this._listener == null)
                {
                    lock (_stopLock)
                    {
                        if (!_sotpMessage)
                        {
                            OnErrorEvent(ErrorType.DisAccept, "服务器关闭了监听！", null);
                            _sotpMessage = true;
                        }
                    }
                    return;
                }

                if (stx._conn == null) return;

                stx._conn.EndReceive(ar);

                if (stx.AvailableData == 0)
                {
                    DropConnection(stx);
                    return;
                }
                try
                {
                    lock (this)
                    {
                        OnReceiveBeginEvent(stx);

                        #region receive

                        stx._buffer = new byte[0];
                        stx._count = 0;
                        stx._dataStream.SetLength(0);
                        stx._dataStream.Position = 0;
                        if (stx._getonceall)
                        {
                            stx._buffer = new byte[stx.AvailableData];
                            int ret = stx.Read(stx._buffer, 0, stx._buffer.Length);
                            if (ret > 0)
                            {
                                stx._dataStream.Write(stx._buffer, 0, stx._buffer.Length);
                                stx._count++;
                                OnReceiveingEvent(stx);
                            }
                        }
                        else
                        {
                            while (stx.AvailableData > 0)
                            {
                                if (stx.AvailableData > _bufferSize)
                                    stx._buffer = new byte[_bufferSize];
                                else
                                    stx._buffer = new byte[stx.AvailableData];
                                int ret = stx.Read(stx._buffer, 0, stx._buffer.Length);
                                if (ret > 0)
                                {
                                    stx._dataStream.Write(stx._buffer, 0, stx._buffer.Length);
                                    stx._count++;
                                    OnReceiveingEvent(stx);
                                }
                            }
                        }
                        #endregion

                        OnReceiveEndEvent(stx);
                    }

                    if (stx._conn == null) return;
                    if (stx._conn.Connected)
                    {
                        stx._buffer = new byte[0];
                        stx._count = 0;
                        stx._conn.BeginReceive(stx._buffer, 0, 0, SocketFlags.None, ReceivedDataReady, stx);
                    }
                }
                catch (Exception ex)
                {
                    if (this._listener == null)
                    {
                        lock (_stopLock)
                        {
                            if (!_sotpMessage)
                            {
                                OnErrorEvent(ErrorType.DisAccept, "服务器关闭了监听！", null);
                                _sotpMessage = true;
                            }
                        }
                        return;
                    }

                    if (stx._conn != null)
                        DropConnection(stx);
                    if (Debug)
                    {
                        OnErrorEvent(ErrorType.Catch, "ReceivedDataReady.1 Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", stx);
                    }
               }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "ReceivedDataReady.2 Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        private void DropConnection(_Bgz_ConnectionState stx)
        {
            try
            {
                lock (this)
                {
                    if (_listener == null)
                    {
                        lock (_stopLock)
                        {
                            if (!_sotpMessage)
                            {
                                OnErrorEvent(ErrorType.DisAccept, "服务器关闭了监听！", null);
                                _sotpMessage = true;
                            }
                        }
                        return;
                    }
                    OnDropConnectEvent(stx);
                    if (_connections.Contains(stx)) _connections.Remove(stx);

                    if (stx._conn != null)
                    {
                        IPEndPoint info = (IPEndPoint)stx._conn.RemoteEndPoint;
                        string str = info.Address.ToString() + ":" + info.Port.ToString();
                        OnErrorEvent(ErrorType.DisAccept, "关闭了远程连接[" + str + "]！", null);
                        if (stx._conn.Connected)
                            stx._conn.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "DropConnection Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        private void SendCallback(IAsyncResult ar)
        {
            try
            {
                Socket client = (Socket)ar.AsyncState;
                int bytesSent = client.EndSend(ar);
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Send Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
            finally
            {
                sendDone.Set();
            }
        }
 
        #endregion

        #region Public Methods

        public void Start()
        {
            Start(false);
        }
 
        public void Start(bool optionValue)
        {
            try
            {
                _listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                #region 处理Socket端口复用
                _listener.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, optionValue);
                #endregion

                _connections = new List<_Bgz_ConnectionState>(); ;
                ConnectionReady = new AsyncCallback(ConnectionReady_Handler);
                AcceptConnection = new WaitCallback(AcceptConnection_Handler);
                ReceivedDataReady = new AsyncCallback(ReceivedDataReady_Handler);

                _listener.Bind(new IPEndPoint(IPAddress.Parse(_listenerIp), _port));
                _listener.Listen(_backlog);

                _Bgz_ConnectionState stx = new _Bgz_ConnectionState(_listener);
                OnBindEvent(stx);

                _sotpMessage = false;
                _stopLock = new object();
                _listener.BeginAccept(ConnectionReady, null);
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Start Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        public void Send(byte[] msg)
        {
            try
            {
                foreach (Socket s in ClientSockets)
                {
                    Send(s, msg);
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Send Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        public void Send(Socket ClientSocket, byte[] msg)
        {
            try
            {
                if (ClientSocket.Connected == false)
                {
                    OnErrorEvent(ErrorType.DisConnect, "未与服务器建立链接，导致发送数据失败！", null);
                }
                ClientSocket.Send(msg);
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Send Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        public void SendAsync(Socket ClientSocket, byte[] msg)
        {
            try
            {
                if (ClientSocket.Connected == false)
                {
                    throw (new Exception("没有连接客户端不可以发送信息!"));
                }

                byte[] buffer;
                int count = msg.Length;
                int cur = 0;
                while (count > 0)
                {
                    if (count > this._bufferSize)
                        buffer = new byte[this._bufferSize];
                    else
                        buffer = new byte[count];

                    for (int i = 0; i < buffer.Length; i++)
                    {
                        buffer[i] = msg[cur + i];
                    }
                    count -= buffer.Length;

                    cur += buffer.Length;

                    ClientSocket.BeginSend(buffer, 0, buffer.Length, 0, new AsyncCallback(SendCallback), ClientSocket);
                    sendDone.WaitOne();
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Send Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        public void SendAsync(Socket ClientSocket, Stream Astream)
        {
            try
            {
                if (ClientSocket.Connected == false)
                {
                    throw (new Exception("没有连接客户端不可以发送信息!"));
                }

                byte[] buffer;
                long count = Astream.Length;
                while (count > 0)
                {
                    if (count > this._bufferSize)
                        buffer = new byte[this._bufferSize];
                    else
                        buffer = new byte[count];

                    Astream.Read(buffer, 0, buffer.Length);
                    count -= buffer.Length;
                    ClientSocket.BeginSend(buffer, 0, buffer.Length, 0, new AsyncCallback(SendCallback), ClientSocket);
                    sendDone.WaitOne();
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Send Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        public void Stop()
        {
            try
            {
                lock (this)
                {
                    foreach (object obj in _connections)
                    {
                        _Bgz_ConnectionState stx = obj as _Bgz_ConnectionState;
                        OnDropConnectEvent(stx);

                        stx._conn.Shutdown(SocketShutdown.Both);
                        stx._conn.Close();
                    }
                    _connections.Clear();

                    _listener.Close();
                    _listener = null;
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Stop Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        #endregion

        #region property
        /// <summary>
        /// 获取最大的连接池大小
        /// </summary>
        public int MaxConnections
        {
            get
            {
                return _maxConnections;
            }
        }

 
        /// <summary>
        /// 获取挂起连接队列的最大长度
        /// </summary>
        public int BackLog
        {
            get
            {
                return _backlog;
            }
        }

        public int BufferSize
        {
            get
            {
                return _bufferSize;
            }
        }

        /// <summary>
        /// 获取当前连接池的容量
        /// </summary>
        public int CurrentConnections
        {
            get
            {
                lock (this) { return _connections.Count; }
            }
        }

        public Socket[] ClientSockets
        {
            get
            {
                Socket[] sockets = new Socket[this._connections.Count];
                for (int i = 0; i < this._connections.Count; i++)
                {
                    sockets[i] = this._connections[i]._conn;
                }
                return sockets;
            }
        }

        public bool Debug
        {
            get
            {
                return _debug;
            }
            set
            {
                _debug = value;
            }
        }
        #endregion

    }

}


==========================================================

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using Common.TcpLib;
using Common;

namespace WindowsServer
{
    public partial class ServerY : Form
    {
        ThreadView tv;
        TcpServerY tcpserver;

        public ServerY()
        {
            InitializeComponent();

            tv = new ThreadView(this,0);
            tv.OnUpdateUIEventDelegate = new _Bgz_OnUpdateUI(_UpdateUI);
        }

        private void btConnect_Click(object sender, EventArgs e)
        {
            tcpserver = new TcpServerY(int.Parse(this.textBox1.Text));
            tcpserver.FOnAcceptEventDelegate = new _Bgz_OnAcceptEventDelegate(_OnAccept);
            tcpserver.FOnBindEventDelegate = new _Bgz_OnBindEventDelegate(_OnBind);
            tcpserver.FOnDropConnectEventDelegate = new _Bgz_OnDropConnectEventDelegate(_OnDropConnect);
            tcpserver.FOnErrorEventDelegate = new _Bgz_OnErrorEventDelegate(_OnError);
            tcpserver.FOnReceiveBeginEventDelegate = new _Bgz_OnReceiveBeginEventDelegate(_OnReceiveBegin);
            tcpserver.FOnReceiveingEventDelegate = new _Bgz_OnReceiveingEventDelegate(_OnReceiveing);
            tcpserver.FOnReceiveEndEventDelegate = new _Bgz_OnReceiveEndEventDelegate(_OnReceiveEnd);
            tcpserver.Debug = true;
            tcpserver.Start(true);
            this.btConnect.Enabled = false;
        }

        private void btClose_Click(object sender, EventArgs e)
        {
            tcpserver.Stop();
            this.btConnect.Enabled = true;
        }

        public void _OnAccept(_Bgz_ConnectionState state)
        {
            string str = "远程端口[" + state.StrRemoteEndPoint + "]访问服务器!#";
            tv.ShowState(str, "rtbReceiveMessage");
        }

        public void _OnBind(_Bgz_ConnectionState state)
        {
            string str = "建立服务器监听[" + state.StrLocalEndPoint + "]#";
            tv.ShowState( str , "rtbReceiveMessage");
        }

        public void _OnDropConnect(_Bgz_ConnectionState state)
        {
            //string str = "关闭了["+state.StrRemoteEndPoint +"]的连接！#";
            //tv.ShowState(str , "rtbReceiveMessage");
        }

        public void _OnError(ErrorType errortype, string errormsg, _Bgz_ConnectionState state)
        {
            tv.ShowState(errormsg, "rtbReceiveMessage");
         }

         public void _OnReceiveBegin(_Bgz_ConnectionState state)
         {
             //设置接收数据包的处理
             //count： 包的接收次数
             //getonceall: 是否一次性接收 如果设置为false则接所设置的默认缓冲区大小bufferSize分批次接收
             state._count = 0;
             state._getonceall = true;

             string str = ">>>>>>> Receive Begin from [" + state.StrRemoteEndPoint + "]#";
             tv.ShowState(str, "rtbReceiveMessage");
         }

         public void _OnReceiveing(_Bgz_ConnectionState state)
         {
             //如非必要建议不要在此处理 服务器接收数据片段
             //string str = Encoding.UTF8.GetString(state._buffer);
             //tv.ShowState(state._count.ToString() + ">>>", "rtbReceiveMessage");
             //tv.ShowState(str, "rtbReceiveMessage");
         }

         long i = 0;
         public void _OnReceiveEnd(_Bgz_ConnectionState state)
         {
             string str = Encoding.UTF8.GetString(state._buffer);
             tv.ShowState(str, "rtbReceiveMessage");

             tv.ShowState(">>>>>>> Receive End frm  [" + state.StrRemoteEndPoint + "]#", "rtbReceiveMessage");

             //回写客户端
             System.Threading.Interlocked.Increment(ref i);
             str = i.ToString() + ":" + str;
             tcpserver.Send(Encoding.UTF8.GetBytes(str));
         }
       
        #region 跨线程窗体控件操作
        private void _UpdateUI(object sender, MessageEvents e)
        {
            switch (e.Control)
            {
                case "rtbReceiveMessageApp":
                    this.rtbReceiveMessage.AppendText(e.Msg);
                    this.rtbReceiveMessage.ScrollToCaret();
                    break;
                case "rtbReceiveMessage":
                default:
                    this.rtbReceiveMessage.AppendText(e.Msg + "\r\n");
                    this.rtbReceiveMessage.ScrollToCaret();
                    break;
            }
        }
        #endregion
    }
}