SocketAsyncEventArgs



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

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

不过例子还是感觉复杂了点，我只是需要知道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