Common.TcpLibTcpClientY

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 TcpClientY : Common.TcpLib.ITcpClient
    {
        public Socket _clientSocket;
        private string _serverIp;
        private int _port;
        private int _bufferSize = 1024;

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

        #region define delegates
        /// <summary>
        /// 连接上服务器后的事件处理
        /// </summary>
        public _Bgz_OnConnectEventDelegate FOnConnectEventDelegate;

        /// <summary>
        /// 接收服务端发来的数据事件处理
        /// </summary>
        public _Bgz_OnReceiveBeginEventDelegate FOnReceiveBeginEventDelegate;

        /// <summary>
        /// 接收服务端发来的数据事件处理
        /// </summary>
        public _Bgz_OnReceiveingEventDelegate FOnReceiveingEventDelegate;

        /// <summary>
        /// 接收服务端发来的数据事件处理
        /// </summary>
        public _Bgz_OnReceiveEndEventDelegate FOnReceiveEndEventDelegate;

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

        #region Event
        private void OnConnectEvent(_Bgz_ConnectionState state)
        {
            if (FOnConnectEventDelegate != null) FOnConnectEventDelegate(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);
        }
        #endregion

        #region property

        public int BufferSize
        {
            get
            {
                return _bufferSize;
            }
        }

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

        #region Constructor and Destructor
        public TcpClientY(string serverIp, int port)
        {
            this._serverIp = serverIp;
            this._port = port;
        }

        public TcpClientY(string serverIp, int port, int bufferSize)
        {
            this._serverIp = serverIp;
            this._port = port;
            this._bufferSize = bufferSize;
        }

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

        #region Private Methods
        private void Dispose()
        {
            if (!_disposed)
            {
                Stop();
                GC.Collect();
                GC.WaitForPendingFinalizers();
                this.FOnConnectEventDelegate = null;
                this.FOnErrorEventDelegate = null;
                this.FOnReceiveBeginEventDelegate = null;
                this.FOnReceiveEndEventDelegate = null;
                this.FOnReceiveingEventDelegate = null;
                _disposed = true;
            }
        }

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

                OnReceiveBeginEvent(stx);

                stx._conn.EndReceive(ar);

                if (stx._conn.Available == 0)
                {
                    Stop();
                    return;
                }

                #region receive
                lock (ar)
                {
                    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.Connected)
                    stx._conn.BeginReceive(stx._buffer, 0, 0, SocketFlags.None, new AsyncCallback(ReceiveCallback), stx);
            }
            catch (Exception ex)
            {
                Stop();
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "ReceiveCallback 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)
            {
                Stop();
                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 Connect()
        {
            try
            {
                _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                _clientSocket.Connect(new IPEndPoint(IPAddress.Parse(_serverIp), _port));

                _Bgz_ConnectionState stx = new _Bgz_ConnectionState();
                stx._conn = this._clientSocket;
                OnConnectEvent(stx);
                _stopLock = new object();
                _sotpMessage = false;

                _clientSocket.BeginReceive(stx._buffer, 0, 0, SocketFlags.None, new AsyncCallback(ReceiveCallback), stx);
            }
            catch (Exception ex)
            {
                OnErrorEvent(ErrorType.Catch, "连接到远程服务器" + _serverIp + ":" + _port.ToString() + "失败！\r\n" + ex.Message, null);
            }
        }

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

        public void SendAsync(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[_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)
            {
                Stop();
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Send Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        public void SendAsync(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)
            {
                Stop();
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Send Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        public void Stop()
        {
            try
            {
                if (_clientSocket != null)
                {
                    if (_clientSocket.Connected)
                    {
                        _clientSocket.Shutdown(SocketShutdown.Both);
                        _clientSocket.Disconnect(false);
                    }
                    _clientSocket.Close();
                }
                lock (_stopLock)
                {

                    if (!_sotpMessage)
                    {
                        OnErrorEvent(ErrorType.DisConnect, "关闭了与服务器的连接！", null);
                        _sotpMessage = true;
                    }
                }
            }
            catch (Exception ex)
            {
                if (Debug)
                {
                    OnErrorEvent(ErrorType.Catch, "Stop Error！[Message]:\r\n" + ex.Message + "[StackTrace]:\r\n" + ex.StackTrace + "\r\n", null);
                }
            }
        }

        #endregion

    }

}