C# 数据封装和解析

最新推荐文章于 2021-07-17 10:23:14 发布
最新推荐文章于 2021-07-17 10:23:14 发布
阅读量1.6k 收藏 2
点赞数 1
分类专栏： C/C++ C# 文章标签： Unity3D c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linxinfa/article/details/46471783
版权
C# 同时被 2 个专栏收录
74 篇文章 29 订阅
订阅专栏
C/C++
18 篇文章 6 订阅
订阅专栏 
/// <summary>
/// 数据封装和解析类
/// 作者：林新发
/// </summary>
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System;


public class NetBitStream 
{


    //****************************************Write*********************************************//
    /// <summary>
    /// 写字节
    /// </summary>
    /// <param name="bt">写入的字节</param>
    public void WriteByte(byte bt)
    {
        WriteData(enDataType.en_byte,bt);
    }


    /// <summary>
    /// 写字节流
    /// </summary>
    /// <param name="bts">写入的字节流</param>
    /// <param name="len">长度，单位字节</param>
    public void WriteBytes(byte[] bts, int len)
    {
        if (_bodyLength + BYTE_LEN * len > MAX_BODY_LENGTH) return;
        for (int i = 0; i < len; ++i)
        {
            _bytes[_bodyLength] = bts[i];
            _bodyLength += BYTE_LEN;
        }
    }


    /// <summary>
    /// 写bool
    /// </summary>
    /// <param name="flag">bool值</param>
    public void WriteBool(bool flag)
    {
        byte b = (byte)1;
        if (!flag) b = (byte)0;
        WriteData(enDataType.en_byte,b);
    }


    /// <summary>
    /// 写int
    /// </summary>
    /// <param name="num">int值</param>
    public void WriteInt32(int num)
    {
       WriteData(enDataType.en_int32,num);
    }


    /// <summary>
    /// 写uint
    /// </summary>
    /// <param name="num">uint值</param>
    public void WriteUInt32(uint num)
    {
        WriteData(enDataType.en_uint32,num);
    }


    public void WriteShort(short num)
    {
        WriteData(enDataType.en_short,num);
    }


    public void WriteFloat(float num)
    {
       WriteData(enDataType.en_float,num);
    }


    public void WriteInt64(Int64 num)
    {
        WriteData(enDataType.en_int64, num);
    }


    public void WriteUInt64(UInt64 num)
    {
        WriteData(enDataType.en_uint64, num);
    }


    public void WriteDouble(double num)
    {
        WriteData(enDataType.en_double, num);
    }


    private void WriteData(enDataType dataType,object data)
    {
        ushort dataSize=0;
        byte[] bs=new byte[]{};
        switch(dataType)
        {
            case enDataType.en_byte:
                dataSize=BYTE_LEN;
                bs = System.BitConverter.GetBytes((byte)data);
                break;
            case enDataType.en_short:
                dataSize=SHORT16_LEN;
                bs = System.BitConverter.GetBytes((ushort)data);
                break;
            case enDataType.en_ushort:
                dataSize=SHORT16_LEN;
                bs = System.BitConverter.GetBytes((short)data);
                break;
            case enDataType.en_int32:
                 dataSize=INT32_LEN;
                bs = System.BitConverter.GetBytes((int)data);
                break;
            case enDataType.en_uint32:
                 dataSize=INT32_LEN;
                bs = System.BitConverter.GetBytes((uint)data);
                break;
            case enDataType.en_float:
                dataSize=INT32_LEN;
                bs = System.BitConverter.GetBytes((float)data);
                break;
            case enDataType.en_double:
                dataSize=DOUBLE_LEN;
                bs = System.BitConverter.GetBytes((double)data);
                break;
            case enDataType.en_int64:
                dataSize=DOUBLE_LEN;
                bs = System.BitConverter.GetBytes((Int64)data);
                break;
            case enDataType.en_uint64:
                dataSize=DOUBLE_LEN;
                bs = System.BitConverter.GetBytes((UInt64)data);
                break;
        }


        if (_bodyLength + dataSize > MAX_BODY_LENGTH) return;
        Array.Copy(bs, 0, _bytes, _bodyLength, dataSize);
        _bodyLength += dataSize;
    }


