IAsyncResult BeginAccept(AsyncCallback callback, object state);

Socket socket = new Socket(                   AddressFamily.InterNetwork,                   SocketType.Stream,                   ProtocolType.Tcp); IPEndPoint iep = new IPEndPoint(IPAddress.Any, 8888); socket.Bind(iep); socket.Listen(5); socket.BeginAccept (new AsyncCallback(CallbackAccept), socket); private void CallbackAccept(IAsyncResult iar) {   Socket server = (Socket)iar.AsyncState;   Socket client = server.EndAccept(iar); }

private List<TcpClientState> clients;

/// <summary>    /// 异步TCP服务器    /// </summary>    public class AsyncTcpServer : IDisposable    {      #region Fields      private TcpListener listener;      private List<TcpClientState> clients;      private bool disposed = false;      #endregion      #region Ctors      /// <summary>      /// 异步TCP服务器      /// </summary>      /// <param name="listenPort">监听的端口</param>      public AsyncTcpServer(int listenPort)        : this(IPAddress.Any, listenPort)      {      }      /// <summary>      /// 异步TCP服务器      /// </summary>      /// <param name="localEP">监听的终结点</param>      public AsyncTcpServer(IPEndPoint localEP)        : this(localEP.Address, localEP.Port)      {      }      /// <summary>      /// 异步TCP服务器      /// </summary>      /// <param name="localIPAddress">监听的IP地址</param>      /// <param name="listenPort">监听的端口</param>      public AsyncTcpServer(IPAddress localIPAddress, int listenPort)      {        Address = localIPAddress;        Port = listenPort;        this.Encoding = Encoding.Default;        clients = new List<TcpClientState>();        listener = new TcpListener(Address, Port);        listener.AllowNatTraversal(true);      }      #endregion      #region Properties      /// <summary>      /// 服务器是否正在运行      /// </summary>      public bool IsRunning { get; private set; }      /// <summary>      /// 监听的IP地址      /// </summary>      public IPAddress Address { get; private set; }      /// <summary>      /// 监听的端口      /// </summary>      public int Port { get; private set; }      /// <summary>      /// 通信使用的编码      /// </summary>      public Encoding Encoding { get; set; }      #endregion      #region Server      /// <summary>      /// 启动服务器      /// </summary>      /// <returns>异步TCP服务器</returns>      public AsyncTcpServer Start()      {        if (!IsRunning)        {          IsRunning = true;          listener.Start();          listener.BeginAcceptTcpClient(            new AsyncCallback(HandleTcpClientAccepted), listener);        }        return this;      }      /// <summary>      /// 启动服务器      /// </summary>      /// <param name="backlog">      /// 服务器所允许的挂起连接序列的最大长度      /// </param>      /// <returns>异步TCP服务器</returns>      public AsyncTcpServer Start(int backlog)      {        if (!IsRunning)        {          IsRunning = true;          listener.Start(backlog);          listener.BeginAcceptTcpClient(            new AsyncCallback(HandleTcpClientAccepted), listener);        }        return this;      }      /// <summary>      /// 停止服务器      /// </summary>      /// <returns>异步TCP服务器</returns>      public AsyncTcpServer Stop()      {        if (IsRunning)        {          IsRunning = false;          listener.Stop();          lock (this.clients)          {            for (int i = 0; i < this.clients.Count; i++)            {              this.clients[i].TcpClient.Client.Disconnect(false);            }            this.clients.Clear();          }        }        return this;      }      #endregion      #region Receive      private void HandleTcpClientAccepted(IAsyncResult ar)      {        if (IsRunning)        {          TcpListener tcpListener = (TcpListener)ar.AsyncState;          TcpClient tcpClient = tcpListener.EndAcceptTcpClient(ar);          byte[] buffer = new byte[tcpClient.ReceiveBufferSize];          TcpClientState internalClient            = new TcpClientState(tcpClient, buffer);          lock (this.clients)          {            this.clients.Add(internalClient);            RaiseClientConnected(tcpClient);          }          NetworkStream networkStream = internalClient.NetworkStream;          networkStream.BeginRead(            internalClient.Buffer,            0,            internalClient.Buffer.Length,            HandleDatagramReceived,            internalClient);          tcpListener.BeginAcceptTcpClient(            new AsyncCallback(HandleTcpClientAccepted), ar.AsyncState);        }      }      private void HandleDatagramReceived(IAsyncResult ar)      {        if (IsRunning)        {          TcpClientState internalClient = (TcpClientState)ar.AsyncState;          NetworkStream networkStream = internalClient.NetworkStream;          int numberOfReadBytes = 0;          try          {            numberOfReadBytes = networkStream.EndRead(ar);          }          catch          {            numberOfReadBytes = 0;          }          if (numberOfReadBytes == 0)          {            // connection has been closed            lock (this.clients)            {              this.clients.Remove(internalClient);              RaiseClientDisconnected(internalClient.TcpClient);              return;            }          }          // received byte and trigger event notification          byte[] receivedBytes = new byte[numberOfReadBytes];          Buffer.BlockCopy(            internalClient.Buffer, 0,            receivedBytes, 0, numberOfReadBytes);          RaiseDatagramReceived(internalClient.TcpClient, receivedBytes);          RaisePlaintextReceived(internalClient.TcpClient, receivedBytes);          // continue listening for tcp datagram packets          networkStream.BeginRead(            internalClient.Buffer,            0,            internalClient.Buffer.Length,            HandleDatagramReceived,            internalClient);        }      }      #endregion      #region Events      /// <summary>      /// 接收到数据报文事件      /// </summary>      public event EventHandler<TcpDatagramReceivedEventArgs<byte[]>> DatagramReceived;      /// <summary>      /// 接收到数据报文明文事件      /// </summary>      public event EventHandler<TcpDatagramReceivedEventArgs<string>> PlaintextReceived;      private void RaiseDatagramReceived(TcpClient sender, byte[] datagram)      {        if (DatagramReceived != null)        {          DatagramReceived(this, new TcpDatagramReceivedEventArgs<byte[]>(sender, datagram));        }      }      private void RaisePlaintextReceived(TcpClient sender, byte[] datagram)      {        if (PlaintextReceived != null)        {          PlaintextReceived(this, new TcpDatagramReceivedEventArgs<string>(            sender, this.Encoding.GetString(datagram, 0, datagram.Length)));        }      }      /// <summary>      /// 与客户端的连接已建立事件      /// </summary>      public event EventHandler<TcpClientConnectedEventArgs> ClientConnected;      /// <summary>      /// 与客户端的连接已断开事件      /// </summary>      public event EventHandler<TcpClientDisconnectedEventArgs> ClientDisconnected;      private void RaiseClientConnected(TcpClient tcpClient)      {        if (ClientConnected != null)        {          ClientConnected(this, new TcpClientConnectedEventArgs(tcpClient));        }      }      private void RaiseClientDisconnected(TcpClient tcpClient)      {        if (ClientDisconnected != null)        {          ClientDisconnected(this, new TcpClientDisconnectedEventArgs(tcpClient));        }      }      #endregion      #region Send      /// <summary>      /// 发送报文至指定的客户端      /// </summary>      /// <param name="tcpClient">客户端</param>      /// <param name="datagram">报文</param>      public void Send(TcpClient tcpClient, byte[] datagram)      {        if (!IsRunning)          throw new InvalidProgramException("This TCP server has not been started.");        if (tcpClient == null)          throw new ArgumentNullException("tcpClient");        if (datagram == null)          throw new ArgumentNullException("datagram");        tcpClient.GetStream().BeginWrite(          datagram, 0, datagram.Length, HandleDatagramWritten, tcpClient);      }      private void HandleDatagramWritten(IAsyncResult ar)      {        ((TcpClient)ar.AsyncState).GetStream().EndWrite(ar);      }      /// <summary>      /// 发送报文至指定的客户端      /// </summary>      /// <param name="tcpClient">客户端</param>      /// <param name="datagram">报文</param>      public void Send(TcpClient tcpClient, string datagram)      {        Send(tcpClient, this.Encoding.GetBytes(datagram));      }      /// <summary>      /// 发送报文至所有客户端      /// </summary>      /// <param name="datagram">报文</param>      public void SendAll(byte[] datagram)      {        if (!IsRunning)          throw new InvalidProgramException("This TCP server has not been started.");        for (int i = 0; i < this.clients.Count; i++)        {          Send(this.clients[i].TcpClient, datagram);        }      }      /// <summary>      /// 发送报文至所有客户端      /// </summary>      /// <param name="datagram">报文</param>      public void SendAll(string datagram)      {        if (!IsRunning)          throw new InvalidProgramException("This TCP server has not been started.");        SendAll(this.Encoding.GetBytes(datagram));      }      #endregion      #region IDisposable Members      /// <summary>      /// Performs application-defined tasks associated with freeing,      /// releasing, or resetting unmanaged resources.      /// </summary>      public void Dispose()      {        Dispose(true);        GC.SuppressFinalize(this);      }      /// <summary>      /// Releases unmanaged and - optionally - managed resources      /// </summary>      /// <param name="disposing"><c>true</c> to release      /// both managed and unmanaged resources; <c>false</c>      /// to release only unmanaged resources.</param>      protected virtual void Dispose(bool disposing)      {        if (!this.disposed)        {          if (disposing)          {            try            {              Stop();              if (listener != null)              {                listener = null;              }            }            catch (SocketException ex)            {              ExceptionHandler.Handle(ex);            }          }          disposed = true;        }      }      #endregion    }

