/// <summary>
        /// AcceptCallback是回调函数
        /// </summary>
        /// <param name="ar"></param>
        public static void AcceptCallback(IAsyncResult ar)
        {
            // 接收连接后，按照前面的定义会执行该函数，首先就是让主线程继续往下执行
            allDone.Set();
            count++;
            Console.WriteLine("连接已经建立");

            try
            {
                //将接收的连接传递进来
                Socket listener = (Socket)ar.AsyncState;

                //调用EndAccept方法表示连接已经建立，建立的连接就是该方法的返回的对象
                Socket handler = listener.EndAccept(ar);

                //保存当前会话的Socket信息
                StateObject state = new StateObject();

                state.socket = handler;

                //这里又出现了类似的定义。可以看出，BeginReceive函数的参数和同步里面Receive函数的参数前面是相同的
                //只是后面多出了两个：定义在BeginReceive函数执行完毕以后所要执行的操作
                //这里定义的是ReadCallback函数
                handler.BeginReceive(state.buffer, 0, StateObject.bufferSize, 0,
                    new AsyncCallback(ReadCallback), state);

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

        public void AcceptCallback(IAsyncResult ar)
        {
            // Signal the main thread to continue.
            allDone.Set();

            // Get the socket that handles the client request.
            Socket listener = (Socket)ar.AsyncState;
            Socket handler = listener.EndAccept(ar);
            handler.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, 1);

            // Create the state object.
            StateObject state = new StateObject();
            state.workSocket = handler;

            lock (__syncroot)
            {
                if (clients.Count < 2)
                {
                    Console.WriteLine("Accepting client {0}", clients.Count);
                    clients[handler.Handle] = state;
                    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
                }
                else
                {
                    handler.Shutdown(SocketShutdown.Both);
                    handler.Close();
                }
            }
        }

        public static void AcceptCallback(IAsyncResult ar)
        {
            // Signal the main thread to continue.
            AllDone.Set();

            // Get the socket that handles the client request.
            Socket listener = (Socket) ar.AsyncState;
            Socket handler = listener.EndAccept(ar);

            // Create the state object.
            bool wasLoogedIn = false;
            foreach (var stateObject in Clients)
            {
                if ((stateObject.WorkSocket.RemoteEndPoint as IPEndPoint).Address.Address ==
                    (handler.RemoteEndPoint as IPEndPoint).Address.Address)
                {
                    wasLoogedIn = true;
                    ClientState = stateObject;
                    ClientState.WorkSocket = handler;
                    break;
                }
            }
            if (!wasLoogedIn)
            {
                ClientState = new StateObject();
                ClientState.WorkSocket = handler;
                Clients.Add(ClientState);
            }
            handler.BeginReceive(ClientState.Buffer, 0, StateObject.BufferSize, 0,
                                 ReadCallback, ClientState);
        }

        public void Receive()
        {
            try
            {
                connectDone.WaitOne();
                Console.WriteLine("Start to Listening");
                while (true)
                {
                    receiveDone.Reset();

                    // Create the state object.
                    StateObject state = new StateObject();
                    state.workSocket = server;

                    // Begin receiving the data from the remote device.
                    server.BeginReceive(state.recBuffer, 0, StateObject.BufferSize, 0,
                        new AsyncCallback(ReceiveCallback), state);

                    receiveDone.WaitOne();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

 public void OnReceive(IAsyncResult asyncResult)
 {
     try
     {
         Console.WriteLine("Got some data...");
         StateObject so = (StateObject)asyncResult.AsyncState;
         Socket s = so.workSocket;
         IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
         EndPoint tempRemoteEP = (EndPoint)sender;
         int read = s.EndReceiveFrom(asyncResult, ref tempRemoteEP);
         Console.WriteLine("Read is {0}", read);
         if (read > 0)
         {
             StateObject processState = new StateObject();
             processState.endPoint = tempRemoteEP;
             processState.buffer = so.buffer;
             processState.workSocket = s;
             processState.recvSize = read;
             processState.sb.Append(Encoding.ASCII.GetString(so.buffer, 0, read));
             ProcessBuffer(processState);
         }
     }
     catch (Exception e)
     {
         Console.WriteLine("Exception occurred in OnReceive {0}", e.Message);
         Console.WriteLine(e.StackTrace);
     }
     finally
     {
         allDone.Set();
     }
 }

        public SyncSocClient(string _ipAddress, int port, int timeout)
        {
            try
            {
                IPAddress ipAddress = System.Net.IPAddress.Parse(_ipAddress);
                mPort = port;
                remoteEP = new IPEndPoint(ipAddress, mPort);

                mSender = new Socket(AddressFamily.InterNetwork,
                                        SocketType.Stream, ProtocolType.Tcp);

                if (timeout > 0)
                {
                    mSender.ReceiveTimeout = timeout;
                    mSender.SendTimeout = timeout;
                }
                //mSender.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, timeout);

                // The socket will linger for 10 seconds after Socket.Close is called.
                LingerOption lingerOption = new LingerOption(true, 10);

                mSender.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, lingerOption);

                stateObj = new StateObject(mSender);
            }
            catch (Exception e)
            {
                setErrorMessage(e, string.Format("소켓생성Error ip[{0}]/port[{1}]/timeout[{2}]]",_ipAddress,port,timeout));
                Logger.error(e.ToString());
            }
        }

        private async Task OnConnectAsync(TcpClient tcpClient, StateObject tcpState)
        {
            // Start a transfer task
            var transferTask = OnTransferAsync(tcpClient, tcpState);

            // lock it as this is critial path
            lock (_lock)
                _connections.Add(transferTask);

            try
            {
                await transferTask;

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
            finally
            {
                lock (_lock)
                    _connections.Remove(transferTask);
            }

        }

        // This method instantiate the tcp server
        public async Task StartListener(StateObject tcpState)
        {
            var TcpServer = TcpListener.Create(1000);

            // this if statement differentiates between a server and a client's server
            if (tcpState.ClientType == false)
            {
                Console.WriteLine("Creating server on port {0}", 1000);
                TcpServer = TcpListener.Create(1000);

            }
            else {
                TcpServer = TcpListener.Create(tcpState.Port);
            }

            TcpServer.Start(100);
            while (true)
            {
                var TcpClient = await TcpServer.AcceptTcpClientAsync();
                var task = OnConnectAsync(TcpClient, tcpState);
                if (task.IsFaulted)
                    task.Wait();
            }
            //Console.WriteLine("Server is closing down");

        }

        public static void AcceptCallback(IAsyncResult ar)
        {
            StateObject state = null;
            TcpServer c = (TcpServer)ar.AsyncState;
            try
            {
                if (c == null) return;
                Socket listener = (Socket)c.m_Socket;
                Socket handler = listener.EndAccept(ar);
                c.onConnect(handler);
                state = new StateObject();
                state.s = handler;
                state.c = (TcpServer)c;
                handler.BeginReceive(state.buffer, 0, state.buffer.Length, 0, new AsyncCallback(ReadCallBack), state);

                listener.BeginAccept(new AsyncCallback(AcceptCallback), c);
            }
            catch (System.Exception ex)
            {
                if (state != null)
                {
                    state.c.onClose(state.s);

                    state.s.Dispose();
                }
            }
        }

 public override List<Hex> Targets(StateObject s)
 {
     List<Hex> targets = new List<Hex>();
     s.Caster.Base.Hex.Adjacent(GameControl.gameControl.GridControl.Map).ForEach(h => h.Adjacent(GameControl.gameControl.GridControl.Map).ForEach(he => targets.Add(he)));
     targets.RemoveAll(h => h.Unit != null);
     return targets;
 }

        public void AcceptCallback(IAsyncResult ar)
        {
            //System.Threading.Thread.Sleep(100);
            // Signal the main thread to continue.
            allDone.Set();

            // Get the socket that handles the client request.
            Socket listener = (Socket)ar.AsyncState;
            Socket handler = listener.EndAccept(ar);

            // Create the state object.
            StateObject state = new StateObject();
            state.workSocket = handler;
            handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                new AsyncCallback(ReadCallback), state);

            parent.eventFromMainForm += delegate(object sender, SocketEventArgs e)
            {
                if ((((IPEndPoint)handler.RemoteEndPoint).Address.ToString() == e.address) && (handler.Connected))
                {
                    Send(handler, e.programm + "<EOC>");
                    sendDone.WaitOne();
                    Send(handler, e.parameters + "<EOPN>");
                    sendDone.WaitOne();
                    Send(handler, "<SUBMIT>");
                    sendDone.WaitOne();
                }
                else showM("Handler is offline");
            };
        }

    public static void StartClient()
    {
        // Connect to a remote device.
        try
        {

            // Establish the remote endpoint for the socket.
            // The name of the
            // remote device is "host.contoso.com".
            //IPHostEntry ipHostInfo = Dns.Resolve("user");
            //IPAddress ipAddress = ipHostInfo.AddressList[0];
            IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
            IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
            // Create a TCP/IP socket.
            client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            // Connect to the remote endpoint.
            client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);

            state = new StateObject();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

        private async Task StartReceiving(StateObject state)
        {
            if (_isDisposed) return;
            if (!_socket.Connected) return;

            _logger.Info("Receiving message...");

            var args = new SocketAsyncEventArgs();
            args.SetBuffer(new byte[0x1000], 0, 0x1000);
            var awaitable = new SocketAwaitable(args);

            while (true)
            {
                await _socket.ReceiveAsync(awaitable);
                var bytesRead = args.BytesTransferred;
                if (bytesRead <= 0) break;

                _logger.Info(string.Format("Bytes read: {0}", bytesRead));
                if (awaitable.EventArgs.Buffer[0] == _framingProtocol.StartFrame || state.StartedReceiving)
                {
                    state.Append(Encoding.ASCII.GetString(awaitable.EventArgs.Buffer, 0, bytesRead));
                }

                if (awaitable.EventArgs.Buffer[bytesRead - 1] == _framingProtocol.EndFrame) // We're done
                {
                    InvokeMessageReceived(state.ToString());
                }
            }
        }

        private void bomba1_DoWork(object sender, DoWorkEventArgs e)
        {
            Socket listener = new Socket(
                AddressFamily.InterNetwork,
                SocketType.Stream,
                ProtocolType.Tcp
            );

            String data = null;

            listener.Bind(bomba1EndPoint);
            listener.Listen(1);

            // Create the state object.
            sBomba1 = new StateObject();
            sBomba1.bomba = bomba1;
            sBomba1.workSocket = listener;

            while (true)
            {
                listener.Accept();
                bomba1Status.Text = "Bomba 1 conectada";

                while (true)
                {
                    int bytesRec = listener.Receive(sBomba1.buffer);
                    data += Encoding.ASCII.GetString(sBomba1.buffer, 0, bytesRec);
                    bomba1.ReportProgress(1, sBomba1);
                }
            }
        }

 public void Setup(StateObject s, SpellCard target, float delay)
 {
     this.s = s;
     this.target = target;
     this.delay = delay;
     invoked = true;
 }

 /// <summary>
 ///  Thread for session with PythonServer
 /// </summary>
 private void Run()
 {
     try
     {
         // Build listener for python engine
         listener = new TcpListener(9669);
         listener.Start();
         //  Wait connection from python engine and if successful then create new socket to python engine
         pythonClient = listener.AcceptTcpClient();
         mainForm.PrintToLog(DateTime.Now.ToShortTimeString() + " :  Server trying start...", Color.Black);
         listener.Stop(); // stop listening because python engine connected to GUI
         flagRun = true;
         // Asynchronic StateObject
         StateObject stateObject = new StateObject();
         stateObject.workSocket = pythonClient.Client;
         // Begins to asynchronously receive data from a connected socket with  python engine
         pythonClient.Client.BeginReceive(stateObject.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(Read_Callback), stateObject);
     }
     catch (SocketException se)
     {
         mainForm.PrintToLog(se.Message, Color.Red);
     }
     catch (Exception e)
     {
         mainForm.PrintToLog(e.Message, Color.Red);
     }
 }

        public void StartListening()
        {
            EndPoint localEp = ( EndPoint )_iep;
            Socket listener = new Socket( AddressFamily.InterNetwork,
                                          SocketType.Dgram,
                                          ProtocolType.Udp );
            try
            {
                listener.Bind( localEp );
                while ( true )
                {
                    allDone.Reset();
                    StateObject so = new StateObject();
                    so.workSocket = listener;
                    Console.WriteLine( "Waiting for a connection..." );
                    IAsyncResult result =
                    listener.BeginReceiveFrom( so.buffer,
                                              0,
                                              StateObject.BUFFER_SIZE,
                                              SocketFlags.None,
                                              ref localEp,
                                              new AsyncCallback( this.OnReceive ), so );
                    allDone.WaitOne();
                }

            }
            catch ( Exception e )
            {
                Console.WriteLine( e.ToString() );
            }
        }

        private static void NewComingConnection(IAsyncResult result)
        {
            try
            {

                Socket s = result.AsyncState as Socket;
                StateObject state = new StateObject();
                int bytesTransferred = 0;
                byte[] data = null;
                Socket handler = s.EndAccept(out data, out bytesTransferred, result);
                //first 4 bytes data will be in data.  i don't know why bytesTransferrd is 56

                state.CommandType = (CommandType)BitConverter.ToInt32(data, 0);
                state.WorkSocket = handler;
                Console.WriteLine("New Connection commandType:" + state.CommandType);

                HandleCommandType(state);

            }
            catch (SocketException ex)
            {

            }
            finally
            {
                allDone.Set();
            }
        }

 public void Receive(StateObject state = null, AsyncCallback asyncCallBack = null)
 {
     if (state == null) { state = new StateObject(); }
     if (asyncCallBack == null) { asyncCallBack = new AsyncCallback(ReceiveCallback); }
     state.WorkSocket = socket;
     socket.BeginReceive(state.Buffer, 0, state.BufferSize, 0, asyncCallBack, state);
 }

        static int Main(string[] args)
        {
            // Коннектимся
            byte[] addr = new byte[4];
            addr[0] = 192;
            addr[1] = 168;
            addr[2] = 1;
            addr[3] = 200;

            client.BeginConnect(new IPAddress(addr), port, new AsyncCallback(ConnectCallback), client);

            while(!client.Connected) { };

            StateObject state = new StateObject();
            state.workSocket = client;

            // Настраиваемся на приём
            client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);

            while(true)
            {
                string data = Console.ReadLine();
                if(data == "close")
                {
                    client.Close();
                    while(true) { };
                }
                Send(client, ":" + data + "\x0d\x0a");
            };

            return 0;
        }