public abstract class ClientBase
    {
		public class ProcessDataExecObj : IExecObj
		{
			private ClientBase m_client;
			private int m_bytesReceived = 0;

			public ProcessDataExecObj()
			{
			}

			public ClientBase Client
			{
				set
				{
					m_client = value;
				}
			}

			public int BytesReceived
			{
				get
				{
					return m_bytesReceived;
				}
				set
				{
					m_bytesReceived = value;
				}
			}

			public void Execute()
			{
				m_client.OnReceive(m_bytesReceived);
				m_client.ResumeReceive();
			}
		}

        /// <summary>
        /// Default constructor
        /// </summary>
        /// <param name="server">The server this client is connected to.</param>
        protected ClientBase(ServerBase server)
        {
            m_server = server;

            m_readBuffer = BufferManager.Instance.CheckOut();

			m_processDataObj = new ProcessDataExecObj();
			m_processDataObj.Client = this;
        }

        #region Private variables

        /// <summary>
        /// Total number of bytes that have been received by all clients.
        /// </summary>
        private static volatile uint s_totalBytesReceived;

        /// <summary>
        /// Total number of bytes that have been sent by all clients.
        /// </summary>
        private static volatile uint s_totalBytesSent;

        /// <summary>
        /// Number of bytes that have been received by this client.
        /// </summary>
        private int m_bytesReceived;

        /// <summary>
        /// Number of bytes that have been sent by this client.
        /// </summary>
        private int m_bytesSent;

        /// <summary>
        /// The socket containing the TCP connection this client is using.
        /// </summary>
        protected Socket m_tcpSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

        /// <summary>
        /// Pointer to the server this client is connected to.
        /// </summary>
        protected ServerBase m_server;

        /// <summary>
        /// The port the client should receive UDP datagrams on.
        /// </summary>
        protected IPEndPoint m_udpEp;

        /// <summary>
        /// The buffer containing the data received.
        /// </summary>
        protected ArraySegment<byte> m_readBuffer;

        /// <summary>
        /// The adjustment to make in the packet buffer.
        /// </summary>
        protected int m_packetDelta;

		/// <summary>
		/// The execution object for processing data.
		/// </summary>
		protected ProcessDataExecObj m_processDataObj;

        #endregion

        #region Public properties

        public ServerBase Server
        {
            get { return m_server; }
        }

        /// <summary>
        /// Gets the total number of bytes sent to all clients.
        /// </summary>
        [CLSCompliant(false)]
        public static uint TotalBytesSent
        {
            get { return s_totalBytesSent; }
        }

        /// <summary>
        /// Gets the total number of bytes received by all clients.
        /// </summary>
        [CLSCompliant(false)]
        public static uint TotalBytesReceived
        {
            get { return s_totalBytesReceived; }
        }

        /// <summary>
        /// Gets the IP address of the client.
        /// </summary>
        public IPAddress TcpIP
        {
            get { return (m_tcpSock.RemoteEndPoint as IPEndPoint).Address; }
        }

        /// <summary>
        /// Gets the port the client is communicating on.
        /// </summary>
        public int TcpPort
        {
            get { return (m_tcpSock.RemoteEndPoint as IPEndPoint).Port; }
        }

        /// <summary>
        /// Gets the port the client should receive UDP datagrams on.
        /// </summary>
        public IPEndPoint UdpEndpoint
        {
            get { return m_udpEp; }
            set { m_udpEp = value; }
        }

        /// <summary>
        /// Gets/Sets the socket this client is using for TCP communication.
        /// </summary>
        public Socket TcpSocket
        {
            get { return m_tcpSock; }
            set
            {
                if (m_tcpSock.Connected)
                {
                    m_tcpSock.Shutdown(SocketShutdown.Both);
                    m_tcpSock.Close();
                }

                if (value != null)
                {
                    m_tcpSock = value;
                }
            }
        }

        #endregion

        /// <summary>
        /// Begins asynchronous TCP receiving for this client.
        /// </summary>
        public void BeginReceive()
        {
            if (m_tcpSock.Connected)
            {
                using (SocketAsyncEventArgs args = new SocketAsyncEventArgs())
                {
                    args.SetBuffer(m_readBuffer.Array, m_readBuffer.Offset, m_readBuffer.Count);
                    args.UserToken = this;
                    args.Completed += ReceiveAsyncComplete;

                    m_tcpSock.ReceiveAsync(args);
                }
            }
        }

		/// <summary>
		/// Resumes asynchronous TCP receiving for this client.
		/// </summary>
		public void ResumeReceive()
		{
			using (SocketAsyncEventArgs socketArgs = new SocketAsyncEventArgs())
			{
				socketArgs.SetBuffer(m_readBuffer.Array, m_readBuffer.Offset + m_packetDelta, m_readBuffer.Count - m_packetDelta);
				socketArgs.UserToken = this;
				socketArgs.Completed += ReceiveAsyncComplete;

				m_tcpSock.ReceiveAsync(socketArgs);
			}
		}

        private static void ReceiveAsyncComplete(object sender, SocketAsyncEventArgs args)
        {
            ClientBase client = args.UserToken as ClientBase;

            try
            {
                int bytesTransferred = args.BytesTransferred;

                if (bytesTransferred == 0)
                {
                    client.m_server.DisconnectClient(client, true);
                }
                else
                {
                    unchecked
                    {
                        client.m_bytesReceived += bytesTransferred;
                        s_totalBytesReceived += (uint)bytesTransferred;
                    }

					client.m_processDataObj.BytesReceived = bytesTransferred;

					ThreadMgr.QueueExecObj(client.m_processDataObj);
                }
            }
            catch (ObjectDisposedException e)
            {
                client.m_server.Warning(client, e);
                client.m_server.DisconnectClient(client, true);
            }
            catch (Exception e)
            {
                client.m_server.Warning(client, e);
                client.m_server.DisconnectClient(client, true);
            }
        }

        /// <summary>
        /// Called when a packet has been received and needs to be processed.
        /// </summary>
        /// <param name="num_bytes">The size of the packet in bytes.</param>
        protected abstract void OnReceive(int num_bytes);
}