C# WebSocket解析（收发数据包、分片超长包处理）

最新推荐文章于 2024-07-25 08:01:17 发布
最新推荐文章于 2024-07-25 08:01:17 发布
阅读量1.6k 收藏 1
点赞数
文章标签： 网络 c# json
原文链接：http://www.cnblogs.com/gaobw/p/8087384.html
版权 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;

namespace LaiHuaRendSpeederServer
{
    public static class WebSocketSeverHelper
    {
        /// <summary>
        /// 打包服务器握手数据
        /// </summary>
        public static byte[] PackageHandShakeData(string handShakeText)
        {
            //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" + Environment.NewLine);
            responseBuilder.Append("Upgrade: websocket" + Environment.NewLine);
            responseBuilder.Append("Connection: Upgrade" + Environment.NewLine);
            responseBuilder.Append("Sec-WebSocket-Accept: " + secKey + Environment.NewLine + Environment.NewLine);
            //responseBuilder.Append("Sec-WebSocket-Protocol: " + "chat, superchat" + Environment.NewLine + Environment.NewLine);
           

            return Encoding.UTF8.GetBytes(responseBuilder.ToString());
        }

        /// <summary>
        /// 解析客户端发送来的数据
        /// </summary>
        public static string DecodeClientData(byte[] recBytes, int length)
        {
            if (length < 2)
            {
                return string.Empty;
            }
            
            bool fin = (recBytes[0] & 0x80) == 0x80; //0x80 = 1000,0000  第1bit = 1表示最后一帧  
            if (!fin)
            {
                if (recBytes[1] == 0xff)
                {
                }
                else
                return string.Empty;
            }

            bool mask_flag = (recBytes[1] & 0x80) == 0x80; // 是否包含掩码  
            if (!mask_flag)
            {
                return string.Empty;// 不包含掩码的暂不处理
            }

            int payload_len = recBytes[1] & 0x7F; // 数据长度  

            byte[] masks = new byte[4];
            byte[] payload_data;

            if (payload_len == 126)
            {
                Array.Copy(recBytes, 4, masks, 0, 4);
                payload_len = (UInt16)(recBytes[2] << 8 | recBytes[3]);
                payload_data = new byte[payload_len];
                Array.Copy(recBytes, 8, payload_data, 0, payload_len);

            }
            else if (payload_len == 127)
            {
                Array.Copy(recBytes, 10, masks, 0, 4);
                byte[] uInt64Bytes = new byte[8];
                for (int i = 0; i < 8; i++)
                {
                    uInt64Bytes[i] = recBytes[9 - i];
                }
                UInt64 len = BitConverter.ToUInt64(uInt64Bytes, 0);

                payload_data = new byte[len];
                for (UInt64 i = 0; i < len; i++)
                {
                    payload_data[i] = recBytes[i + 14];
                }
            }
            else
            {
                Array.Copy(recBytes, 2, masks, 0, 4);
                payload_data = new byte[payload_len];
                Array.Copy(recBytes, 6, payload_data, 0, payload_len);

            }

            for (var i = 0; i < payload_len; i++)
            {
                payload_data[i] = (byte)(payload_data[i] ^ masks[i % 4]);
            }
            //var uuu = new byte[payload_data.Length * 3 / 4];
            //for (int i = 0; i < uuu.Length; i++)
            //{
            //    uuu[i] = payload_data[i];
            //}
            //Console.WriteLine("UUUUUU：" + Encoding.UTF8.GetString(uuu));
            return Encoding.UTF8.GetString(payload_data);
        }

