BeginAccept(AsyncCallback AsyncCallback, Ojbect state)

//定義IP地址
IPAddress local = IPAddress.Parse("127.0,0,1");
IPEndPoint iep = new IPEndPoint(local,13000);
//創(chuàng)建服務(wù)器的socket對(duì)象
Socket server = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
server.Bind(iep);
server.Listen(20);
server.BeginAccecpt(new AsyncCallback(Accept),server);

void Accept(IAsyncResult iar)
{
 //還原傳入的原始套接字
 Socket MyServer = (Socket)iar.AsyncState;
 //在原始套接字上調(diào)用EndAccept方法，返回新的套接字
 Socket service = MyServer.EndAccept(iar);
}

Socket socket=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp)
IPAddress ip=IPAddress.Parse("127.0.0.1");
IPEndPoint iep=new IPEndPoint(ip,13000);
socket.BeginConnect(iep, new AsyncCallback(Connect),socket);

void Connect(IAsyncResult iar)
{
 Socket client=(Socket)iar.AsyncState;
 try
 {
  client.EndConnect(iar);
 }
 catch (Exception e)
 {
  Console.WriteLine(e.ToString());
 }
 finally
 {

 }
}

public static void DoBeginAccept(TcpListener listner)
{
 //開(kāi)始從客戶(hù)端監(jiān)聽(tīng)連接
 Console.WriteLine("Waitting for a connection");
 //接收連接
 //開(kāi)始準(zhǔn)備接入新的連接，一旦有新連接嘗試則調(diào)用回調(diào)函數(shù)DoAcceptTcpCliet
 listner.BeginAcceptTcpClient(new AsyncCallback(DoAcceptTcpCliet), listner);
}

//處理客戶(hù)端的連接
public static void DoAcceptTcpCliet(IAsyncResult iar)
{
 //還原原始的TcpListner對(duì)象
 TcpListener listener = (TcpListener)iar.AsyncState;

 //完成連接的動(dòng)作，并返回新的TcpClient
 TcpClient client = listener.EndAcceptTcpClient(iar);
 Console.WriteLine("連接成功");
}

public void doBeginConnect(IAsyncResult iar)
{
 Socket client=(Socket)iar.AsyncState;
 //開(kāi)始與遠(yuǎn)程主機(jī)進(jìn)行連接
 client.BeginConnect(serverIP[0],13000,requestCallBack,client);
 Console.WriteLine("開(kāi)始與服務(wù)器進(jìn)行連接");
}
private void requestCallBack(IAsyncResult iar)
{
 try
 {
  //還原原始的TcpClient對(duì)象
  TcpClient client=(TcpClient)iar.AsyncState;
  //
  client.EndConnect(iar);
  Console.WriteLine("與服務(wù)器{0}連接成功",client.Client.RemoteEndPoint);
 }
 catch(Exception e)
 {
  Console.WriteLine(e.ToString());
 }
 finally
 {

 }
}

private static void Send(Socket handler, String data)
{
 // Convert the string data to byte data using ASCII encoding.  
 byte[] byteData = Encoding.ASCII.GetBytes(data);
 // Begin sending the data to the remote device.  
 handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);
}
private static void SendCallback(IAsyncResult ar)
{
 try
 {
  // Retrieve the socket from the state object.  
  Socket handler = (Socket)ar.AsyncState;
  // Complete sending the data to the remote device.  
  int bytesSent = handler.EndSend(ar);
  Console.WriteLine("Sent {0} bytes to client.", bytesSent);
  handler.Shutdown(SocketShutdown.Both);
  handler.Close();
 }
 catch (Exception e)
 {
  Console.WriteLine(e.ToString());
 }
}

private static void Receive(Socket client)
{
 try
 {
  // Create the state object.  
  StateObject state = new StateObject();
  state.workSocket = client;
  // Begin receiving the data from the remote device.  
  client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
 }
 catch (Exception e)
 {
  Console.WriteLine(e.ToString());
 }
}
private static void ReceiveCallback(IAsyncResult ar)
{
 try
 {
  // Retrieve the state object and the client socket  
  // from the asynchronous state object.  
  StateObject state = (StateObject)ar.AsyncState;
  Socket client = state.workSocket;
  // Read data from the remote device.  
  int bytesRead = client.EndReceive(ar);
  if (bytesRead > 0)
  {
   // There might be more data, so store the data received so far.  

   state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
   // Get the rest of the data.  
   client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
  }
  else
  {
   // All the data has arrived; put it in response.  
   if (state.sb.Length > 1)
   {
    response = state.sb.ToString();
   }
   // Signal that all bytes have been received.  
   receiveDone.Set();
  }
 }
 catch (Exception e)
 {
  Console.WriteLine(e.ToString());
 }
}

