Socket 异步多线程TCP通信
设计要求：客户、服务器模式，客户端数量很多，需要服务器端使用异步多线程socket接收和发送
哪位有应用的例子可以参考？

下面是MSDN上异步socket的例子，有对这个例子的应用代码也行

VB.NET code

 
 Imports System 
 Imports System.Net 
 Imports System.Net.Sockets 
 Imports System.Text 
 Imports System.Threading 
 Imports Microsoft.VisualBasic 
  
 ' State object for reading client data asynchronously 
  
 Public Class StateObject 
     ' Client  socket. 
     Public workSocket As Socket = Nothing 
     ' Size of receive buffer. 
     Public Const BufferSize As Integer = 1024 
     ' Receive buffer. 
     Public buffer(BufferSize) As Byte 
     ' Received data string. 
     Public sb As New StringBuilder 
 End Class 'StateObject 
  
  
 Public Class AsynchronousSocketListener 
     ' Thread signal. 
     Public Shared allDone As New ManualResetEvent(False) 
  
     ' This server waits for a connection and then uses  asychronous operations to 
     ' accept the connection, get data from the connected client,  
     ' echo that data back to the connected client. 
     ' It then disconnects from the client and waits for another client.  
     Public Shared Sub Main() 
         ' Data buffer for incoming data. 
         Dim bytes() As Byte = New [Byte](1023) {} 
  
         ' Establish the local endpoint for the socket. 
         Dim ipHostInfo As IPHostEntry = Dns.Resolve(Dns.GetHostName()) 
         Dim ipAddress As IPAddress = ipHostInfo.AddressList(0) 
         Dim localEndPoint As New IPEndPoint(ipAddress, 11000) 
  
         ' Create a TCP/IP socket. 
         Dim listener As New Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp) 
  
         ' Bind the socket to the local endpoint and listen for incoming connections. 
         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(AddressOf AcceptCallback), listener) 
  
             ' Wait until a connection is made and processed before continuing. 
             allDone.WaitOne() 
         End While 
     End Sub 'Main 
  
  
     Public Shared Sub AcceptCallback(ByVal ar As IAsyncResult) 
         ' Get the socket that handles the client request. 
         Dim listener As Socket = CType(ar.AsyncState, Socket) 
         ' End the operation. 
         Dim handler As Socket = listener.EndAccept(ar) 
  
         ' Create the state object for the async receive. 
         Dim state As New StateObject 
         state.workSocket = handler 
         handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, New AsyncCallback(AddressOf ReadCallback), state)  
 
     End Sub 'AcceptCallback 
  
  
     Public Shared Sub ReadCallback(ByVal ar As IAsyncResult) 
         Dim content As String = String.Empty 
  
         ' Retrieve the state object and the handler socket 
         ' from the asynchronous state object. 
         Dim state As StateObject = CType(ar.AsyncState, StateObject) 
         Dim handler As Socket = state.workSocket 
  
         ' Read data from the client socket.  
         Dim bytesRead As Integer = handler.EndReceive(ar) 
  
         If bytesRead > 0 Then 
             ' 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 Then 
                 ' All the data has been read from the  
                 ' client. Display it on the console. 
                 Console.WriteLine("Read {0} bytes from socket. " + vbLf + " 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(AddressOf ReadCallback), state) 
             End If 
         End If 
     End Sub 'ReadCallback 
  
     Private Shared Sub Send(ByVal handler As Socket, ByVal data As String) 
         ' Convert the string data to byte data using ASCII encoding. 
         Dim byteData As Byte() = Encoding.ASCII.GetBytes(data) 
  
         ' Begin sending the data to the remote device. 
         handler.BeginSend(byteData, 0, byteData.Length, 0, New AsyncCallback(AddressOf SendCallback), handler) 
     End Sub 'Send 
  
  
     Private Shared Sub SendCallback(ByVal ar As IAsyncResult) 
         ' Retrieve the socket from the state object. 
         Dim handler As Socket = CType(ar.AsyncState, Socket) 
  
         ' Complete sending the data to the remote device. 
         Dim bytesSent As Integer = handler.EndSend(ar) 
         Console.WriteLine("Sent {0} bytes to client.", bytesSent) 
  
         handler.Shutdown(SocketShutdown.Both) 
         handler.Close() 
         ' Signal the main thread to continue. 
         allDone.Set() 
     End Sub 'SendCallback 
 End Class 'AsynchronousSocketListener 
  
 

我也和楼主在做相同的东西，一直也没找到很好的例子
同样一个TCP连接访问 可能有好几种 代码解决形式
要是从头，开始一点点弄可能需要 1，2个星期
反正是比较麻烦 而且懂得用Sokcet的人也不是很多。很不好问
[解决办法]
listener.BeginAccept为接受用户的连接请求，然后马上自动执行回调函数AcceptCallback，建立新的socket进行数据的接收等处理
这么做的原因是开启不同的线程处理不同的事务，达到线程的同步
[解决办法]
LZ 先看线程吧

异步其实不过是一个线程池~
listener.BeginAccept(New AsyncCallback(AddressOf AcceptCallback), listener)
这句话的意思是
监听开始接受请求 也就是异步的 开始
AsyncCallback 是一个委托 ,就是一个回调
当监听结束的时候 会影响IAsyncState 的
这里影响的就是listener 说 明 监听完毕
可就要 listener.End....
为什么叫异步,因为 你在
listener.BeginAccept(New AsyncCallback(AddressOf AcceptCallback), listener)
加入异步以后
可以利用主线程做 其他的事情
[解决办法]
.net交流群 26165524