class Program    {      static AsyncTcpServer server;      static void Main(string[] args)      {        LogFactory.Assign(new ConsoleLogFactory());        server = new AsyncTcpServer(9999);        server.Encoding = Encoding.UTF8;        server.ClientConnected +=          new EventHandler<TcpClientConnectedEventArgs>(server_ClientConnected);        server.ClientDisconnected +=          new EventHandler<TcpClientDisconnectedEventArgs>(server_ClientDisconnected);        server.PlaintextReceived +=          new EventHandler<TcpDatagramReceivedEventArgs<string>>(server_PlaintextReceived);        server.Start();        Console.WriteLine("TCP server has been started.");        Console.WriteLine("Type something to send to client...");        while (true)        {          string text = Console.ReadLine();          server.SendAll(text);        }      }      static void server_ClientConnected(object sender, TcpClientConnectedEventArgs e)      {        Logger.Debug(string.Format(CultureInfo.InvariantCulture,          "TCP client {0} has connected.",          e.TcpClient.Client.RemoteEndPoint.ToString()));      }      static void server_ClientDisconnected(object sender, TcpClientDisconnectedEventArgs e)      {        Logger.Debug(string.Format(CultureInfo.InvariantCulture,          "TCP client {0} has disconnected.",          e.TcpClient.Client.RemoteEndPoint.ToString()));      }      static void server_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs<string> e)      {        if (e.Datagram != "Received")        {          Console.Write(string.Format("Client : {0} --> ",            e.TcpClient.Client.RemoteEndPoint.ToString()));          Console.WriteLine(string.Format("{0}", e.Datagram));          server.Send(e.TcpClient, "Server has received you text : " + e.Datagram);        }      }    }