static void DataHandle(TcpClient client)
{
 TcpClient tcpClient = client;
 //使用TcpClient的GetStream方法獲取網(wǎng)絡(luò)流
 NetworkStream ns = tcpClient.GetStream();
 //檢查網(wǎng)絡(luò)流是否可讀
 if(ns.CanRead)
 {
 //定義緩沖區(qū)
 byte[] read = new byte[1024];
 ns.BeginRead(read,0,read.Length,new AsyncCallback(myReadCallBack),ns); 
 }
 else
 {
 Console.WriteLine("無(wú)法從網(wǎng)絡(luò)中讀取流數(shù)據(jù)");
 }
}

public static void myReadCallBack(IAsyncResult iar)
{
 NetworkStream ns = (NetworkStream)iar.AsyncState;
 byte[] read = new byte[1024];
 String data = "";
 int recv;

 recv = ns.EndRead(iar);
 data = String.Concat(data, Encoding.ASCII.GetString(read, 0, recv));

 //接收到的消息長(zhǎng)度可能大于緩沖區(qū)總大小，反復(fù)循環(huán)直到讀完為止
 while (ns.DataAvailable)
 {
  ns.BeginRead(read, 0, read.Length, new AsyncCallback(myReadCallBack), ns);
 }
 //打印
 Console.WriteLine("您收到的信息是" + data);
}

