C# Socket编程 同步以及异步通信

SocketType

ProtocolType

描述

Stream

Tcp

面向连接

Dgram

Udp

面向无连接

Raw

Icmp

网际消息控制

Raw

Raw

基础传输协议

Socket类的公共属性：

属性名

描述

AddressFamily

获取Socket的地址族

Available

获取已经从网络接收且可供读取的数据量

Blocking

获取或设置一个值，只是socket是否处于阻塞模式

Connected

获取一个值，指示当前连接状态

Handle

获取socket的操作系统句柄

LocalEndPoint

获取本地终端EndPoint

RemoteEndPoint

获取远程终端EndPoint

ProtocolType

获取协议类型

SocketType

获取SocketType类型

Socket常用方法：

Bind(EndPoint)

服务器端套接字需要绑定到特定的终端，客户端也可以先绑定再请求连接

Listen(int)

监听端口，其中parameters表示最大监听数

Accept()

接受客户端链接，并返回一个新的链接，用于处理同客户端的通信问题

Send()

发送数据

Send(byte[])

简单发送数据

Send(byte[],SocketFlag)

使用指定的SocketFlag发送数据

Send(byte[], int, SocketFlag)

使用指定的SocketFlag发送指定长度数据

Send(byte[], int, int, SocketFlag)

使用指定的SocketFlag，将指定字节数的数据发送到已连接的socket(从指定偏移量开始)

Receive()

接受数据

Receive(byte[])

简单接受数据

Receive (byte[],SocketFlag)

使用指定的SocketFlag接受数据

Receive (byte[], int, SocketFlag)

使用指定的SocketFlag接受指定长度数据

Receive (byte[], int, int, SocketFlag)

使用指定的SocketFlag，从绑定的套接字接收指定字节数的数据，并存到指定偏移量位置的缓冲区

Connect(EndPoint)

连接远程服务器

ShutDown(SocketShutDown)

禁用套接字，其中SocketShutDown为枚举，Send禁止发送，Receive为禁止接受，Both为两者都禁止

Close()

关闭套接字，释放资源

异步通信方法：

BeginAccept(AsynscCallBack,object)

开始一个一步操作接受一个连接尝试。参数：一个委托。一个对象。对象包含此请求的状态信息。其中回调方法中必须使用EndAccept方法。应用程序调用BegineAccept方法后，系统会使用单独的线程执行指定的回调方法并在EndAccept上一直处于阻塞状态，直至监测到挂起的链接。EndAccept会返回新的socket对象。供你来同远程主机数据交互。不能使用返回的这个socket接受队列中的任何附加连接。调用BeginAccept当希望原始线程阻塞的时候，请调用WaitHandle.WaitOne方法。当需要原始线程继续执行时请在回调方法中使用ManualResetEvent的set方法

BeginConnect(EndPoint, AsyncCallBack, Object)

回调方法中必须使用EndConnect()方法。Object中存储了连接的详细信息。

BeginSend(byte[], SocketFlag, AsyncCallBack, Object)

BegineReceive(byte[], SocketFlag, AsyncCallBack, Object)

BegineDisconnect(bool, AsyncCallBack, Object)

同步通信：

预定义结构体，同步通信没有多线程异步委托回调，所以无需预定义结构体

客户端Client：

classProgram

{

staticvoidMain()

{

try{

intport = 2000;

stringhost ="127.0.0.1";

IPAddressip =IPAddress.Parse(host);

IPEndPointipe =newIPEndPoint(ip, port);//把ip和端口转化为IPEndPoint实例

Socketc =newSocket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);//创建一个Socket

Console.WriteLine("Conneting...");

c.Connect(ipe);//连接到服务器

stringsendStr ="hello!This is a socket test";

byte[] bs =Encoding.ASCII.GetBytes(sendStr);

Console.WriteLine("Send Message");

c.Send(bs, bs.Length, 0);//发送测试信息

stringrecvStr ="";

byte[] recvBytes =newbyte[1024];

intbytes;

bytes = c.Receive(recvBytes, recvBytes.Length, 0);//从服务器端接受返回信息

recvStr +=Encoding.ASCII.GetString(recvBytes, 0, bytes);

Console.WriteLine("Client Get Message:{0}", recvStr);//显示服务器返回信息

c.Close();

}

catch(ArgumentNullExceptione){

Console.WriteLine("ArgumentNullException: {0}", e);

}

catch(SocketExceptione){

Console.WriteLine("SocketException: {0}", e);

}

Console.WriteLine("Press Enter to Exit");

Console.ReadLine();

}

}

