C# socket异步 服务端

转自:  http://blog.csdn.net/qq_20282263/article/details/54310737

       private Dictionary<string, Session> SessionPool = new Dictionary<string, Session>();
         private Dictionary<string, string> MsgPool = new Dictionary<string, string>();
 
         #region 启动WebSocket服务
         /// <summary>
         /// 启动WebSocket服务
         /// </summary>
         public void start(int port)
         {
             Socket SockeServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
             SockeServer.Bind(new IPEndPoint(IPAddress.Any, port));
             SockeServer.Listen();
             SockeServer.BeginAccept(new AsyncCallback(Accept), SockeServer);
             Console.WriteLine("服务已启动");
             Console.WriteLine("按任意键关闭服务");
             Console.ReadLine();
         }
         #endregion
 
         #region 处理客户端连接请求
         /// <summary>
         /// 处理客户端连接请求
         /// </summary>
         /// <param name="result"></param>
         private void Accept(IAsyncResult socket)
         {
             // 还原传入的原始套接字
             Socket SockeServer = (Socket)socket.AsyncState;
             // 在原始套接字上调用EndAccept方法，返回新的套接字
             Socket SockeClient = SockeServer.EndAccept(socket);
             byte[] buffer = new byte[];
             try
             {
                 //接收客户端的数据
                 SockeClient.BeginReceive(buffer, , buffer.Length, SocketFlags.None, new AsyncCallback(Recieve), SockeClient);
                 //保存登录的客户端
                 Session session = new Session();
                 session.SockeClient = SockeClient;
                 session.IP = SockeClient.RemoteEndPoint.ToString();
                 session.buffer = buffer;
                 lock (SessionPool)
                 {
                     if (SessionPool.ContainsKey(session.IP))
                     {
                         this.SessionPool.Remove(session.IP);
                     }
                     this.SessionPool.Add(session.IP, session);
                 }
                 //准备接受下一个客户端
                 SockeServer.BeginAccept(new AsyncCallback(Accept), SockeServer);
                 Console.WriteLine(string.Format("Client {0} connected", SockeClient.RemoteEndPoint));
             }
             catch (Exception ex)
             {
                 Console.WriteLine("Error : " + ex.ToString());
             }
         }
         #endregion
 
         #region 处理接收的数据
         /// <summary>
         /// 处理接受的数据
         /// </summary>
         /// <param name="socket"></param>
         private void Recieve(IAsyncResult socket)
         {
             Socket SockeClient = (Socket)socket.AsyncState;
             string IP = SockeClient.RemoteEndPoint.ToString();
             if (SockeClient == null || !SessionPool.ContainsKey(IP))
             {
                 return;
             }
             try
             {
                 int length = SockeClient.EndReceive(socket);
                 byte[] buffer = SessionPool[IP].buffer;
                 SockeClient.BeginReceive(buffer, , buffer.Length, SocketFlags.None, new AsyncCallback(Recieve), SockeClient);
                 string msg = Encoding.UTF8.GetString(buffer, , length);
                 //  websocket建立连接的时候，除了TCP连接的三次握手，websocket协议中客户端与服务器想建立连接需要一次额外的握手动作
                 if (msg.Contains("Sec-WebSocket-Key"))
                 {
                     SockeClient.Send(PackageHandShakeData(buffer, length));
                     SessionPool[IP].isWeb = true;
                     return;
                 }
                 if (SessionPool[IP].isWeb)
                 {
                     msg = AnalyzeClientData(buffer, length);
                 }
                 byte[] msgBuffer = PackageServerData(msg);
                 foreach (Session se in SessionPool.Values)
                 {
                     se.SockeClient.Send(msgBuffer, msgBuffer.Length, SocketFlags.None);
                 }
             }
             catch
             {
                 SockeClient.Disconnect(true);
                 Console.WriteLine("客户端 {0} 断开连接", IP);
                 SessionPool.Remove(IP);
             }
         }
         #endregion
         #region 客户端和服务端的响应
         /*
          * 客户端向服务器发送请求
          *
          * GET / HTTP/1.1
          * Origin: http://localhost:1416
          * Sec-WebSocket-Key: vDyPp55hT1PphRU5OAe2Wg==
          * Connection: Upgrade
          * Upgrade: Websocket
          *Sec-WebSocket-Version: 13
          * User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko
          * Host: localhost:8064
          * DNT: 1
          * Cache-Control: no-cache
          * Cookie: DTRememberName=admin
          *
          * 服务器给出响应
          *
          * HTTP/1.1 101 Switching Protocols
          * Upgrade: websocket
          * Connection: Upgrade
          * Sec-WebSocket-Accept: xsOSgr30aKL2GNZKNHKmeT1qYjA=
          *
          * 在请求中的“Sec-WebSocket-Key”是随机的，服务器端会用这些数据来构造出一个SHA-1的信息摘要。把“Sec-WebSocket-Key”加上一个魔幻字符串
          * “258EAFA5-E914-47DA-95CA-C5AB0DC85B11”。使用 SHA-1 加密，之后进行 BASE-64编码，将结果做为 “Sec-WebSocket-Accept” 头的值，返回给客户端
          */
         #endregion
 
         #region 打包请求连接数据
         /// <summary>
         /// 打包请求连接数据
         /// </summary>
         /// <param name="handShakeBytes"></param>
         /// <param name="length"></param>
         /// <returns></returns>
         private byte[] PackageHandShakeData(byte[] handShakeBytes, int length)
         {
             string handShakeText = Encoding.UTF8.GetString(handShakeBytes, , length);
             string key = string.Empty;
             Regex reg = new Regex(@"Sec\-WebSocket\-Key:(.*?)\r\n");
             Match m = reg.Match(handShakeText);
             if (m.Value != "")
             {
                 key = Regex.Replace(m.Value, @"Sec\-WebSocket\-Key:(.*?)\r\n", "$1").Trim();
             }
             byte[] secKeyBytes = SHA1.Create().ComputeHash(Encoding.ASCII.GetBytes(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"));
             string secKey = Convert.ToBase64String(secKeyBytes);
             var responseBuilder = new StringBuilder();
             responseBuilder.Append("HTTP/1.1 101 Switching Protocols" + "\r\n");
             responseBuilder.Append("Upgrade: websocket" + "\r\n");
             responseBuilder.Append("Connection: Upgrade" + "\r\n");
             responseBuilder.Append("Sec-WebSocket-Accept: " + secKey + "\r\n\r\n");
             return Encoding.UTF8.GetBytes(responseBuilder.ToString());
         }
         #endregion
 
         #region 处理接收的数据
         /// <summary>
         /// 处理接收的数据
         /// 参考 http://www.cnblogs.com/smark/archive/2012/11/26/2789812.html
         /// </summary>
         /// <param name="recBytes"></param>
         /// <param name="length"></param>
         /// <returns></returns>
         private string AnalyzeClientData(byte[] recBytes, int length)
         {
             int start = ;
             // 如果有数据则至少包括3位
             if (length < ) return "";
             // 判断是否为结束针
             bool IsEof = (recBytes[start] >> ) > ;
             // 暂不处理超过一帧的数据
             if (!IsEof) return "";
             start++;
             // 是否包含掩码
             bool hasMask = (recBytes[start] >> ) > ;
             // 不包含掩码的暂不处理
             if (!hasMask) return "";
             // 获取数据长度
             UInt64 mPackageLength = (UInt64)recBytes[start] & 0x7F;
             start++;
             // 存储4位掩码值
             byte[] Masking_key = new byte[];
             // 存储数据
             byte[] mDataPackage;
             if (mPackageLength == )
             {
                 // 等于126 随后的两个字节16位表示数据长度
                 mPackageLength = (UInt64)(recBytes[start] <<  | recBytes[start + ]);
                 start += ;
             }
             if (mPackageLength == )
             {
                 // 等于127 随后的八个字节64位表示数据长度
                 mPackageLength = (UInt64)(recBytes[start] << ( * ) | recBytes[start] << ( * ) | recBytes[start] << ( * ) | recBytes[start] << ( * ) | recBytes[start] << ( * ) | recBytes[start] << ( * ) | recBytes[start] <<  | recBytes[start + ]);
                 start += ;
             }
             mDataPackage = new byte[mPackageLength];
             for (UInt64 i = ; i < mPackageLength; i++)
             {
                 mDataPackage[i] = recBytes[i + (UInt64)start + ];
             }
             Buffer.BlockCopy(recBytes, start, Masking_key, , );
             for (UInt64 i = ; i < mPackageLength; i++)
             {
                 mDataPackage[i] = (byte)(mDataPackage[i] ^ Masking_key[i % ]);
             }
             return Encoding.UTF8.GetString(mDataPackage);
         }
         #endregion
 
         #region 发送数据
         /// <summary>
         /// 把发送给客户端消息打包处理（拼接上谁什么时候发的什么消息）
         /// </summary>
         /// <returns>The data.</returns>
         /// <param name="message">Message.</param>
         private byte[] PackageServerData(string msg)
         {
             byte[] content = null;
             byte[] temp = Encoding.UTF8.GetBytes(msg);
             if (temp.Length < )
             {
                 content = new byte[temp.Length + ];
                 content[] = 0x81;
                 content[] = (byte)temp.Length;
                 Buffer.BlockCopy(temp, , content, , temp.Length);
             }
             else if (temp.Length < 0xFFFF)
             {
                 content = new byte[temp.Length + ];
                 content[] = 0x81;
                 content[] = ;
                 content[] = (byte)(temp.Length & 0xFF);
                 content[] = (byte)(temp.Length >>  & 0xFF);
                 Buffer.BlockCopy(temp, , content, , temp.Length);
             }
             return content;
         }
         #endregion

Session

   public class Session
     {
         private Socket _sockeclient;
         private byte[] _buffer;
         private string _ip;
         private bool _isweb = false;
 
         public Socket SockeClient
         {
             set { _sockeclient = value; }
             get { return _sockeclient; }
         }
 
         public byte[] buffer
         {
             set { _buffer = value; }
             get { return _buffer; }
         }
 
         public string IP
         {
             set { _ip = value; }
             get { return _ip; }
         }
 
         public bool isWeb
         {
             set { _isweb = value; }
             get { return _isweb; }
         }
     }