百度360必应搜狗淘宝本站头条
当前位置:网站首页 > 热门文章 > 正文

给大家分享一个我经常使用的类「含源码」

bigegpt 2024-09-08 11:25 9 浏览

前言

今天跟大家分享一个我自己封装,而且经常使用的类,话不多说,直接看源码。

源码

    /// <summary>
    /// 字节集合类
    /// </summary>
    public class ByteArray
    {
        /// <summary>
        /// 初始化一个List集合对象
        /// </summary>
        private List<byte> list = new List<byte>();

        /// <summary>
        /// 通过索引获取值
        /// </summary>
        /// <param name="index">索引</param>
        /// <returns>返回字节</returns>
        public byte this[int index]
        {
            get => list[index];
            set => list[index] = value;
        }

        /// <summary>
        /// 返回长度
        /// </summary>
        public int Length => list.Count;


        /// <summary>
        /// 通过属性返回字节数组
        /// </summary>
        public byte[] array
        {
            get { return list.ToArray(); }
        }

        /// <summary>
        /// 清空字节数组
        /// </summary>
        public void Clear()
        {
            list.Clear();
        }

        /// <summary>
        /// 添加一个字节
        /// </summary>
        /// <param name="item">字节</param>
        public void Add(byte item)
        {
            list.Add(item);
        }

        /// <summary>
        /// 添加一个字节数组
        /// </summary>
        /// <param name="items">字节数组</param>
        public void Add(byte[] items)
        {
            list.AddRange(items);
        }

        /// <summary>
        /// 添加二个字节
        /// </summary>
        /// <param name="item">字节</param>
        public void Add(byte item1, byte item2)
        {
            Add(new byte[] { item1, item2 });
        }

        /// <summary>
        /// 添加三个字节
        /// </summary>
        /// <param name="item">字节</param>
        public void Add(byte item1, byte item2, byte item3)
        {
            Add(new byte[] { item1, item2, item3 });
        }

        /// <summary>
        /// 添加四个字节
        /// </summary>
        /// <param name="item">字节</param>
        public void Add(byte item1, byte item2, byte item3, byte item4)
        {
            Add(new byte[] { item1, item2, item3, item4 });
        }

        /// <summary>
        /// 添加五个字节
        /// </summary>
        /// <param name="item">字节</param>
        public void Add(byte item1, byte item2, byte item3, byte item4, byte item5)
        {
            Add(new byte[] { item1, item2, item3, item4, item5 });
        }


        /// <summary>
        /// 添加一个ByteArray对象
        /// </summary>
        /// <param name="byteArray">ByteArray对象</param>
        public void Add(ByteArray byteArray)
        {
            list.AddRange(byteArray.array);
        }

        public void Insert(int index, byte item)
        {
            list.Insert(index,item);
        }


        public void Insert(int index, byte[] item)
        {
            for (int i = 0; i < item.Length; i++)
            {
                list.Insert(index + i, item[i]);
            }
        }

        /// <summary>
        /// 添加一个ushort类型数值
        /// </summary>
        /// <param name="value">ushort类型数值</param>
        /// <param name="dataFormat">字节序</param>
        public void Add(ushort value,DataFormat dataFormat)
        {
            byte[] data = BitConverter.GetBytes(value);

            byte[] result = new byte[data.Length];

            switch (dataFormat)
            {
                case DataFormat.ABCD:
                case DataFormat.CDAB:
                    result[0] = data[1];
                    result[1] = data[0];
                    break;
                case DataFormat.BADC:
                case DataFormat.DCBA:
                    result[0] = data[0];
                    result[1] = data[1];
                    break;
                default:
                    break;
            }
            Add(result);
        }

        /// <summary>
        /// 添加一个short类型数值
        /// </summary>
        /// <param name="value">short类型数值</param>
        /// <param name="dataFormat">字节序</param>
        public void Add(short value, DataFormat dataFormat)
        {
            byte[] data = BitConverter.GetBytes(value);

            byte[] result = new byte[data.Length];

            switch (dataFormat)
            {
                case DataFormat.ABCD:
                case DataFormat.CDAB:
                    result[0] = data[1];
                    result[1] = data[0];
                    break;
                case DataFormat.BADC:
                case DataFormat.DCBA:
                    result[0] = data[0];
                    result[1] = data[1];
                    break;
                default:
                    break;
            }
            Add(result);
        }

        /// <summary>
        /// 添加一个ushort类型数值
        /// </summary>
        /// <param name="value">ushort类型数值</param>
        /// <param name="dataFormat">字节序</param>
        public void Insert(int index, ushort value, DataFormat dataFormat)
        {
            byte[] data = BitConverter.GetBytes(value);

            byte[] result = new byte[data.Length];

            switch (dataFormat)
            {
                case DataFormat.ABCD:
                case DataFormat.CDAB:
                    result[0] = data[1];
                    result[1] = data[0];
                    break;
                case DataFormat.BADC:
                case DataFormat.DCBA:
                    result[0] = data[0];
                    result[1] = data[1];
                    break;
                default:
                    break;
            }
            Insert(index, result);
        }

        /// <summary>
        /// 添加一个short类型数值
        /// </summary>
        /// <param name="value">short类型数值</param>
        /// <param name="dataFormat">字节序</param>
        public void Insert(int index, short value, DataFormat dataFormat)
        {
            byte[] data = BitConverter.GetBytes(value);

            byte[] result = new byte[data.Length];

            switch (dataFormat)
            {
                case DataFormat.ABCD:
                case DataFormat.CDAB:
                    result[0] = data[1];
                    result[1] = data[0];
                    break;
                case DataFormat.BADC:
                case DataFormat.DCBA:
                    result[0] = data[0];
                    result[1] = data[1];
                    break;
                default:
                    break;
            }
            Insert(index, result);
        }
    }