服务器端：

classProgram

{

staticvoidMain()

{

try{

intport = 2000;

stringhost ="127.0.0.1";

IPAddressip =IPAddress.Parse(host);

IPEndPointipe =newIPEndPoint(ip, port);

Sockets =newSocket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);//创建一个Socket类

s.Bind(ipe);//绑定2000端口

s.Listen(0);//开始监听

Console.WriteLine("Wait for connect");

Sockettemp = s.Accept();//为新建连接创建新的Socket。

Console.WriteLine("Get a connect");

stringrecvStr ="";

byte[] recvBytes =newbyte[1024];

intbytes;

bytes = temp.Receive(recvBytes, recvBytes.Length, 0);//从客户端接受信息

recvStr +=Encoding.ASCII.GetString(recvBytes, 0, bytes);

Console.WriteLine("Server Get Message:{0}", recvStr);//把客户端传来的信息显示出来

stringsendStr ="Ok!Client Send Message Sucessful!";

byte[] bs =Encoding.ASCII.GetBytes(sendStr);

temp.Send(bs, bs.Length, 0);//返回客户端成功信息

temp.Close();

s.Close();

}

catch(ArgumentNullExceptione){

Console.WriteLine("ArgumentNullException: {0}", e);}

catch(SocketExceptione){

Console.WriteLine("SocketException: {0}", e);}

Console.WriteLine("Press Enter to Exit");

Console.ReadLine();

}

}

异步通信：

客户端Client：

预定义结构体，用于异步委托之间的传递。用户根据自己需要定制即可

publicclassStateObject

{

// Client socket.

publicSocketworkSocket =null;

// Size of receive buffer.

publicconstintBufferSize = 256;

// Receive buffer.

publicbyte[] buffer =newbyte[BufferSize];

// Received data string.

publicStringBuildersb =newStringBuilder();

}

正文：

publicclassAsynchronousClient