    public void WriteString(string str,bool isUtf8=true)
    {
        if (str == null) return;
        ushort len = isUtf8 ? (ushort)System.Text.Encoding.UTF8.GetByteCount(str) :
            (ushort)System.Text.Encoding.GetEncoding("GB2312").GetByteCount(str);
        if (_bodyLength + len > MAX_BODY_LENGTH) return;
        System.Text.Encoding.GetEncoding("GB2312").GetBytes(str, 0, str.Length,
            _bytes, _bodyLength);
        _bodyLength += len;
    }


    public void WriteStringWithLen(string str,ushort len,bool isUtf8=true)
    {
        if (str == null)
        {
            WriteZero((ushort)len);
            return;
        }
        ushort strlen = isUtf8 ? (ushort)System.Text.Encoding.UTF8.GetByteCount(str) :
            (ushort)System.Text.Encoding.GetEncoding("GB2312").GetByteCount(str);
        if (strlen > len) return;
        WriteString(str, isUtf8);
        ushort zeroCnt = (ushort)(len - strlen);
        WriteZero(zeroCnt);
    }


    public void WriteZero(ushort zeroCnt)
    {
        byte zero = (byte)0;
        for (ushort i = 0; i < zeroCnt; ++i)
        {
            WriteByte(zero);
        }
    }




    


    //****************************************Read*********************************************//
    public void ReadByte(out byte bt)
    {
        bt = 0;
        if (_bodyLength + BYTE_LEN > MAX_BODY_LENGTH) return;
        bt = _bytes[_bodyLength];
        _bodyLength += BYTE_LEN;
    }


    public void ReadBool(out bool flag)
    {
        flag = false;
        if (_bodyLength + BYTE_LEN > MAX_BODY_LENGTH) return;
        byte bt = _bytes[_bodyLength];
        if (bt == (byte)1) flag = true;
        else flag = false;
        _bodyLength += BYTE_LEN;
    }


    public void ReadInt32(out int num)
    {
        object objNum;
        ReadData(enDataType.en_int32, out objNum);
        num = (int)objNum;
    }


    public void ReadUInt32(out uint num)
    {
        object objNum;
        ReadData(enDataType.en_uint32, out objNum);
        num = (UInt32)objNum;
    }


    public void ReadShort(out short num)
    {
        object objNum;
        ReadData(enDataType.en_short, out objNum);
        num = (short)objNum;
    }


    public void ReadUShort(out ushort num)
    {
        object objNum;
        ReadData(enDataType.en_ushort, out objNum);
        num = (ushort)objNum;
    }


    public void ReadInt64(out Int64 num)
    {
        object objNum;
        ReadData(enDataType.en_int64, out objNum);
        num = (Int64)objNum;
    }


    public void ReadUInt64(out UInt64 num)
    {
        object objNum;
        ReadData(enDataType.en_uint64, out objNum);
        num = (UInt64)objNum;
    }


    public void ReadDouble(out double num)
    {
        object objNum;
        ReadData(enDataType.en_double, out objNum);
        num = (double)objNum;
    }


    public void ReadFloat(out float num)
    {
        object objNum;
        ReadData(enDataType.en_float, out objNum);
        num = (float)objNum;
    }


    public void ReadString(out string str, ushort len,bool isUtf8)
    {
        str = "";
        if (_bodyLength + len > MAX_BODY_LENGTH) return;
        str=isUtf8?System.Text.Encoding.UTF8.GetString(_bytes,_bodyLength,(int)len):
            System.Text.Encoding.GetEncoding("GBK").GetString(_bytes,_bodyLength,(int)len);
        if(str.Contains("\0"))
        {
            int endPos=str.IndexOf('\0');
            str=str.Substring(0,endPos);
        }
    }


    public void JumpByte(ushort jumpCnt)
    {
        _bodyLength += jumpCnt;
    }