        public static byte[] DecodeClientByteData(byte[] recBytes, int length)
        {
            if (length < 2)
            {
                return null;
            }

            bool fin = (recBytes[0] & 0x80) == 0x80; //0x80 = 1000,0000  第1bit = 1表示最后一帧  
            //if (!fin)
            //{
            //    if (recBytes[1] == 0xff)
            //    {
            //        if (recBytes[0] == 0x01)
            //        {
            //            recBytes[0] += 0x80;
            //        }
            //        else
            //            return null;
            //    }
            //    else
            //        return null;
            //}

            bool mask_flag = (recBytes[1] & 0x80) == 0x80; // 是否包含掩码  
            if (!mask_flag)
            {
                return null;// 不包含掩码的暂不处理
            }

            int payload_len = recBytes[1] & 0x7F; // 数据长度  

            byte[] masks = new byte[4];
            byte[] payload_data;

            if (payload_len == 126)
            {
                Array.Copy(recBytes, 4, masks, 0, 4);
                payload_len = (UInt16)(recBytes[2] << 8 | recBytes[3]);
                payload_data = new byte[payload_len];
                Array.Copy(recBytes, 8, payload_data, 0, payload_len);

            }
            else if (payload_len == 127)
            {
                Array.Copy(recBytes, 10, masks, 0, 4);
                byte[] uInt64Bytes = new byte[8];
                for (int i = 0; i < 8; i++)
                {
                    uInt64Bytes[i] = recBytes[9 - i];
                }
                UInt64 len = BitConverter.ToUInt64(uInt64Bytes, 0);

                payload_data = new byte[len];
                
                for (UInt64 i = 0; i < len; i++)
                {
                    payload_data[i] = recBytes[i + 14];
                }
            }
            else
            {
                Array.Copy(recBytes, 2, masks, 0, 4);
                payload_data = new byte[payload_len];
                Array.Copy(recBytes, 6, payload_data, 0, payload_len);

            }

            for (var i = 0; i < payload_data.Length; i++)
            {
                payload_data[i] = (byte)(payload_data[i] ^ masks[i % 4]);
            }
            return payload_data;
        }

        /// <summary>
        /// 把客户端消息打包处理
        /// </summary>
        public static byte[] EncodeServerData(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;
                Array.Copy(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);
                Array.Copy(temp, 0, content, 4, temp.Length);
            }
            else
            {
                // 暂不处理超长内容  
            }
            return content;
        }
    }
}
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;

namespace LaiHuaRendSpeederServer
{
    public static class WebSocketExt
    {
        public static int SendProtocol(this Socket s, Protocol p)
        {
            var msg = JsonConvert.SerializeObject(p);
            Console.WriteLine("SendProtocol : " + msg);
            return s.Send(WebSocketSeverHelper.EncodeServerData(msg));
        }
        public static int ReceiveProtocol(this Socket s, ref Protocol p)
        {
            byte[] buffer = new byte[502400];
            int reccount = 0;
            List<ArraySegment<byte>> segList = new List<ArraySegment<byte>>();
            if (s.Connected)
            {
                reccount = s.Receive(buffer);
                if(reccount == 0)
                {
                    s.Shutdown(SocketShutdown.Send);
                    p = null;
                    return 0;
                }
            }
            byte[] r = new byte[reccount];
            Array.Copy(buffer, r, reccount);
            buffer = null;
            string mgs = string.Empty;
            if ((r[0] & 0x80) == 0)
            {
                segList.Add(new ArraySegment<byte>(r, 0, reccount));
                byte[] r2 = new byte[8];
                while ((r2[0] & 0x80) == 0)
                {
                    r2 = new byte[502400];
                    int cout = s.Receive(r2);
                    segList.Add(new ArraySegment<byte>(r2, 0, cout));
                }
                byte[] all = null;
                for (int i = 0; i < segList.Count; i++)
                {
                    if (all == null)
                    {
                        all = WebSocketSeverHelper.DecodeClientByteData(segList[i].Array, segList[i].Count);
                    }
                    else
                    {
                        var pit = WebSocketSeverHelper.DecodeClientByteData(segList[i].Array, segList[i].Count);
                        all = all.Concat(pit).ToArray();
                    }
                }
                mgs = Encoding.UTF8.GetString(all);
            }
            else
            {
                mgs = WebSocketSeverHelper.DecodeClientData(r, r.Length);
            }

            if (mgs.Length < 150)
            {
                Console.WriteLine("ReceiveProtocol : " + mgs);
            }
            else
            {
                Console.WriteLine("ReceiveProtocol : " + mgs.Substring(0, 150));
            }
            try
            {
                var f = mgs.Substring(1, mgs.Length - 2);
                var menbs = f.Split(new string[] { "\",\"" }, StringSplitOptions.RemoveEmptyEntries);
                if (menbs.Length != 4)
                {
                    p = null;
                    return reccount;
                }
                p = new Protocol();
                foreach (var item in menbs)
                {
                    var pare = item.Split(new string[] { "\":\"" }, StringSplitOptions.None);
                    if (pare.Length != 2)
                    {
                        p = null;
                        return reccount;
                    }
                    switch (pare[0].Replace("\"", ""))
                    {
                        case "Head":
                            p.Head = pare[1].Replace("\"", "");
                            break;
                        case "Func":
                            p.Func = pare[1].Replace("\"", "");
                            break;
                        case "Name":
                            p.Name = pare[1].Replace("\"", "");
                            break;
                        case "Data":
                            p.Data = pare[1].Replace("\"", "");
                            break;
                        default:
                            p = null;
                            return reccount;
                            break;
                    }
                }
                //p = JsonConvert.DeserializeObject<Protocol>(mgs);
            }
            catch (Exception ex)
            {
                var errormsg = JsonConvert.SerializeObject(
                    new Protocol() { Func = FUNC.ERROR, Data = ex.ToString() });
                if (s.Connected)
                {
                    s.Send(WebSocketSeverHelper.EncodeServerData(errormsg));
                }
                Console.WriteLine("ERROR : " + errormsg);
                s.Close();
            }
            return reccount;
        }
    }
}

 