{

// The port number for the remote device.

privateconstintport = 11000;

// ManualResetEvent instances signal completion.

privatestaticManualResetEventconnectDone =newManualResetEvent(false);

privatestaticManualResetEventsendDone =newManualResetEvent(false);

privatestaticManualResetEventreceiveDone =newManualResetEvent(false);

// The response from the remote device.

privatestaticStringresponse =String.Empty;

privatestaticvoidStartClient(){

// Connect to a remote device.

try{

// Establish the remote endpoint for the socket.

// The name of the remote device is "host.contoso.com".

IPHostEntryipHostInfo =Dns.Resolve("host.contoso.com");

IPAddressipAddress = ipHostInfo.AddressList[0];

IPEndPointremoteEP =newIPEndPoint(ipAddress, port);

// Create a TCP/IP socket.

Socketclient =newSocket(AddressFamily.InterNetwork,

SocketType.Stream,ProtocolType.Tcp);

// Connect to the remote endpoint.

client.BeginConnect(remoteEP,

newAsyncCallback(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(Exceptione){

Console.WriteLine(e.ToString());}

}

privatestaticvoidConnectCallback(IAsyncResultar)

{

try{

// Retrieve the socket from the state object.

Socketclient = (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(Exceptione){

Console.WriteLine(e.ToString());}

}

privatestaticvoidReceive(Socketclient)

{

try{

// Create the state object.

StateObjectstate =newStateObject();

state.workSocket = client;

// Begin receiving the data from the remote device.

client.BeginReceive(state.buffer, 0,StateObject.BufferSize, 0,

newAsyncCallback(ReceiveCallback), state);

}

catch(Exceptione){

Console.WriteLine(e.ToString());}

}

privatestaticvoidReceiveCallback(IAsyncResultar)

{

try{

// Retrieve the state object and the client socket

// from the asynchronous state object.

StateObjectstate = (StateObject)ar.AsyncState;

Socketclient = state.workSocket;

// Read data from the remote device.

intbytesRead = 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,

newAsyncCallback(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(Exceptione){

Console.WriteLine(e.ToString());}

}

privatestaticvoidSend(Socketclient,Stringdata)

{

// 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,

newAsyncCallback(SendCallback), client);

}

privatestaticvoidSendCallback(IAsyncResultar)

{

try{

// Retrieve the socket from the state object.

Socketclient = (Socket)ar.AsyncState;

// Complete sending the data to the remote device.

intbytesSent = client.EndSend(ar);

Console.WriteLine("Sent {0} bytes to server.", bytesSent);

// Signal that all bytes have been sent.

sendDone.Set();

}

catch(Exceptione){

Console.WriteLine(e.ToString());}

}

publicstaticintMain(String[] args)

{

StartClient();

return0;

}

}

服务器端Server：

预定义结构体，用于异步委托之间的传递。同客户端的一致。不再赘述

正文：

// State object for reading client data asynchronously

publicclassAsynchronousSocketListener

{

// Thread signal.

publicstaticManualResetEventallDone =newManualResetEvent(false);

publicAsynchronousSocketListener(){}

publicstaticvoidStartListening()

{

// Data buffer for incoming data.

byte[] bytes =newByte[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());

IPHostEntryipHostInfo =Dns.Resolve("127.0.0.1");

IPAddressipAddress = ipHostInfo.AddressList[0];

IPEndPointlocalEndPoint =newIPEndPoint(ipAddress, 11000);

// Create a TCP/IP socket.

Socketlistener =newSocket(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(newAsyncCallback(AcceptCallback),listener);

// Wait until a connection is made before continuing.

allDone.WaitOne();

}

}

catch(Exceptione){

Console.WriteLine(e.ToString());}

Console.WriteLine(" Press ENTER to continue...");

Console.Read();

}

publicstaticvoidAcceptCallback(IAsyncResultar)

{

// Signal the main thread to continue.

allDone.Set();

// Get the socket that handles the client request.

Socketlistener = (Socket)ar.AsyncState;

Sockethandler = listener.EndAccept(ar);

// Create the state object.

StateObjectstate =newStateObject();

state.workSocket = handler;

handler.BeginReceive(state.buffer, 0,StateObject.BufferSize, 0,newAsyncCallback(ReadCallback), state);

}

publicstaticvoidReadCallback(IAsyncResultar)

{

Stringcontent =String.Empty;

// Retrieve the state object and the handler socket

// from the asynchronous state object.

StateObjectstate = (StateObject)ar.AsyncState;

Sockethandler = state.workSocket;

// Read data from the client socket.

intbytesRead = handler.EndReceive(ar);

if(bytesRead > 0)

{

// Theremight 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. Data : {1}",

content.Length, content);

// Echo the data back to the client.

Send(handler,"Server return :"+ content);

}

else{

// Not all data received. Get more.

handler.BeginReceive(state.buffer, 0,StateObject.BufferSize, 0,

newAsyncCallback(ReadCallback), state);

}

}

}

privatestaticvoidSend(Sockethandler,Stringdata){

// 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,

newAsyncCallback(SendCallback), handler);

}

privatestaticvoidSendCallback(IAsyncResultar)

{

try{

// Retrieve the socket from the state object.

Sockethandler = (Socket)ar.AsyncState;

// Complete sending the data to the remote device.

intbytesSent = handler.EndSend(ar);

Console.WriteLine("Sent {0} bytes to client.", bytesSent);

handler.Shutdown(SocketShutdown.Both);

handler.Close();

}

catch(Exceptione){

Console.WriteLine(e.ToString());

}

}

publicstaticintMain(String[] args)

{

StartListening();

return0;

}

}