C#数据转换帮助类-进制转换

最新推荐文章于 2024-10-02 07:55:04 发布

Mo嘻哈

最新推荐文章于 2024-10-02 07:55:04 发布

阅读量117

点赞数 1

分类专栏： C# 文章标签： c# 算法开发语言

本文链接：https://blog.csdn.net/weixin_44391105/article/details/142175825

版权

C# 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

  #region 字节转换为二进制、十进制、十六进制

                byte a = 10;

                string data_2 = Convert.ToString(a, 2);    //字节转化为二进制

                string data_10 = Convert.ToString(a, 10);  //字节转化为十进制

                string data_16 = Convert.ToString(a, 16);  //字节转化为十六进制
 #endregion

 #region 二进制转为十进制、十六进制

                string x = "1010";

                //十进制
                int x1 = Convert.ToInt16(x, 2);
                int x2 = Convert.ToInt32(x, 2);
                long x3 = Convert.ToInt64(x, 2);

                //十六进制
                string x4 = string.Format("{0:X}", Convert.ToInt32(x, 2));

#endregion

#region 十进制转二进制、十六进制

                int y = 10;

                string y1 = Convert.ToString(y, 2);
                string y2 = Convert.ToString(y, 16).ToUpper();

#endregion

#region 十六进制转二进制、十进制

                int z = 0x0A;

                string Z1 = Convert.ToString(z, 2); //十六进制转二进制
                string Z2 = Convert.ToString(z, 10); //十六进制转十进制

#endregion

#region byte 转为char , 十进制转为char 

                //byte
                char c = Convert.ToChar(a);

                //10进制
                int ccc = 82;
                char c1 = Convert.ToChar(ccc);

#endregion

#region 字符串、十六进制字符串、字节数组 转换
                string str = "这是我的测试数据";

                string string_hex = StringToHexString(str, Encoding.Default);

                str = HexStringToString(string_hex);

                byte[] vv = HexStringToBytes(string_hex);

                string_hex = BytesToHexString(vv);

                byte[] aaa = StringToBytes(str,Encoding.Default);

                str = BytesToString(aaa);
#endregion

#region 十进制、十六进制 转换为二进制
                int r1 = 11;
                byte bbb = Convert.ToByte(r1);
                Console.WriteLine(Convert.ToString(bbb, 2).PadLeft(8, '0'));

                r1 = 0x0B;
                bbb = Convert.ToByte(r1);
                Console.WriteLine(Convert.ToString(bbb, 2).PadLeft(8, '0'));

                string ss = "0x0B";
                bbb = Convert.ToByte(ss, 16);
                Console.WriteLine(Convert.ToString(bbb, 2).PadLeft(8, '0'));
#endregion

#region Hex字符串 批量转为 ASCII

                string hex = "68656c6c6f20776f726c64"; // 要转换的十六进制字符串
                byte[] bytes = Enumerable.Range(0, hex.Length / 2)
.Select(d => Convert.ToByte(hex.Substring(d * 2, 2), 16))
.ToArray();
                string result = Encoding.Default.GetString(bytes);

#endregion

#region bit操作  一个字节八位

                byte bytetest = 0;
                bytetest = SetBit(bytetest, 0, 0);
                bytetest = SetBit(bytetest, 1, 0);
                bytetest = SetBit(bytetest, 2, 0);
                bytetest = SetBit(bytetest, 3, 0);
                bytetest = SetBit(bytetest, 4, 0);
                bytetest = SetBit(bytetest, 5, 0);
                bytetest = SetBit(bytetest, 6, 0);
                bytetest = SetBit(bytetest, 7, 1);

                Console.WriteLine("byte 转二进制" + Convert.ToString(bytetest, 2));
                Console.WriteLine("byte 转十进制" + Convert.ToString(bytetest, 10));
                Console.WriteLine("byte 转十六进制" + Convert.ToString(bytetest, 16));

                bytetest = SetBit(bytetest, 4, 1);

                Console.WriteLine("byte 转二进制" + Convert.ToString(bytetest, 2));
                Console.WriteLine("byte 转十进制" + Convert.ToString(bytetest, 10));
                Console.WriteLine("byte 转十六进制" + Convert.ToString(bytetest, 16));

                for (int i = 7; i >= 0; i--)
                {
                    var itemtest = GetBit(bytetest, i);
                    Console.WriteLine("每位值:" + itemtest);
                }

