.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();
}
}
}
}
（三）客户端向服务端发送消息
客户端：
服务端：
以上这篇c# 实现websocket服务端教程就是www.887551.com分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持www.887551.com。