分析

这个类其实是对List集合的二次封装,但是会比集合增加了更多的功能,实际使用的时候代码也会比集合要简洁一些。

具体好不好用,用了就知道!

给大家看一个实际应用场景。

        /// <summary>
        /// 根据起始地址及长度,确定读取协议帧
        /// </summary>
        /// <param name="address">起始地址</param>
        /// <param name="length">长度</param>
        /// <returns>协议帧数据</returns>
        public  virtual OperateResult<byte[]> BuildReadMessageFrame(string address, ushort length)
        {
            var result = MelsecHelper.MelsecAddressAnalysis(address, IsFx5U);
            if (!result.IsSuccess) return OperateResult.CreateFailResult<byte[]>(result);

            //创建ByteArray对象
            ByteArray sendCommand = new ByteArray();
            // 副头部
            sendCommand.Add(0x50, 0x00);
            // 网络编号
            sendCommand.Add(NetworkNo);
            // 可编程控制器编号
            sendCommand.Add(0xFF);
            // 请求目标模块I/O编号
            sendCommand.Add(0xFF, 0x03);
            // 请求目标模块站号
            sendCommand.Add(DstModuleNo);
            // 请求数据长度
            sendCommand.Add(0x0C, 0x00);
            // CPU监视定时器
            sendCommand.Add(0x0A, 0x00);
            // 指令
            sendCommand.Add(0x01, 0x04);
            // 子指令
            sendCommand.Add(result.Content1.AreaType, 0x00);
            // 起始软元件
            byte[] startAddress = BitConverter.GetBytes(result.Content2);
            sendCommand.Add(startAddress[0], startAddress[1], startAddress[2]);
            // 软元件代码
            sendCommand.Add(result.Content1.AreaBinaryCode);
            // 软元件点数
            sendCommand.Add((byte)(length % 256), (byte)(length / 256));

            return OperateResult.CreateSuccessResult(sendCommand.array);
        }

我是新阁上位机付老师,用我的专业,成就你的梦想!

相关推荐

Redis集群对比:主从复制、哨兵模式、Cluster一文看懂所有优缺点