#endregion


        /// <summary>
        /// 字节数组转换为整数
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static int BytesToInt(byte[] bytes)
        {
            return BitConverter.ToInt32(bytes, 0);
        }

        /// <summary>
        /// 字节数组转换为整数
        /// </summary>
        /// <param name="bytes"></param>
        /// <param name="offset"></param>
        /// <returns></returns>
        public static int BytesToInt(byte[] bytes, int offset)
        {
            return (bytes[offset] & 0xFF) | ((bytes[offset + 1] & 0xFF) << 8);
        }

        /// <summary>
        /// 字节数组转换为字符串
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static string BytesToString(byte[] bytes)
        {
            string str = Encoding.Default.GetString(bytes);
            return str;
        }


        /// <summary>
        /// 字节数组转 空格分割的16进制字符串
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns>空格分割的16进制字符串</returns>
        public static string BytesToHexString(byte[] bytes)
        {
            if (bytes.Length<=0) 
            {
                return string.Empty;
            }
            string res=string.Empty;
            res = string.Join(" ", from s in bytes select s.ToString("X2"));

            return res;
        }


        #region 进制转换
        /// <summary>
        /// 字节转为2、10、16进制
        /// </summary>
        /// <param name="_byte">要转换的值</param>
        /// <param name="_tobase">要转换的进制 2,10,16</param>
        /// <returns></returns>
        public static string ConvertFromByte(byte _byte, int _tobase)
        {
            //eg:
            //byte a = 10;
            //string data_2 = Convert.ToString(a, 2);    //字节转化为二进制
            //string data_10 = Convert.ToString(a, 10);  //字节转化为十进制
            //string data_16 = Convert.ToString(a, 16);  //字节转化为十六进制

            string res = string.Empty;

            if (_tobase == 2)
            {
                res = Convert.ToString(_byte, 2).PadLeft(8, '0');    //字节转化为二进制
            }
            else if (_tobase == 10)
            {
                res = Convert.ToString(_byte, 10);    //字节转化为十进制
            }
            else if (_tobase == 16)
            {
                //res = Convert.ToString(_byte, 16).PadLeft(2,'0');    //字节转化为十六进制

                res = _byte.ToString("X2");
                //大写X：ToString("X2")即转化为大写的16进制。
                //小写x：ToString("x2")即转化为小写的16进制。
            }
            else
            {
                throw new Exception("no support");
            }
            return res;
        }



        /// <summary>
        /// 2进制转换为10、16进制
        /// </summary>
        /// <param name="_bin"></param>
        /// <param name="_tobase"></param>
        /// <returns></returns>
        public static string ConvertFromBinary(string _bin, int _tobase)
        {
            //string x = "1010";
            十进制
            //int x1 = Convert.ToInt16(x, 2);
            //int x2 = Convert.ToInt32(x, 2);
            //long x3 = Convert.ToInt64(x, 2);
            十六进制
            //string x4 = string.Format("{0:X}", Convert.ToInt32(x, 2));

            string res = string.Empty;

            if (_tobase == 10)
            {
                res = Convert.ToInt32(_bin, 2).ToString();
            }
            else if (_tobase == 16)
            {
                //先转10进制再转16进制

                //res = string.Format("{0:X}", Convert.ToInt32(_bin, 2));
                res = Convert.ToInt32(_bin, 2).ToString("X2");
            }

            return res;
        }

        /// <summary>
        /// 10进制转为2、16进制
        /// </summary>
        /// <param name="_DEC"></param>
        /// <param name="_tobase"></param>
        /// <returns></returns>
        public static string ConvertFromDecimal(int _DEC, int _tobase)
        {
            //int y = 10;
            //string y1 = Convert.ToString(y, 2);
            //string y2 = Convert.ToString(y, 16).ToUpper();

            string res = string.Empty;

            if (_tobase == 2)
            {
                res = Convert.ToString(_DEC, 2);
            }
            else if (_tobase == 16)
            {
                //res = Convert.ToString(_DEC, 16);

                // res = string.Format("{0:X}", Convert.ToString(_DEC, 16));

                res = _DEC.ToString("X2");
            }

            return res;
        }

        /// <summary>
        /// 16进制转为2、10进制
        /// </summary>
        /// <param name="_HEX"></param>
        /// <param name="_tobase"></param>
        /// <returns></returns>
        public static string ConvertFromHex(string _HEX, int _tobase)
        {
            //int z = 0x0A;
            //string Z1 = Convert.ToString(z, 2); //十六进制转二进制
            //string Z2 = Convert.ToString(z, 10); //十六进制转十进制

            string res = string.Empty;

            if (_tobase == 2)
            {
                int decimalValue = int.Parse(_HEX, System.Globalization.NumberStyles.HexNumber); // 先将十六进制转换为十进制
                res = Convert.ToString(decimalValue, 2).PadLeft(8, '0');
            }
            else if (_tobase == 10)
            {
                res = Convert.ToInt32(_HEX, 16).ToString();
            }

            return res;
        }
        #endregion

        #region char
        /// <summary>
        /// 字节转为char
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static char ConvertToChar(byte data)
        {
            char c = Convert.ToChar(data);
            return c;
        }

        /// <summary>
        /// 10进制数转为char
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static char ConvertToChar(int data)
        {
            char c = Convert.ToChar(data);
            return c;
        }
        #endregion


        /// <summary>
        /// 整数转换为字节数组
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        public static byte[] IntToBytes(int number)
        {
            return BitConverter.GetBytes(number);
        }

        /// <summary>
        /// 字符串转为字节数组
        /// </summary>
        /// <param name="str"></param>
        /// <param name="encode"></param>
        /// <returns></returns>
        public static byte[] StringToBytes(string str, Encoding encode)
        {
           return encode.GetBytes(str);
        }

        /// <summary>
        /// 字符串转16进制字符串(返回的字符串以空格分割)
        /// </summary>
        /// <param name="s"></param>
        /// <param name="encode"></param>
        /// <returns></returns>
        public static string StringToHexString(string str, Encoding encode)
        {
            //先转为byte数组
            //byte数组再转为16进制

            byte[] bytes = encode.GetBytes(str);  

            string res = string.Empty;

            res = string.Join(" ", from s in bytes select s.ToString("X2"));


            return res;
        }


        /// <summary>
        /// 16进制字符串转字节数组
        /// </summary>
        /// <param name="hexString"></param>
        /// <returns></returns>
        public static byte[] HexStringToBytes(string hexString)
        {
            hexString = hexString.Replace(" ", "");

            byte[] bytes = Enumerable.Range(0, hexString.Length / 2)
                                     .Select(d => Convert.ToByte(hexString.Substring(d * 2, 2), 16))
                                     .ToArray();
            return bytes;
        }



        /// <summary>
        /// 16进制字符串转字符串
        /// </summary>
        /// <param name="hexString">有无空格分割都可以</param>
        /// <returns></returns>
        public static string HexStringToString(string hexString)
        {
            //string hs = "68656c6c6f20776f726c64"; // 要转换的十六进制字符串
            //string hs = "68 65 6c 6c 6f 20 77 6f 72 6c 64"; // 要转换的十六进制字符串

            hexString = hexString.Replace(" ", "");

            #region 如果是纯 FFF 这样的数据，则忽略
            if (hexString == "F".PadLeft(hexString.Length, 'F'))
            {
                return string.Empty;
            }
            #endregion

            byte[] bytes = Enumerable.Range(0, hexString.Length / 2)
                                     .Select(d => Convert.ToByte(hexString.Substring(d * 2, 2), 16))
                                     .ToArray();

            string res = Encoding.ASCII.GetString(bytes);

            return res;
        }

        /// <summary>
        /// 16进制字符串转整数
        /// </summary>
        /// <param name="hexString"></param>
        /// <returns></returns>
        public static int HexStringToInt(string hexString)
        {
            byte[] bytes = DataConvertHelper.HexStringToBytes(hexString);
            int res = (BitConverter.ToInt32(bytes, 0));
            return res;
        }

        /// <summary>
        /// 获取字节中的指定索引的的BIT值
        /// </summary>
        /// <param name="SOUCE">字节</param>
        /// <param name="index">Bit的索引值(0-7)</param>
        /// <returns></returns>
        public static int GetBit(byte SOUCE, int index)
        {
            byte x = 1;
            switch (index)
            {
                case 0: { x = 0x01; } break;
                case 1: { x = 0x02; } break;
                case 2: { x = 0x04; } break;
                case 3: { x = 0x08; } break;
                case 4: { x = 0x10; } break;
                case 5: { x = 0x20; } break;
                case 6: { x = 0x40; } break;
                case 7: { x = 0x80; } break;
                default: { return 0; }
            }
            return (SOUCE & x) == x ? 1 : 0;
        }

        /// <summary>
        /// 设置字节里的指定索引的的 BIT值
        /// </summary>
        /// <param name="SOUCE"></param>
        /// <param name="index">序号</param>
        /// <param name="bitvalue">0或者1</param>
        /// <returns></returns>
        public static byte SetBit(byte SOUCE, int index, int bitvalue)
        {
            var _byte = SOUCE;
            if (bitvalue == 1)
            {
                switch (index)
                {
                    case 0: { return _byte |= 0x01; }
                    case 1: { return _byte |= 0x02; }
                    case 2: { return _byte |= 0x04; }
                    case 3: { return _byte |= 0x08; }
                    case 4: { return _byte |= 0x10; }
                    case 5: { return _byte |= 0x20; }
                    case 6: { return _byte |= 0x40; }
                    case 7: { return _byte |= 0x80; }
                    default: { return _byte; }
                }
            }
            else
            {
                switch (index)
                {
                    case 0: { return _byte &= 0xFE; }
                    case 1: { return _byte &= 0xFD; }
                    case 2: { return _byte &= 0xFB; }
                    case 3: { return _byte &= 0xF7; }
                    case 4: { return _byte &= 0xEF; }
                    case 5: { return _byte &= 0xDF; }
                    case 6: { return _byte &= 0xBF; }
                    case 7: { return _byte &= 0x7F; }
                    default: { return _byte; }
                }
            }
        }

        /// <summary>
        /// 从指定的数组里截取数据
        /// </summary>
        /// <param name="skip_count"></param>
        /// <param name="take_count"></param>
        /// <param name="dataArray"></param>
        /// <returns></returns>
        public static List<byte> TakeSkipData(int skip_count, int take_count, List<byte> dataArray)
        {
            //var list = new List<int>();
            比如  list里面是 1,2,3,4,5,6,7,8,9,10
            //var result = list.Skip(2);   //返回值就是 3,4,5,6,7,8,9,10;
            //var result = list.Take(2);   //返回值就是 1,2
            //var result = list.Skip(2).Take(2);  //返回值 3,4 

            var result = dataArray.Skip(skip_count).Take(take_count).ToList();

            return result;
        }