    private void ReadData(enDataType dataType, out object data)
    {
        ushort dataSize = 0;
        data = 0;
        switch (dataType)
        {
            case enDataType.en_byte:
                dataSize = BYTE_LEN;
                data = _bytes[_bodyLength];
                break;
            case enDataType.en_short:
                dataSize = SHORT16_LEN;
                data = System.BitConverter.ToInt16(_bytes,_bodyLength);
                break;
            case enDataType.en_ushort:
                dataSize = SHORT16_LEN;
                data = System.BitConverter.ToUInt16(_bytes, _bodyLength);
                break;
            case enDataType.en_int32:
                dataSize = INT32_LEN;
                data = System.BitConverter.ToInt32(_bytes, _bodyLength);
                break;
            case enDataType.en_uint32:
                dataSize = INT32_LEN;
                data = System.BitConverter.ToUInt32(_bytes, _bodyLength);
                break;
            case enDataType.en_float:
                dataSize = INT32_LEN;
                data = System.BitConverter.ToSingle(_bytes, _bodyLength);
                break;
            case enDataType.en_double:
                dataSize = DOUBLE_LEN;
                data = System.BitConverter.ToDouble(_bytes, _bodyLength);
                break;
            case enDataType.en_int64:
                dataSize = DOUBLE_LEN;
                data = System.BitConverter.ToInt64(_bytes, _bodyLength);
                break;
            case enDataType.en_uint64:
                dataSize = DOUBLE_LEN;
                data = System.BitConverter.ToUInt64(_bytes, _bodyLength);
                break;
        }
        if (_bodyLength + dataSize > MAX_BODY_LENGTH) return;
        _bodyLength += dataSize;
    }


    public void CopyBytes(byte[] bs, ushort len)
    {
        if (len > MAX_BODY_LENGTH)
            return;
        Array.Copy(bs, 0, _bytes,0, len);
    }


    public NetBitStream()
    {
        _bodyLength = 0;
        _bytes = new byte[MAX_BODY_LENGTH];
    }


    public byte[] BYTES
    {
        get { return _bytes; }
        set { _bytes = value; }
    }
    public ushort BodyLength
    {
        get { return _bodyLength; }
    }


    private const int MAX_BODY_LENGTH = 2048;


    //数据长度//


    private const ushort BYTE_LEN = 1;
    private const ushort SHORT16_LEN = 2;
    private const ushort INT32_LEN = 4;
    private const ushort FLOAT_LEN = 4;
    private const ushort DOUBLE_LEN = 8;
    private const ushort INT64_LEN = 8;


    private enum enDataType
    {
        en_byte,
        en_short,
        en_ushort,
        en_int32,
        en_uint32,
        en_int64,
        en_uint64,
        en_float,
        en_double
    }
    




    private byte[] _bytes = null;
    private ushort _bodyLength = 0;


}

