C# 16进制字节转Int(涉及:Base64转byte数组)

十年河东,十年河西,莫欺少年穷

学无止境,精益求精

一个字节数组,如下:

 List<byte> by2 = new List<byte>() {0x55,0x22 };//8789

其对应的十进制的值为:8789

 从上图可知,C#中byte数组默认为低字节在前

再例如:

List<byte> by3 = new List<byte>() { 0x55, 0x22 ,0x11};//1122901

对应的十进制是:1122901

对应的16进制为:0x112255,如下:

 经过上述两个案例,C#byte数组中是按照低字节在前的方式排列的。

C#中有什么方法转化字节流为Int吗?

            List<byte> by2 = new List<byte>() {0x55,0x22 };//8789
            int ResultInt16 = BitConverter.ToInt16(by2.ToArray(), 0);
            List<byte> by4 = new List<byte>() { 0x55, 0x22, 0x11, 0x01 };//1428295937 
            int ResultInt32 = BitConverter.ToInt32(by4.ToArray(), 0);

涉及到两个方法:BitConverter.ToInt16 和 BitConverter.ToInt32

但是::BitConverter.ToInt这个方法只能转化长度为2或者长度为4的字节数组,如果字节长度为3,则无法转化。

譬如:

 List<byte> by3 = new List<byte>() { 0x55, 0x22 ,0x11};//1122901

因此,有必要做一个通用方法

在实际业务需求中,软硬件双方制定的通讯协议中经常为字节流指定是高字节在前?还是低字节在前?

因此,我总结的方法如下:

#region C# 字节转Int

        public static int GetValue(byte by)
        {
            return Convert.ToInt32(by);
        }

        #region 16进制转十进制 高字节在前
        /// <summary>
        /// 16进制转十进制 高字节在前
        /// </summary>
        /// <param name="Ary"></param>
        /// <returns></returns>
        public static int GetValue(List<byte> Ary)
        {
            double result = 0;
            var cm = 0;
            cm = Ary.Count;
            foreach (var item in Ary)
            {
                if (cm - 1 == 0)
                {
                    result += item;
                }
                else
                {
                    result += item * Math.Pow(16, (cm * 2 - 2));
                    cm--;
                }

            }
            return Convert.ToInt32(result);
        }
        /// <summary>
        /// 高字节在前
        /// </summary>
        /// <param name="Ary"></param>
        /// <returns></returns>
        public static int GetValue(IEnumerable<byte> Ary)
        {
            double result = 0;
            var cm = 0;
            cm = Ary.Count();
            foreach (var item in Ary)
            {
                if (cm - 1 == 0)
                {
                    result += item;
                }
                else
                {
                    result += item * Math.Pow(16, (cm * 2 - 2));
                    cm--;
                }

            }
            return Convert.ToInt32(result);
        }
        /// <summary>
        /// 16进制转十进制 具体参考十六进制的数值
        /// </summary>
        /// <param name="Ary"></param>
        /// <returns></returns>
        public static int GetValue(List<int> Ary)
        {
            double result = 0;
            var cm = 0;
            cm = Ary.Count;
            foreach (var item in Ary)
            {
                if (cm - 1 == 0)
                {
                    result += item;
                }
                else
                {
                    result += item * Math.Pow(16, (cm * 2 - 2));
                    cm--;
                }

            }
            return Convert.ToInt32(result);
        }
        /// <summary>
        /// 16进制转十进制
        /// </summary>
        /// <param name="Ary"></param>
        /// <returns></returns>
        public static int GetValue(IEnumerable<int> Ary)
        {
            double result = 0;
            var cm = 0;
            cm = Ary.Count();
            foreach (var item in Ary)
            {
                if (cm - 1 == 0)
                {
                    result += item;
                }
                else
                {
                    result += item * Math.Pow(16, (cm * 2 - 2));
                    cm--;
                }

            }
            return Convert.ToInt32(result);
        }
        #endregion

        #region 16进制转十进制 低字节在前
        /// <summary>
        /// 16进制转十进制 高字节在前
        /// </summary>
        /// <param name="Ary"></param>
        /// <returns></returns>
        public static int GetValueLH(List<byte> Ary)
        {
            Ary.Reverse();
            double result = 0;
            var cm = 0;
            cm = Ary.Count;
            foreach (var item in Ary)
            {
                if (cm - 1 == 0)
                {
                    result += item;
                }
                else
                {
                    result += item * Math.Pow(16, (cm * 2 - 2));
                    cm--;
                }

            }
            return Convert.ToInt32(result);
        }
        /// <summary>
        /// 低字节在前
        /// </summary>
        /// <param name="Ary"></param>
        /// <returns></returns>
        public static int GetValueLH(IEnumerable<byte> Ary)
        {
            Ary.Reverse();
            double result = 0;
            var cm = 0;
            cm = Ary.Count();
            foreach (var item in Ary)
            {
                if (cm - 1 == 0)
                {
                    result += item;
                }
                else
                {
                    result += item * Math.Pow(16, (cm * 2 - 2));
                    cm--;
                }

            }
            return Convert.ToInt32(result);
        }
        /// <summary>
        /// 16进制转十进制 低字节在前
        /// </summary>
        /// <param name="Ary"></param>
        /// <returns></returns>
        public static int GetValueLH(List<int> Ary)
        {
            Ary.Reverse();
            double result = 0;
            var cm = 0;
            cm = Ary.Count;
            foreach (var item in Ary)
            {
                if (cm - 1 == 0)
                {
                    result += item;
                }
                else
                {
                    result += item * Math.Pow(16, (cm * 2 - 2));
                    cm--;
                }

            }
            return Convert.ToInt32(result);
        }
        /// <summary>
        /// 16进制转十进制 低字节在前
        /// </summary>
        /// <param name="Ary"></param>
        /// <returns></returns>
        public static int GetValueLH(IEnumerable<int> Ary)
        {
            Ary.Reverse();
            double result = 0;
            var cm = 0;
            cm = Ary.Count();
            foreach (var item in Ary)
            {
                if (cm - 1 == 0)
                {
                    result += item;
                }
                else
                {
                    result += item * Math.Pow(16, (cm * 2 - 2));
                    cm--;
                }

            }
            return Convert.ToInt32(result);
        }
        #endregion

        #endregion

扩展:int数值转字节:

var by4 = BitConverter.GetBytes(8888);//长度四字节
var by2 = BitConverter.GetBytes(Convert.ToUInt16(8888));//长度两字节

C# base64 转 byte[]

        static void Main(string[] args)
        {
            string btinfo = @"MDAwMDAwMDAwMDAwMDAwMAHgAMgB7wAATjcBAXEBqAADAGEM7QzoR0UPDOkM6wzrDOkM6QzsDOwM7QzrDOgM6gzpDOoM6QzpAkdFAAAAAAANAQEBAQEBAAAAAAAAAAAAAAA=";
            var Bys = Encoding.Default.GetBytes(btinfo);
            var Bse64Bys = Convert.FromBase64String(btinfo);
            Console.WriteLine("普通byte数组,8位表示一个普通字符,长度为:"+Bys.Length);
            Console.WriteLine("Base64byte数组,6位表示一个base64字符,长度为:" + Bse64Bys.Length);
            Console.ReadLine();
        }

@天才卧龙的博客

原文地址:https://www.cnblogs.com/chenwolong/p/13958339.html