C# 实现WebSocket服务端教程_.net

.net4.5中实现了对websocket的支持

在这里我使用的是.net4.0。因此需要对原本的socket发送的数据根据websocket的协议进行解析和打包。

using system;
using system.collections.generic;
using system.linq;
using system.text;
using system.net.sockets;
using system.threading;
using system.net;

namespace websocketserver
{
 class program
 {
  static void main(string[] args)
  {
   websocket socket = new websocket();
   socket.start(8064);
  }
 }
}

using system;
using system.collections.generic;
using system.linq;
using system.text;
using system.net.sockets;
using system.net;
namespace websocketserver
{
 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; }
  }
 }
}

using system;
using system.collections.generic;
using system.linq;
using system.text;
using system.threading;
using system.net.sockets;
using system.net;
using system.text.regularexpressions;
using system.security.cryptography;

namespace websocketserver
{
 public class websocket
 {
  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(20);
   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[4096];
   try
   {
    //接收客户端的数据
    sockeclient.beginreceive(buffer, 0, 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, 0, buffer.length, socketflags.none, new asynccallback(recieve), sockeclient);
    string msg = encoding.utf8.getstring(buffer, 0, 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, 0, 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>
  /// 处理接收的数据
  /// </summary>
  /// <param name="recbytes"></param>
  /// <param name="length"></param>
  /// <returns></returns>
  private string analyzeclientdata(byte[] recbytes, int length)
  {
   int start = 0;
   // 如果有数据则至少包括3位
   if (length < 2) return "";
   // 判断是否为结束针
   bool iseof = (recbytes[start] >> 7) > 0;
   // 暂不处理超过一帧的数据
   if (!iseof) return "";
   start++;
   // 是否包含掩码
   bool hasmask = (recbytes[start] >> 7) > 0;
   // 不包含掩码的暂不处理
   if (!hasmask) return "";
   // 获取数据长度
   uint64 mpackagelength = (uint64)recbytes[start] & 0x7f;
   start++;
   // 存储4位掩码值
   byte[] masking_key = new byte[4];
   // 存储数据
   byte[] mdatapackage;
   if (mpackagelength == 126)
   {
    // 等于126 随后的两个字节16位表示数据长度
    mpackagelength = (uint64)(recbytes[start] << 8 | recbytes[start + 1]);
    start += 2;
   }
   if (mpackagelength == 127)
   {
    // 等于127 随后的八个字节64位表示数据长度
    mpackagelength = (uint64)(recbytes[start] << (8 * 7) | recbytes[start] << (8 * 6) | recbytes[start] << (8 * 5) | recbytes[start] << (8 * 4) | recbytes[start] << (8 * 3) | recbytes[start] << (8 * 2) | recbytes[start] << 8 | recbytes[start + 1]);
    start += 8;
   }
   mdatapackage = new byte[mpackagelength];
   for (uint64 i = 0; i < mpackagelength; i++)
   {
    mdatapackage[i] = recbytes[i + (uint64)start + 4];
   }
   buffer.blockcopy(recbytes, start, masking_key, 0, 4);
   for (uint64 i = 0; i < mpackagelength; i++)
   {
    mdatapackage[i] = (byte)(mdatapackage[i] ^ masking_key[i % 4]);
   }
   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 < 126)
   {
    content = new byte[temp.length + 2];
    content[0] = 0x81;
    content[1] = (byte)temp.length;
    buffer.blockcopy(temp, 0, content, 2, temp.length);
   }
   else if (temp.length < 0xffff)
   {
    content = new byte[temp.length + 4];
    content[0] = 0x81;
    content[1] = 126;
    content[2] = (byte)(temp.length & 0xff);
    content[3] = (byte)(temp.length >> 8 & 0xff);
    buffer.blockcopy(temp, 0, content, 4, temp.length);
   }
   return content;
  }
  #endregion
 }
}

补充知识：【tcp/ip】使用c#实现websocket服务端与客户端通信

一、websocket简介

websocket是一种在单个tcp连接上进行全双工通信的协议。

websocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在websocket api中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

二、背景

很多网站为了实现推送技术，所用的技术都是轮询。

轮询是在特定的时间间隔，由浏览器对客户端发出http请求，然后由服务器返回最新的数据给客户端的浏览器。这种传统的模式带来很明显的缺点，即浏览器需要不断的向服务器发出请求，然后http请求可能包含较长的头部，其中真正有效的数据可能只是很小的一部分，显然这样会浪费很多的宽带等资源。

在这种情况下，html5定义了websocket协议，能更好的节省服务器资源和宽带，而且能够更实时地进行通讯。

三、优点

1、控制开销

创建连接后，服务器和客户端之间交换数据时，用于协议控制的数据包头部相对较小。

2、实时性更强

由于协议是全双工的，所以服务器可以随时主动给客户端下发数据。相对于http请求需要等待客户端发起请求服务端才能响应，延迟明显更少。

3、保持连接状态

与http不同的是，websocket需要先创建连接，这就使得其成为一种有状态的协议，之后通信时可以省略部分状态信息。而http请求可能需要在每个请求都携带状态信息（如身份认证等）。

4、更好的二进制支持

5、支持扩展和更好的实现压缩效果

四、原理

websocket同http一样也是应用层的协议，但是它是一种双向通信协议，建立在tcp之上的。

连接过程（握手过程）

1、客户端、服务器建立tcp连接，三次握手。

这是通信的基础，传输控制层，若失败后续都不执行。

2、tcp连接成功后，客户端通过http协议向服务器传送websocket支持的版本号信息。（开始前的http握手）

3、服务器收到客户端的握手请求后，同样采用http协议回馈数据。

4、当收到了连接成功的消息后，通过tcp通道进行传输通信。

五、websocket和socket的关系

socket其实并不是一个协议，而是为了方便使用tcp和udp而抽象出来的一层，是位于应用层和传输控制层之间的一组接口。

socket是应用层与tcp/ip协议通信的中间软件抽象层，它是一组接口。在设计模式中，socket其实就是一个门面模式，它把复杂的tcp/ip协议隐藏在socket接口后面，对用户来说，一组简单的接口就是全部，让socket去组织数据，以符合指定的协议。

两台主机通信，必须通过socket连接，socket则利用tcp/ip协议建立tcp连接。tcp连接则更依靠于底层的ip协议，ip协议的连接则依赖于链路层等更低层次。

websocket则是一个典型的应用层协议。

六、使用c#实现websocket服务端与客户端通信

（一） superwebsocket实现服务端

1、创建窗口程序，windowsformswebsocketserver

2、添加程序包

工具 -->nuget包管理 -->管理解决方案的nuget程序包 -->搜索 superwebsocket ，选择superwebsocketnetserver，点击右侧安装，等待安装完成，安装完成以后，项目会多出很多引用库，如下

3、代码实例

using superwebsocket;
using system;
using system.windows.forms;
 
namespace windowsformswebsocketserver
{
  public partial class form1 : form
  {
    public form1()
    {
      initializecomponent();
      websocketserver();
    }
 
