异步客户端套接字示例
下面的示例程序创建一个连接到服务器的客户端。该客户端是用异步套接字生成的，因此在等待服务器返回响应时不挂起客户端应用程序的执行。该应用程序将字符串发送到服务器，然后在控制台显示该服务器返回的字符串。
c#
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(host.contoso.com); 
ipaddress ipaddress = iphostinfo.addresslist[0]; 
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(); 
} 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; 
} 
} 
异步服务器套接字示例 下面的示例程序创建一个接收来自客户端的连接请求的服务器。该服务器是用异步套接字生成的， 
因此在等待来自客户端的连接时不挂起服务器应用程序的执行。该应用程序接收来自客户端的字符串， 
在控制台显示该字符串，然后将该字符串回显到客户端。来自客户端的字符串必须包含字符串“<eof>”， 
以发出表示消息结尾的信号。
c# 
 复制代码
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]; 
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; 
} 
} 
 以上就是c#(socket)异步套接字代码示例的内容。