給大家分享一個我經常使用的類【含源碼】

前言

今天跟大家分享一個我自己封裝，而且經常使用的類，話不多說，直接看源碼。

源碼

    /// <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);
        }