林新发
关注
专栏目录
C# 数据访问层封装
05-07
数据库管理，权限精确到库，是一个很好的的demo。数据库管理，权限精确到库，是一个很好的的demo。数据库管理，权限精确到库，是一个很好的的demo。
数据传输过程的封装和解析
ren__wei_的博客
05-20 3139
基于两台主机的文件传输 1.源主机和目的主机，基于TCPIP协议四层的每一层，都要使用相同的协议 2.理解发送数据时的封装/包装，和接收数据时的分用，解析 一台主机发送数据时，从上向下封装数据，每一层基于该层的协议，在数据外面包裹一个头信息 同一网段内的两台主机TCP/IP通讯过程： 跨网段的主机的文件传输： 跨网段的两台主机文件传输过程主体部分与同一网段内的传输过程类似，不过要注意的是，数据这时候要经过一个或者多个路由器，并且要遵守令牌环网协议。 数据包的封装和分用 1.不同的协议层对数据包有不同
C# database封装
HinsLin的专栏
08-24 522
public class database{     public static string GetConnectionString()    {        string conStr = ConfigurationManager.ConnectionStrings["BMSConnectionString"].ConnectionString;        return conStr; 
C# 数据打包代码
06-18
C# 销售数据打包代码
ASP.Net下的数据访问层的封装(C#)
weixin_33922670的博客
09-28 169
晚上有点时间，整理一下自己的文档，写点东西记念一下。我们操作数据库的时候，必不可少地要写连接字符串，其中包括设置用户名，密码，服务器名等等……还要执行SQL语句，得到它的返回值。而这些操作，每次都要做，这就给我们提出了封装的需求。ASP.NET中对于数据库的连接字符串，可以放在Web.config中，类似下面的形式：<!--这是一个自定义的连接字符串配置文件--><appSe...
C#封装和解析json
08-19
本教程将详细介绍如何在C#中进行JSON的封装和解析，以帮助开发者更好地理解和应用这些技术。 首先，我们要了解JSON的结构。JSON基于JavaScript的一个子集，它支持以下数据类型：数字、字符串、布尔值、数组、对象...
c#json封装和解析练习例子
01-07
在C#编程中，JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它以易于人阅读和编写，同时也易于机器解析和生成。在处理Web服务或与服务器进行数据交换时，JSON常被用作数据传输的载体。本练习例子...
C# socket封装类和组件含例程全部开源
06-17
本资源“C# socket封装类和组件含例程全部开源”提供了一套全面且强大的C# Socket封装，旨在简化开发过程，提高代码的可读性和可维护性。以下是对这个开源项目的详细解析： 首先，Socket是TCP/IP协议族的基本组成...
xml 封装与解析(javascript和C#中)
10-29
总结，XML在JavaScript和C#中的处理涉及到解析和封装两个主要步骤。解析XML时，JavaScript根据浏览器兼容性选择不同的方法，而C#使用`XmlDocument`加载XML。在封装XML时，JavaScript使用DOM操作，C#同样使用`Xml...
C#读取串口数据封装， RS485、232 MODBUS通讯协议，亲测可用
09-17
在IT行业中，串口通信是...通过编程实现串口读取数据的封装，可以大大提高开发效率，同时确保通信的稳定性和可靠性。在实际项目中，我们还需要考虑到错误处理、多线程通信、定时重试等复杂情况，以确保系统的健壮性。
一个感觉不错的.NET数据层访问组件，封装的不错
05-21
一个开源的.NET数据层组件，有源代码哦^_^
.obj模型读取显示 c#版
11-30
.obj模型文件读取与显示 基于microsoft c#语言实现
C#导入Obj模型文件并显示
07-07
使用C#WinForm加载OBJ的三维模型文件并显示出来,支持鼠标拾取模型,支持三维场景漫游，支持自动计算帧率，。
基于Newtonsoft.Json实现Json数据解析和封装
06-02
Newtonsoft.Json已经足够强大，易用性也没得说。但是在使用过程中存在着一个问题，如果数据不存在需要判空的逻辑，这种判空逻辑会扩散在代码的各个角落，很容易犯错。 本文就是为了将这个变化点收缩到一处，便于控制。设计中也分别对JObject类和JArray类进行了封装。JObject的封装类是JsonObject，JArray的封装类是JsonArray类。JsonObject类和JsonArray类可以相互嵌套，支持原生类的JsonPath检索能力，满足Json数据解析和Json数据封装常见需求。
C#.Net底层操作数据库及常用功能封装类
09-14
常用数据库操作功能的封装。 消息功能封装 常用加密解密方式的封装 邮件发送功能的封装 数据字符串功能的封装 等等
数据库访问层封装
weixin_30587927的博客
03-20 340
简单工厂 精髓：通过不同的方法返回不同的实例 转载于:https://www.cnblogs.com/rockywood/p/6590379.html
数据访问层——字段的封装
Matrix_Designer的专栏
10-06 572
一个对表格字段的封装类<br /> 调试环境:Visual Stdio 2005,C#.net<br /> /// <summary><br /> /// 字段类型数据<br /> /// </summary><br /> public class DBFieldInfo<br /> {<br /> private String fieldName;<br /> private SqlDbType fieldType;<br /> private int
数据访问层——表结构的封装
Matrix_Designer的专栏
10-06 1186
一个对记录类型数据的封装，类似表结构封装<br /> 调试环境:Visual Stdio 2005,C#.net<br /> /// <summary><br /> /// 记录类型数据(表结构)<br /> /// </summary><br /> public class DBRecordInfo<br /> {<br /> private IList<DBFieldInfo> fields;<br /> protected string tableName;
C#自己封装数据库操作类BaseADO
chinaherolts2008的博客
07-17 343
这几天学习vb.net教程数据库操作,就自己封装了一个数据库c#教程操作类,下面是代码展示 下面的例子是Access数据库 也可能用在Sql数据库中,只在在第一行代码上修改标识符即可 #define OLEDB_ using System; using System.Data; using System.Data.OleDb; using System.Drawing; using System.IO; using System.Windows.Forms; namespace MYDATACLAS
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林新发

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值