class EasySocket
    {
        public delegate void ConnectEvent(object sender);
        public delegate void ShutdownEvent(object sender);
        public delegate void ClientConnectedEvent(Socket socketConnected, object sender);
        public delegate void DataReceivedEvent(String data, Socket fromSocket, object sender);
        public delegate void DataSendEvent(object sender);

        public enum FamilyType
        {
            Tcp,
            Udp
        }

        public class Server : IDisposable
        {            
            public Server()
            {
                EndToken = "\0";

            }
            public event ClientConnectedEvent OnClientConnected;
            public event DataReceivedEvent OnDataReceive;
            public event DataSendEvent OnDataSent;
            public event ShutdownEvent OnShutdown;

            public FamilyType SocketFamilyType { get; set; }
            public int Port { get; set; }
            public int MaxClient { get; set; }
            public bool Universal { get; set; }
            public String EndToken { get; set; }
            public bool Started { get; private set; }
            public List<Socket> SocketsConnected { get { return this.m_Sockets; } }

            public void Start()
            {
                if (String.IsNullOrEmpty(SocketFamilyType.ToString()) || Port == 0)
                    return;
                else // I liked this style
                {
                    m_EndPoint = new IPEndPoint(Universal ? IPAddress.Any : IPAddress.Loopback, Port);
                    switch (SocketFamilyType)
                    {
                        case FamilyType.Tcp:
                            m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                            break;
                        case FamilyType.Udp:
                            m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                            break;
                    }
                    try
                    {
                        m_Socket.Bind(m_EndPoint);
                        m_Socket.Listen(MaxClient);
                        m_Socket.BeginAccept(CallBack_OnAccept, m_Socket);
                        Started = true;
                    }
                    catch (SocketException ex)
                    {
                        throw new Exception(String.Format("Port {0} has already been occupied.", Port));
                    }
                }
            }

            public void Disconnnect(Socket trySocket)
            {
                if (trySocket != null)
                {
                    try
                    {
                        trySocket.BeginDisconnect(true, CallBack_OnDisconnect, trySocket);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                        Console.WriteLine(ex.StackTrace);
                    }
                }
            }

            public void Send(Socket socket, String data)
            {
                data += EndToken;
                byte[] byteData = Encoding.ASCII.GetBytes(data);
                socket.BeginSend(byteData, 0, byteData.Length, 0, CallBack_OnSend, socket);
            }

            public void Broadcast(String data)
            {
                foreach (var m_Socket_field in m_Sockets)
                    Send(m_Socket_field, data);
            }

            public void Shutdown()
            {
                m_Socket.Close();
                if (this.OnShutdown != null) OnShutdown(this);
                this.Dispose();
            }

            private void CallBack_OnAccept(IAsyncResult ar)
            {
                Socket socketAccepted = null;
                try
                {
                    socketAccepted = m_Socket.EndAccept(ar);
                    m_Sockets.Add(socketAccepted);
                    m_SocketsBuffer.Add(socketAccepted, new StringBuilder());
                    if (OnClientConnected != null)
                        OnClientConnected(socketAccepted, this);
                    socketAccepted.BeginReceive(m_Data, 0, m_Data.Length, SocketFlags.None, CallBack_OnReceive, socketAccepted);
                    m_Socket.BeginAccept(CallBack_OnAccept, m_Socket);
                }

                catch (SocketException ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                    Disconnnect(socketAccepted);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }
            }

            private void CallBack_OnReceive(IAsyncResult ar)
            {
                Socket socketAccepted = null;
                try
                {
                    socketAccepted = ar.AsyncState as Socket;
                    
                    int read = socketAccepted.EndReceive(ar);
                    var sb = new StringBuilder();

                    if (read > 0)
                    {
                        String strRead = Encoding.ASCII.GetString(m_Data, 0, read);
                        char lastChar = strRead[strRead.Length - 1];
                        //Console.WriteLine("{0}", strRead);
                        Console.WriteLine("{0}", m_SocketsBuffer[socketAccepted]);

                        if (lastChar != '\r' )
                        {
                            m_SocketsBuffer[socketAccepted].Append(strRead);
                            socketAccepted.BeginReceive(m_Data, 0, m_Data.Length, SocketFlags.None, CallBack_OnReceive, socketAccepted);
                            return;
                        }

                        sb.Append(m_SocketsBuffer[socketAccepted]);
                        //socketAccepted.BeginReceive(m_Data, 0, m_Data.Length, SocketFlags.None, CallBack_OnReceive, socketAccepted);
                    }
                    if (sb.Length > 0)
                    {
                        string content = sb.ToString();
                        if (!String.IsNullOrEmpty(EndToken))
                        {
                            int index = content.IndexOf(EndToken, StringComparison.Ordinal);
                            if (index != -1)
                                content = content.Substring(0, index);
                        }
                        if (OnDataReceive != null)
                            OnDataReceive(content, socketAccepted, this);
                        // Flush it
                        m_SocketsBuffer[socketAccepted] = new StringBuilder();
                    }
                }
                catch (SocketException ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                    Disconnnect(socketAccepted);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }
            }

            private void CallBack_OnSend(IAsyncResult ar)
            {
                Socket socketAccepted = null;
                try
                {
                    socketAccepted = ar.AsyncState as Socket;

                    // Complete sending the data to the remote device.
                    socketAccepted.EndSend(ar);

                    if (this.OnDataSent != null)
                        OnDataSent(this);
                }


                catch (SocketException ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                    Disconnnect(socketAccepted);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }
            }

            private void CallBack_OnDisconnect(IAsyncResult ar)
            {
                try
                {
                    Socket socketTryDisconnect = ar.AsyncState as Socket;

                    socketTryDisconnect.EndDisconnect(ar);

                    m_SocketsBuffer.Remove(socketTryDisconnect);
                    m_Sockets.Remove(socketTryDisconnect);
                }

                catch (SocketException ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }
            }

            private readonly Dictionary<Socket, StringBuilder> m_SocketsBuffer = new Dictionary<Socket, StringBuilder>();
            private List<Socket> m_Sockets = new List<Socket>();
            private byte[] m_Data = new byte[65535];
            private IPEndPoint m_EndPoint;
            private Socket m_Socket;
            
            public void Dispose()
            {
                m_Data = null;
                m_Socket = null;
                m_Sockets = null;
                m_EndPoint = null;
                GC.Collect();
                GC.SuppressFinalize(this);
            }
        }

        public class Client : IDisposable
        {
            public event ConnectEvent OnConnected;
            public event DataReceivedEvent OnDataReceive;
            public event DataSendEvent OnDataSent;
            public event ShutdownEvent OnShutdown;
            public FamilyType SocketFamilyType { get; set; }
            public string Destination { get; set; }
            public int Port { get; set; }
            public String EndToken { get; set; }
            public bool Conntected { get { return m_Socket.Connected; } }

            public void Connect()
            {
                if (String.IsNullOrEmpty(SocketFamilyType.ToString()) || Port == 0)
                    return;
                else // I liked this style
                {
                    m_EndPoint = new IPEndPoint(Array.Find(Dns.GetHostAddresses(Destination), a => a.AddressFamily == AddressFamily.InterNetwork), Port);
                    switch (SocketFamilyType)
                    {
                        case FamilyType.Tcp:
                            m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                            break;
                        case FamilyType.Udp:
                            m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                            break;
                    }
                    m_Socket.BeginConnect(m_EndPoint, CallBack_OnConnected, m_Socket);
                }
            }

            public void Send(String data)
            {
               data += EndToken;
                // Convert the string data to byte data using ASCII encoding.
               byte[] byteData = Encoding.ASCII.GetBytes(data);
               m_Socket.BeginSend(byteData, 0, byteData.Length, 0, CallBack_OnSend, m_Socket);
            }

            public void Shutdown()
            {
                m_Socket.Shutdown(SocketShutdown.Receive);
                if (this.OnShutdown != null) OnShutdown(this);
                this.Dispose();
            }

            private void CallBack_OnSend(IAsyncResult ar)
            {
                try
                {
                    m_Socket.EndSend(ar);

                    if (this.OnDataSent != null)
                        OnDataSent(this);

                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }
            }

            private void CallBack_OnConnected(IAsyncResult ar)
            {
                try
                {
                    m_Socket.EndConnect(ar);
                    if (OnConnected != null)
                        OnConnected(this);
                    m_Socket.BeginReceive(m_Data, 0, m_Data.Length, SocketFlags.None, CallBack_OnReceive, m_Socket);
                }
                catch (SocketException ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }
            }

            private void CallBack_OnReceive(IAsyncResult ar)
            {
                try
                {
                    Socket socketAccepted = ar.AsyncState as Socket;
                    int read = socketAccepted.EndReceive(ar);
                    var sb = new StringBuilder();

                    if (read > 0)
                    {
                        sb.Append(Encoding.ASCII.GetString(m_Data, 0, read));
                        socketAccepted.BeginReceive(m_Data, 0, m_Data.Length, SocketFlags.None, CallBack_OnReceive, socketAccepted);
                    }
                    if (sb.Length > 0)
                    {
                        string content = sb.ToString();
                        if (!String.IsNullOrEmpty(EndToken))
                        {
                            int index = content.IndexOf(EndToken);
                            if (index != -1)
                                content = content.Substring(0, index);
                        }
                        if (OnDataReceive != null)
                            OnDataReceive(content, socketAccepted, this);
                    }
                }
                catch (SocketException ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    Console.WriteLine(ex.StackTrace);
                }
            }

            private IPEndPoint m_EndPoint;
            private byte[] m_Data = new byte[65535];
            private Socket m_Socket;
            public void Dispose()
            {
                this.m_Data = null;
                this.m_Socket = null;
                this.m_EndPoint = null;
                GC.Collect();
                GC.SuppressFinalize(this);
            }
        }
    }