Socket IOCP通讯【转】

SocketAsyncEventArgs是.net提供的关于异步socket类，封装了IOCP的使用，可以用它方便的实现NIO（non-blocking IO）

NIO对于提升某些场景下Server性能和吞吐量有很大益处，准备在服务框架中使用它来编写简易rpc的部分

微软官方的demo代理有所缺少：

http://msdn.microsoft.com/en-us/ ... asynceventargs.aspx

还有篇老外写的补充了缺少的代码：

http://www.codeproject.com/KB/IP/socketasynceventargssampl.aspx

不过例子还是感觉复杂了点，我只是需要知道SocketAsyncEventArgs本身如何使用而已，于是自行简化了一下：
1:  using System;  
2:  using System.Net;  
3:  using System.Net.Sockets;  
4:  using System.Text;  
5:    
6:  namespace SocketAsyncServer  
7:  {  
8:      public static class Program  
9:      {  
10:          public static void Main(String[] args)  
11:          {  
12:              IPAddress[] addressList = Dns.GetHostEntry(Environment.MachineName).AddressList;  
13:              new TcpListener().Listen(new IPEndPoint(addressList[addressList.Length - 1], 9900));  
14:    
15:              Console.ReadKey();  
16:          }  
17:      }  
18:    
19:      public class TcpListener  
20:      {  
21:          private SocketAsyncEventArgs Args;
22:          private Socket ListenerSocket;  
23:          private StringBuilder buffers;  
24:          public TcpListener() { }  
25:          public void Listen(EndPoint e)  
26:          {  
27:              //buffer  
28:              buffers = new StringBuilder();  
29:              //socket  
30:              ListenerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  
31:              ListenerSocket.Bind(e);  
32:              ListenerSocket.Listen(10);  
33:              //异步socket事件  
34:              Args = new SocketAsyncEventArgs();  
35:              Args.Completed += new EventHandler<SocketAsyncEventArgs>(ProcessAccept);  
36:              BeginAccept(Args);  
37:              Console.WriteLine("server run at {0}", e.ToString());  
38:          }  
39:    
40:          //开始接受  
41:          void BeginAccept(SocketAsyncEventArgs e)  
42:          {  
43:              e.AcceptSocket = null;
44:              if (!ListenerSocket.AcceptAsync(e))  
45:                  ProcessAccept(ListenerSocket, e);  
46:          }  
47:          //接受完毕 开始接收和发送  
48:          void ProcessAccept(object sender, SocketAsyncEventArgs e)  
49:          {  
50:              Socket s = e.AcceptSocket;  
51:              e.AcceptSocket = null;  
52:    
53:              int bufferSize = 10;//1000 * 1024;  
54:              var args = new SocketAsyncEventArgs();  
55:              args.Completed += new EventHandler<SocketAsyncEventArgs>(OnIOCompleted);  
56:              args.SetBuffer(new byte[bufferSize], 0, bufferSize);  
57:              args.AcceptSocket = s;  
58:              if (!s.ReceiveAsync(args))  
59:                  this.ProcessReceive(args);  
60:    
61:              BeginAccept(e);  
62:          }  
63:    
64:          //IOCP回调  
65:          void OnIOCompleted(object sender, SocketAsyncEventArgs e)  
66:          {  
67:              switch (e.LastOperation)  
68:              {  
69:                  case SocketAsyncOperation.Receive:  
70:                      this.ProcessReceive(e);  
71:                      break;  
72:                  case SocketAsyncOperation.Send:  
73:                      this.ProcessSend(e);  
74:                      break;  
75:                  default:  
76:                      throw new ArgumentException("The last operation completed on the socket was not a receive or send");  
77:              }  
78:          }  
79:            
80:          //接收完毕  
81:          void ProcessReceive(SocketAsyncEventArgs e)  
82:          {  
83:              if (e.BytesTransferred > 0)  
84:              {  
85:                  if (e.SocketError == SocketError.Success)  
86:                  {  
87:                      //读取  
88:                      var data=Encoding.ASCII.GetString(e.Buffer, e.Offset, e.BytesTransferred);  
89:                      buffers.Append(data);  
90:                      Console.WriteLine("Received:{0}", data);  
91:    
92:                      if (e.AcceptSocket.Available == 0)  
93:                      {  
94:                          //读取完毕  
95:                          Console.WriteLine("Receive Complete.Data:{0}", buffers.ToString());  
96:                          //重置  
97:                          buffers = new StringBuilder();  
98:                          //发送反馈  
99:                          Byte[] sendBuffer = Encoding.ASCII.GetBytes("result from server");
100:                          e.SetBuffer(sendBuffer, 0, sendBuffer.Length);
101:                          if (!e.AcceptSocket.SendAsync(e))
102:                          {
103:                      
104:                              this.ProcessSend(e);
105:                          }
106:                      }
107:                      else if (!e.AcceptSocket.ReceiveAsync(e))
108:                      {
109:                          this.ProcessReceive(e);
110:                      }
111:                  }
112:                  else
113:                  {
114:                      //this.ProcessError(e);
115:                  }
116:              }
117:              else
118:              {
119:                  //this.CloseClientSocket(e);
120:              }
121:          }
122:          //发送完毕
123:          void ProcessSend(SocketAsyncEventArgs e)
124:          {
125:              if (e.SocketError == SocketError.Success)
126:              {
127:    
128:                  if (!e.AcceptSocket.ReceiveAsync(e))
129:                  {
130:                      this.ProcessReceive(e);
131:                  }
132:              }
133:              else
134:              {
135:    
136:              }
137:          }
138:      }
139:        
140:  }


上述代码run起来之后，打开cmd用telnet测试下即可

telnet 127.0.0.1 9900
顺便推荐一下一个框架实现了nio的rpc

http://shuttler.codeplex.com/

http://www.cnblogs.com/overred/a ... Shuttler_Net_2.html