    private void websocketserver()
    {
      log("我是服务端");
      websocketserver websocketserver = new websocketserver();
      websocketserver.newsessionconnected += websocketserver_newsessionconnected;
      websocketserver.newmessagereceived += websocketserver_newmessagereceived;
      websocketserver.sessionclosed += websocketserver_sessionclosed;
      if (!websocketserver.setup("127.0.0.1", 1234))
      {
        log("设置服务监听失败！");
      }
      if (!websocketserver.start())
      {
        log("启动服务监听失败！");
      }
      log("启动服务监听成功！");
      //websocketserver.dispose();
    }
 
    private void websocketserver_newsessionconnected(websocketsession session)
    {
      log("欢迎客户端： 加入");
      //sendtoall(session, msg);
    }
 
    private void websocketserver_newmessagereceived(websocketsession session, string value)
    {
      log("服务端收到客户端的数据 ==》"+value);
      //sendtoall(session, value);
    }
 
    private void websocketserver_sessionclosed(websocketsession session, supersocket.socketbase.closereason value)
    {
      log("客户端：关闭，原因：");
      //sendtoall(session, msg);
    }
 
    /// <summary>
    /// 广播，同步推送消息给所有的客户端
    /// </summary>
    /// <param name="websocketsession"></param>
    /// <param name="msg"></param>
    public static void sendtoall(websocketsession websocketsession, string msg)
    {
      foreach (var item in websocketsession.appserver.getallsessions())
      {
        item.send(msg);
      }
    }
 
    private delegate void dolog(string msg);
    public void log(string msg)
    {
      if (this.logreveal.invokerequired)
      {
        dolog dolog = new dolog(log);
        this.logreveal.invoke(dolog, new object[] { msg });
      }
      else
      {
        if (this.logreveal.items.count > 20)
        {
          this.logreveal.items.removeat(0);
        }
        msg = datetime.now.tolocaltime().tostring() + " " + msg;
        this.logreveal.items.add(msg);
      }
    }
  }
}

（二）websocket4net实现客户端

1、创建窗口程序，windowsformswebsocketclient

2、添加程序包

工具 -->nuget包管理 -->管理解决方案的nuget程序包 -->搜索 websocket4net ，选择websocket4net，点击右侧安装，等待安装完成，安装完成以后，项目会多出很多引用库，如下

3、代码实例

using system;
using websocket4net;
using system.threading;
using system.windows.forms;
 
namespace windowsformswebsocketclient
{
  public partial class form1 : form
  {
    public form1()
    {
      initializecomponent();
      websocketservertest();
    }
 
    public static websocket websocket4net = null;
    public void websocketservertest()
    {
      fileutil.getinstance().log("我是客户端");
      websocket4net = new websocket("ws://127.0.0.1:1234");
      websocket4net.opened += websocket4net_opened;
      websocket4net.error += websocket_error;
      websocket4net.closed += new eventhandler(websocket_closed);
      websocket4net.messagereceived += websocket4net_messagereceived;
      websocket4net.open();
      thread thread = new thread(clientsendmsgtoserver);
      thread.isbackground = true;
      thread.start();
      //websocket4net.dispose();
    }
 
    private void savebtn_click(object sender, eventargs e)
    {
      websocketservertest();
    }
 
    public void clientsendmsgtoserver()
    {
      int i = 1;
      while (true)
      {
        websocket4net.send("love girl" + i++);
        thread.sleep(timespan.fromseconds(5));
      }
    }
 
    private void websocket4net_messagereceived(object sender, messagereceivedeventargs e)
    {
      fileutil.getinstance().log("服务端回复的数据:" + e.message);
    }
 
    private void websocket4net_opened(object sender, eventargs e)
    {
      fileutil.getinstance().log("客户端连接成功！发送数据中...");
      websocket4net.send("来自客户端，准备发送数据！");
    }
 
    private void websocket_error(object sender, eventargs e)
    {
      fileutil.getinstance().log("websocket错误");
      thread.sleep(5000);
      if (websocket4net.state!= websocketstate.open&&websocket4net.state!=websocketstate.connecting)
      {
        websocketservertest();
      }
    }
 
    private void websocket_closed(object sender, eventargs e)
    {
      fileutil.getinstance().log("websocket已关闭");
      thread.sleep(5000);
      if (websocket4net.state != websocketstate.open && websocket4net.state != websocketstate.connecting)
      {
        websocketservertest();
      }
    }
  }
}

（三）客户端向服务端发送消息

客户端：