转载于:https://www.cnblogs.com/gaobw/p/8087384.html

weixin_34370347
关注
【webSocket 通信（消息的发送、接收）】
m0_45382009的博客
12-07 7016
场景（代码简单化，只罗列功能代码）： 对象：银行柜员与客户 （都是前端交互） 功能：视频办理相关业务 1. 先定义一个变量，用于存放WebSocket的实例对象 const webSocketObj = null; 2. 判断浏览器是否支持使用WebSocked window.WebSocked = window.WebSocked || window..MozWebSocket; if(!window.WebSocked){ console.error("您的浏览器不支持WebSocked.
C# WebSocket模拟发送接收
山鹰的专栏
12-14 6236
WebSocket服务端 C#示例代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Net.Sockets; using System.Net; using System.Threading; using System.Text.Regula...
websocket 接收发送数据
是秃子总会发光
03-04 3285
websocket 接收发送数据
C# 中使用 WebSocket 的技术探索
最新发布
dotNET跨平台
07-25 403
WebSocket 是一种网络通信协议，提供了浏览器和服务器之间的全双工通信渠道。与传统的 HTTP 请求相比，WebSocket 允许服务器主动发送信息给客户端，实现真正的实时双向交互。在 C# 中，我们可以使用 .NET Framework 或 .NET Core 来实现 WebSocket 通信。本文将深入探讨在 C# 中如何使用 WebSocket 进行开发。一、WebSocket 基础W...
Websocket数据解析全过程
asas043的专栏
05-05 5263
之前在协助建军做自动通知前端刷新和最近分片上传大文件的时候都使用到了websocket，对websocket做了一些调研，这篇文章就跟大家一起分享一下。 websocket的使用场景： 一般我们做聊天室这种需要保持通讯状态的功能，如果是用HTTP协议去做的话，需要客户端一直做长轮询去查询服务端是否由新消息，再显示在客户端上，这是因为HTTP本身是一个短连接，当我们客户端发起请求时，服务器...
WebSocket发送与接收数据
mon_star°的博客
04-18 1252
除了能发送文本信息和普通对象信息之外，还可以发送ArrayBuffer对象和Blob对象；
C#实现WebSocket服务器：（03）消息收发的封装
艾恩
09-11 5509
前文我们实现了WebSocket消息的读取和发送：C#实现WebSocket服务器：（02）消息帧分析和代码实现 但是我们所有的逻辑都是写在OnWebSocket方法的，并不方便扩展，现在我们封装一个Messager抽象类，封装消息的读取和发送。 Messager类封装 我们将在类中暴露一些必要的方法。 下面我们用消息这个词，而不是帧，因为一条消息可能是由多个帧(例如Text帧+N个Continuation帧)组成的。 方法 说明 Accept 在OnWebSocket方法中，调用具体Mes
webSocket C# 源码
02-10
总的来说，"WebSocket C# 源码"是指使用C#编程语言实现WebSocket协议，通过提供完整的源代码，帮助开发者理解WebSocket在C#环境中的工作原理，以及如何处理浏览器发送大数据时的分包问题，特别是针对火狐浏览器的...
简单实现了websocket功能：websocket客户端、winformsocket客户端
10-08
3. **事件驱动编程**：WebSocket API设计为事件驱动，如`onopen`, `onmessage`, `onerror` 和 `onclose` 事件，使得开发人员可以方便地处理连接状态的变化和数据收发。 4. **安全性**：WebSocket连接可以通过WSS...
websocekt发送大数据拆包_使用websocket发送图片文件
weixin_39614011的博客
12-21 684
Websocket是HTML5中的一个传输数据控件。眼下在主流的浏览器中都提供了支持。关于websocket的相关协议能够在网上查到，关于怎样建立连接等操作大家能够查询协议获得。本文主要讨论怎样进行传输数据。在client使用的是Chrome浏览器，在server端使用PHP开发websocket协议。Websocket协议一个frame的标准格式：0 1...
WebSocket服务端消息推送
m0_67391121的博客
06-18 3044
**前言：**移动互联网蓬勃发展的今天，大部分手机 APP和网站都提供了消息推送功能，如新闻客户端的热点新闻推荐，IM 工具的聊天消息提醒，电商产品促销信息，企业应用的通知和审批流程等等。推送对于提高产品活跃度、提高功能模块使用率、提升用户粘性、提升用户留存率起到了重要作用，作为 APP 和网站运营中一个关键的渠道，对消息推送的合理运用能有效促进目标的实现。股票曲线实时变化，在线IM聊天等等，Web系统里总是能见到消息推送的应用。消息推送用好了能增强用户体验，实现消息推送有N种解决方案。Web网站推送:当我
C# Socket 分包传送数据
09-14
C# Socket 分包传送数据是关于图片传送并且分割字节的一个资源。
c#多线程socket开发（一个服务器对多个客户端）
01-11
c#语言开发多线程socket服务器端程序，实现一个服务器同时与多个客户端连接对话。
WebSocket多线程视频通信
02-25
WebSocket多线程视频通信
Unity客户端长度信息法解决Socket粘包问题
土豪gold的博客
06-29 1356
客户端源代码： using System.Collections; using System.Collections.Generic; using UnityEngine; using System.Net.Sockets; using UnityEngine.UI; using System; using System.Linq; public class Echo : MonoBehaviour { //定义套接字 Socket socket; //UGUI p..
html5 的 webScoket 和 C# 建立Socket连接
weixin_30865427的博客
08-09 568
最近使用的web项目中，需要服务器直接触发前端显示效果。 所以研究了一下websocket: 名词解释： WebSocketWebSocket协议是一种双向通信协议，它建立在TCP之上，同http一样通过TCP来传输数据，但是它和http最大的不同有两点： 1.WebSocket是一种双向通信协议，在建立连接后，WebSocket服务器和Browser/UA都能主动的向对方发送或...
springboot框架中使用websocket传输内容过长的问题解决
热门推荐
luohualiushui1的专栏
01-22 1万+
很多业务中使用websocket进行前后台的长连接，一般情况下用作及时性消息推送等。 而一旦传输内容过长，例如传输一些图片音频的base64编码之类的，很容易出现过长问题，甚至不提示问题直接截断乃至丢失数据，解决方法如下。 很多人网上查阅方法会发现使用如下措施解决： 就是在web.xml里面加一个配置 &lt;context-param&gt; &lt;param-name&gt;org...
C# WebSocket通讯入门
黄瓜炒鸡蛋的博客
08-16 859
WebSocket全双工通信协议，TCP握手一次后，前后端自由通信
websocket实现简单的消息发送
x_h_j_的博客
03-08 1354
我写的一坨屎，看起来有点乱，只需要看websocket的js代码和java代码就行了，最重要的是理解。。WebSocket的出现主要是为了解决HTTP等传统协议在实时交互方面的局限性。综上所述，WebSocket作为一种先进的通信协议，为实时应用提供了强大的支持，使得开发具有实时交互功能的网站和应用程序变得更加容易和高效。效果图。
safaris启用nsurlsession后websocket收发数据包失败
02-23
很抱歉听到你在使用Safari启用NSURLSession后，WebSocket收发数据包失败。我建议你尝试检查你的网络设置，确保WebSocket连接可以正常工作。另外，您也可以尝试使用其他浏览器来发送和接收数据包。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值