Common.TcpLibTcpServerS

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 TcpServerS
    {
        private Socket _listener;
        private string _listenerIp = "127.0.0.1";
        private int _port;
        private int _backlog = 100;
        private int _bufferSize = 1024;
        private int _maxConnections = 100;

        private Thread _accept;
        private int _receiveTimeout = 100000;

        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 TcpServerS(string listenerIp, int port)
        {
            _listenerIp = listenerIp;
            _port = port;
        }
        public TcpServerS(string listenerIp, int port, int backlog)
        {
            _listenerIp = listenerIp;
            _port = port;
            _backlog = backlog;
        }
        public TcpServerS(string listenerIp, int port, int backlog, int bufferSize)
        {
            _listenerIp = listenerIp;
            _port = port;
            _backlog = backlog;
            _bufferSize = bufferSize;
        }
        public TcpServerS(string listenerIp, int port, int backlog, int bufferSize, int maxConnections)
        {
            _listenerIp = listenerIp;
            _port = port;
            _backlog = backlog;
            _bufferSize = bufferSize;
            _maxConnections = maxConnections;
        }
        public TcpServerS(int port)
        {
            _port = port;
        }
        public TcpServerS(int port, int backlog)
        {
            _port = port;
            _backlog = backlog;
        }
        public TcpServerS(int port, int backlog, int bufferSize)
        {
            _port = port;
            _backlog = backlog;
            _bufferSize = bufferSize;
        }
        public TcpServerS(int port, int backlog, int bufferSize, int maxConnections)
        {
            _port = port;
            _backlog = backlog;
            _bufferSize = bufferSize;
            _maxConnections = maxConnections;
        }

        ~TcpServerS()
        {
            if (!_disposed)
            {
                Stop();
            }
        }
        #endregion

        #region Private Methods
        private void Dispose()
        {
            if (!_disposed)
            {
                if (_accept != null) 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 ClientWorkThread()
        {
            try
            {
                Thread.CurrentThread.IsBackground = true;

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

                    Socket handler = _listener.Accept();

                    _Bgz_ConnectionState stx = new _Bgz_ConnectionState(handler);
                    OnAcceptEvent(stx);

                    try
                    {
                        #region read to bytes
                        stx._buffer = new byte[0];
                        stx._count = 0;
                        stx._getonceall = false;

                        if (handler == null) break;
                        handler.Receive(stx._buffer);

                        if (handler.Available == 0)
                        {
                            DropConnection(stx);
                            break;
                        }

                        OnReceiveBeginEvent(stx);

                        stx._count = 0;
                        stx._dataStream.SetLength(0);
                        stx._dataStream.Position = 0;
                        if (stx._getonceall)
                        {
                            stx._buffer = new byte[handler.Available];
                            int ret = handler.Receive(stx._buffer, 0, stx._buffer.Length, SocketFlags.None);
                            if (ret > 0)
                            {
                                stx._dataStream.Write(stx._buffer, 0, stx._buffer.Length);
                                stx._count++;
                                OnReceiveingEvent(stx);
                            }
                        }
                        else
                        {
                            while (handler.Available > 0)
                            {
                                if (handler.Available > this._bufferSize)
                                    stx._buffer = new byte[this._bufferSize];
                                else
                                    stx._buffer = new byte[handler.Available];
                                int ret = handler.Receive(stx._buffer, 0, stx._buffer.Length, SocketFlags.None);
                                if (ret > 0)
                                {
                                    stx._dataStream.Write(stx._buffer, 0, stx._buffer.Length);
                                    stx._count++;
                                    OnReceiveingEvent(stx);
                                }
                            }
                        }

                        OnReceiveEndEvent(stx);
                        #endregion
                    }
                    catch (Exception ex)
                    {
                       DropConnection(stx);
                       if (Debug)
                        {
                            OnErrorEvent(ErrorType.Catch, "ReceiveThread.1 Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", stx);
                        }
                        break;
                    }
                    DropConnection(stx);
                }
            }
            catch (Exception ex)
            {
                if (this._listener == null)
                {
                    lock (_stopLock)
                    {
                        if (!_sotpMessage)
                        {
                            OnErrorEvent(ErrorType.DisAccept, "服务器关闭了监听！", null);
                            _sotpMessage = true;
                        }
                    }
                    return;
                }
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "ReceiveThread.2 Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        private void DropConnection(_Bgz_ConnectionState stx)
        {
            try
            {
                lock (this)
                {
                    OnDropConnectEvent(stx);
                    if (stx._conn != 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", stx);
                }
            }
        }

        #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

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

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

                #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

                #region 设置Socket接收延时的处理
                stx._conn.ReceiveTimeout = _receiveTimeout;
                #endregion

                Thread[] clientThreadList = new Thread[_maxConnections];
                for (int i =0; i < this._maxConnections; i++)
                {
                    clientThreadList[i] = new Thread(new ThreadStart(ClientWorkThread));
                    clientThreadList[i].Start();
                }
            }
            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 Stop()
        {
            try
            {
                lock (this)
                {

                    if (_accept != null)
                    {
                        _listener.Close();
                        _listener = null;

                        _accept.Join();
                        _accept = null;
                    }
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Stop 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)
                {
                    ClientSocket.Send(msg);
                }
                else
                {
                    OnErrorEvent(ErrorType.DisConnect, "未与服务器建立链接，导致发送数据失败！", null);
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Send Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        #endregion

        #region property

        public int BackLog
        {
            get
            {
                return _backlog;
            }
        }

        public int BufferSize
        {
            get
            {
                return _bufferSize;
            }
        }

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

    }

}