public static void StartListening()
{
 // Data buffer for incoming data.  
 byte[] bytes = new Byte[1024];
 // Establish the local endpoint for the socket.  
 // The DNS name of the computer  
 // running the listener is "host.contoso.com".  
 //IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
 //IPAddress ipAddress = ipHostInfo.AddressList[0];
 IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
 IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
 // Create a TCP/IP socket.  
 Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
 // Bind the socket to the local  
 //endpoint and listen for incoming connections.  
 try
 {
  listener.Bind(localEndPoint);
  listener.Listen(100);
  while (true)
  {
   // Set the event to nonsignaled state.  
   allDone.Reset();
   // Start an asynchronous socket to listen for connections.  
   Console.WriteLine("Waiting for a connection...");
   listener.BeginAccept(new AsyncCallback(AcceptCallback),listener);
   // Wait until a connection is made before continuing.  
   allDone.WaitOne();
  }
 }
 catch (Exception e)
 {
  Console.WriteLine(e.ToString());
 }
 Console.WriteLine("\nPress ENTER to continue...");
 Console.Read();
}

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
// State object for reading client data asynchronously  
public class StateObject
{
 // Client socket.  
 public Socket workSocket = null;
 // Size of receive buffer.  
 public const int BufferSize = 1024;
 // Receive buffer.  
 public byte[] buffer = new byte[BufferSize];
 // Received data string.  
 public StringBuilder sb = new StringBuilder();
}
public class AsynchronousSocketListener
{
 // Thread signal.  
 public static ManualResetEvent allDone = new ManualResetEvent(false);
 public AsynchronousSocketListener()
 {
 }
 public static void StartListening()
 {
  // Data buffer for incoming data.  
  byte[] bytes = new Byte[1024];
  // Establish the local endpoint for the socket.  
  // The DNS name of the computer  
  // running the listener is "host.contoso.com".  
  //IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
  //IPAddress ipAddress = ipHostInfo.AddressList[0];
  IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
  IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);
  // Create a TCP/IP socket.  
  Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
  // Bind the socket to the local  
  //endpoint and listen for incoming connections.  
  try
  {
   listener.Bind(localEndPoint);
   listener.Listen(100);
   while (true)
   {
    // Set the event to nonsignaled state.  
    allDone.Reset();
    // Start an asynchronous socket to listen for connections.  
    Console.WriteLine("Waiting for a connection...");
    listener.BeginAccept(new AsyncCallback(AcceptCallback),listener);
    // Wait until a connection is made before continuing.  
    allDone.WaitOne();
   }
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
  Console.WriteLine("\nPress ENTER to continue...");
  Console.Read();
 }
 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.  
  StateObject state = new StateObject();
  state.workSocket = handler;
  handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
 }
 public static void ReadCallback(IAsyncResult ar)
 {
  String content = String.Empty;
  // Retrieve the state object and the handler socket  
  // from the asynchronous state object.  
  StateObject state = (StateObject)ar.AsyncState;
  Socket handler = state.workSocket;
  // Read data from the client socket.  
  int bytesRead = handler.EndReceive(ar);
  if (bytesRead > 0)
  {
   // There might be more data, so store the data received so far.  
   state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
   // Check for end-of-file tag. If it is not there, read  
   // more data.  
   content = state.sb.ToString();
   if (content.IndexOf("<EOF>") > -1)
   {
    // All the data has been read from the  
    // client. Display it on the console.  
    Console.WriteLine("Read {0} bytes from socket. \n Data : {1}", content.Length, content);
    // Echo the data back to the client.  
    Send(handler, content);
   }
   else
   {
    // Not all data received. Get more.  
    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReadCallback), state);
   }
  }
 }
 private static void Send(Socket handler, String data)
 {
  // Convert the string data to byte data using ASCII encoding.  
  byte[] byteData = Encoding.ASCII.GetBytes(data);
  // Begin sending the data to the remote device.  
  handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);
 }
 private static void SendCallback(IAsyncResult ar)
 {
  try
  {
   // Retrieve the socket from the state object.  
   Socket handler = (Socket)ar.AsyncState;
   // Complete sending the data to the remote device.  
   int bytesSent = handler.EndSend(ar);
   Console.WriteLine("Sent {0} bytes to client.", bytesSent);
   handler.Shutdown(SocketShutdown.Both);
   handler.Close();
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 public static int Main(String[] args)
 {
  StartListening();
  return 0;
 }
}

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
// State object for receiving data from remote device.  
public class StateObject
{
 // Client socket.  
 public Socket workSocket = null;
 // Size of receive buffer.  
 public const int BufferSize = 256;
 // Receive buffer.  
 public byte[] buffer = new byte[BufferSize];
 // Received data string.  
 public StringBuilder sb = new StringBuilder();
}
public class AsynchronousClient
{
 // The port number for the remote device.  
 private const int port = 11000;
 // ManualResetEvent instances signal completion.  
 private static ManualResetEvent connectDone = new ManualResetEvent(false);
 private static ManualResetEvent sendDone = new ManualResetEvent(false);
 private static ManualResetEvent receiveDone = new ManualResetEvent(false);
 // The response from the remote device.  
 private static String response = String.Empty;
 private 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.  
   Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
   // Connect to the remote endpoint.  
   client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
   connectDone.WaitOne();
   // Send test data to the remote device.  
   Send(client, "This is a test<EOF>");
   sendDone.WaitOne();
   // Receive the response from the remote device.  
   Receive(client);
   receiveDone.WaitOne();
   // Write the response to the console.  
   Console.WriteLine("Response received : {0}", response);
   // Release the socket.  
   client.Shutdown(SocketShutdown.Both);
   client.Close();
   Console.ReadLine();
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 private static void ConnectCallback(IAsyncResult ar)
 {
  try
  {
   // Retrieve the socket from the state object.  
   Socket client = (Socket)ar.AsyncState;
   // Complete the connection.  
   client.EndConnect(ar);
   Console.WriteLine("Socket connected to {0}", client.RemoteEndPoint.ToString());
   // Signal that the connection has been made.  
   connectDone.Set();
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 private static void Receive(Socket client)
 {
  try
  {
   // Create the state object.  
   StateObject state = new StateObject();
   state.workSocket = client;
   // Begin receiving the data from the remote device.  
   client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 private static void ReceiveCallback(IAsyncResult ar)
 {
  try
  {
   // Retrieve the state object and the client socket  
   // from the asynchronous state object.  
   StateObject state = (StateObject)ar.AsyncState;
   Socket client = state.workSocket;
   // Read data from the remote device.  
   int bytesRead = client.EndReceive(ar);
   if (bytesRead > 0)
   {
    // There might be more data, so store the data received so far.  

    state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
    // Get the rest of the data.  
    client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
   }
   else
   {
    // All the data has arrived; put it in response.  
    if (state.sb.Length > 1)
    {
     response = state.sb.ToString();
    }
    // Signal that all bytes have been received.  
    receiveDone.Set();
   }
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 private static void Send(Socket client, String data)
 {
  // Convert the string data to byte data using ASCII encoding.  
  byte[] byteData = Encoding.ASCII.GetBytes(data);
  // Begin sending the data to the remote device.  
  client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client);
 }
 private static void SendCallback(IAsyncResult ar)
 {
  try
  {
   // Retrieve the socket from the state object.  
   Socket client = (Socket)ar.AsyncState;
   // Complete sending the data to the remote device.  
   int bytesSent = client.EndSend(ar);
   Console.WriteLine("Sent {0} bytes to server.", bytesSent);
   // Signal that all bytes have been sent.  
   sendDone.Set();
  }
  catch (Exception e)
  {
   Console.WriteLine(e.ToString());
  }
 }
 public static int Main(String[] args)
 {
  StartClient();
  return 0;
 }
}