在分布式系统中,Redis作为高性能的内存数据库,其集群方案的选择直接影响到系统的稳定性、可用性和扩展性。本文将全面对比Redis的三种主流集群方案:主从复制、哨兵模式和Cluster模式,帮助开发者...

redis的主从复制,读写分离,主从切换

当数据量变得庞大的时候,读写分离还是很有必要的。同时避免一个redis服务宕机,导致应用宕机的情况,我们启用sentinel(哨兵)服务,实现主从切换的功能。redis提供了一个master,多个sl...

# Redis 入门到精通(九)-- 主从复制(3)

#Redis入门到精通(九)--主从复制(3)##一、redis主从复制-常见问题(1)###1、伴随着redis系统的运行,master的数据量会越来越大,一旦master重启...

redis - 主从复制(Redis主从复制时序图)

1引言在上一篇文章中,我们了解了Redis两种不同的持久化方式,Redis服务器通过持久化,把Redis内存中持久化到硬盘当中,当Redis宕机时,我们重启Redis服务器时,可以由RDB文件或AO...

# Redis 入门到精通(九)-- 主从复制(2)

#Redis入门到精通(九)--主从复制(2)##一、redis主从复制--数据同步阶段注意事项###1、数据同步阶段master说明1)如果master数据量巨大,数据同步阶段应...

Redis主从复制(redis主从复制主节点挂了)

介绍Redis有两种不同的持久化方式,Redis服务器通过持久化,把Redis内存中持久化到硬盘当中,当Redis宕机时,我们重启Redis服务器时,可以由RDB文件或AOF文件恢复内存中的数据。不过...

深入解析 Redis 集群的主从复制实现方式

在互联网大厂的后端开发领域,Redis作为一款高性能的内存数据库,被广泛应用于缓存、消息队列等场景。而Redis集群中的主从复制机制,更是保障数据安全、实现读写分离以及提升系统性能的关键所在。今...

Redis主从架构详解(redis主从架构高可用如何实现)

Redis主从架构搭建Redis主节点配置创建主节点目录(/opt/redis-master),复制redis.conf到该目录下,redis.conf配置项修改#后台启动daemonizeyes...

抖音“四大包塘战神”:承包了全网的快乐

在抖音钓鱼垂类领域,"包塘战神"军团正掀起一场黑色幽默风暴。空军华、大表坑、李赔光、透心良四位创作者,以承包鱼塘为舞台,用连续翻车的钓鱼直播构筑起流量奇观。当钓鱼佬在抖音集体转型喜剧人...

ORACLE 11G RAC 安装-通过VM配置共享磁盘

简介:在自己的电脑上通过VM软件搭建Oracle11GRAC,通过修改VM的参数文件来实现磁盘共享!目标:搭建RAC环境实现:使用VMwareWorkstation8.0.0+ORACLE...

Linux操作系统安全配置(linux系统安全配置包括)

一、服务相关命令systemctlenable服务名#开机自启动systemctldisable服务名#禁用开机自启动systemctlstop服务名#停止服务systemctls...

关于Linux性能调优中网络I/O的一些笔记

写在前面和小伙伴分享一些Linux网络优化的笔记,内容很浅,可以用作入门博文内容结合《Linux性能优化》读书笔记整理涉及内容包括常用的优化工具(mii-tool,ethtool,ifconfig,i...

从 Sonatype Nexus Repository Manager 迁移到 Artifactory

1.Nexus1.1下载下载链接:https://help.sonatype.com/repomanager3/product-information/download/download-archiv...

Ubuntu20安装zabbix5.0企业监控系统亲测教程

前言示例主机:zabbix10.0.100.10,将安装在UbuntuServer上教程说明:因使用官方教程无法安装成功,所以本教程与官方教程有所不同安装前提:已安装UbuntuServer2...

Linux内核设计与实现—进程管理(linux内核程序设计)

进程进程就是处于执行期的程序(目标码存放在某种存储介质上)。进并不仅仅局限于一段可执行程序代码(Unix称其为代码段,textsection)。通常进程还要包含其他资源,像打开的文件,挂起的信号,...