C#中的Byte，String，Int，Hex之間的轉換函數

整理轉換方法：

 public class BytesTranfer
    {
        /// <summary> Convert a string of hex digits (ex: E4 CA B2) to a byte array. </summary>
        /// <param name="s"> The string containing the hex digits (with or without spaces). </param>
        /// <returns> Returns an array of bytes. </returns>
        public byte[] HexStringToByteArray(string s)
        {
            s = s.Replace(" ", "");
            byte[] buffer = new byte[s.Length / 2];
            for (int i = 0; i < s.Length; i += 2)
            {
                buffer[i / 2] = (byte)Convert.ToByte(s.Substring(i, 2), 16);
            }

            return buffer;
        }

        /// <summary> Converts an array of bytes into a formatted string of hex digits (ex: E4 CA B2)</summary>
        /// <param name="data"> The array of bytes to be translated into a string of hex digits. </param>
        /// <returns> Returns a well formatted string of hex digits with spacing. </returns>
        public string ByteArrayToHexString(byte[] data)
        {
            StringBuilder sb = new StringBuilder(data.Length * 3);
            foreach (byte b in data)
            {
                sb.Append(Convert.ToString(b, 16).PadLeft(2, '0').PadRight(3, ' '));
            }

            return sb.ToString().ToUpper();
        }

        /// <summary>
        /// 將一條十六進制字符串轉換為ASCII
        /// </summary>
        /// <param name="hexstring">一條十六進制字符串</param>
        /// <returns>返回一條ASCII碼</returns>
        public static string HexStringToASCII(string hexstring)
        {
            byte[] bt = HexStringToBinary(hexstring);
            string lin = "";
            for (int i = 0; i < bt.Length; i++)
            {
                lin = lin + bt[i] + " ";
            }


            string[] ss = lin.Trim().Split(new char[] { ' ' });
            char[] c = new char[ss.Length];
            int a;
            for (int i = 0; i < c.Length; i++)
            {
                a = Convert.ToInt32(ss[i]);
                c[i] = Convert.ToChar(a);
            }

            string b = new string(c);
            return b;
        }


        /**/
        /// <summary>
        /// 16進制字符串轉換為二進制數組
        /// </summary>
        /// <param name="hexstring">用空格切割字符串</param>
        /// <returns>返回一個二進制字符串</returns>
        public static byte[] HexStringToBinary(string hexstring)
        {

            string[] tmpary = hexstring.Trim().Split(' ');
            byte[] buff = new byte[tmpary.Length];
            for (int i = 0; i < buff.Length; i++)
            {
                buff[i] = Convert.ToByte(tmpary[i], 16);
            }
            return buff;
        }


        /// <summary>
        /// 將byte型轉換為字符串
        /// </summary>
        /// <param name="arrInput">byte型數組</param>
        /// <returns>目標字符串</returns>
        private string ByteArrayToString(byte[] arrInput)
        {
            int i;
            StringBuilder sOutput = new StringBuilder(arrInput.Length);
            for (i = 0; i < arrInput.Length; i++)
            {
                sOutput.Append(arrInput[i].ToString("X2"));
            }
            //將此實例的值轉換為System.String
            return sOutput.ToString();
        }



        /// <summary>
        /// 對接收到的數據進行解包（將接收到的byte型數組解包為Unicode字符串）
        /// </summary>
        /// <param name="recbytes">byte型數組</param>
        /// <returns>Unicode編碼的字符串</returns>
        public string disPackage(byte[] recbytes)
        {
            string temp = "";
            foreach (byte b in recbytes)
                temp += b.ToString("X2") + " ";//ToString("X2") 為C#中的字符串格式控制符
            return temp;
        }

        /**
    * int轉byte[]
    * 該方法將一個int類型的數據轉換為byte[]形式，因為int為32bit，而byte為8bit所以在進行類型轉換時，知會獲取低8位，
    * 丟棄高24位。通過位移的方式，將32bit的數據轉換成4個8bit的數據。注意 &0xff，在這當中，&0xff簡單理解為一把剪刀，
    * 將想要獲取的8位數據截取出來。
    * @param i 一個int數字
    * @return byte[]
    */
        public static byte[] int2ByteArray(int i)
        {
            byte[] result = new byte[4];
            result[0] = (byte)((i >> 24) & 0xFF);
            result[1] = (byte)((i >> 16) & 0xFF);
            result[2] = (byte)((i >> 8) & 0xFF);
            result[3] = (byte)(i & 0xFF);
            return result;
        }
        /**
         * byte[]轉int
         * 利用int2ByteArray方法，將一個int轉為byte[]，但在解析時，需要將數據還原。同樣使用移位的方式，將適當的位數進行還原，
         * 0xFF為16進制的數據，所以在其后每加上一位，就相當於二進制加上4位。同時，使用|=號拼接數據，將其還原成最終的int數據
         * @param bytes byte類型數組
         * @return int數字
         */
        public static int bytes2Int(byte[] bytes)
        {
            int num = bytes[3] & 0xFF;
            num |= ((bytes[2] << 8) & 0xFF00);
            num |= ((bytes[1] << 16) & 0xFF0000);
            num |= ((bytes[0] << 24) & 0xFF0000);
            return num;
        }

        public static string Int2String(int str)
        {
            string S = Convert.ToString(str);
            return S;
        }

        public static int String2Int(string str)
        {
            int a;
            int.TryParse(str, out a);
            int a1 = Convert.ToInt32(str);
            return a1;
        }


        /*將int轉為低字節在后，高字節在前的byte數組
b[0] = 11111111(0xff) & 01100001
b[1] = 11111111(0xff) & 00000000
b[2] = 11111111(0xff) & 00000000
b[3] = 11111111(0xff) & 00000000
*/
        public byte[] IntToByteArray2(int value)
        {
            byte[] src = new byte[4];
            src[0] = (byte)((value >> 24) & 0xFF);
            src[1] = (byte)((value >> 16) & 0xFF);
            src[2] = (byte)((value >> 8) & 0xFF);
            src[3] = (byte)(value & 0xFF);
            return src;
        }
        //將高字節在前轉為int，低字節在后的byte數組(與IntToByteArray2想對應)
        public int ByteArrayToInt2(byte[] bArr)
        {
            if (bArr.Length != 4)
            {
                return -1;
            }
            return (int)((((bArr[0] & 0xff) << 24)
                       | ((bArr[1] & 0xff) << 16)
                       | ((bArr[2] & 0xff) << 8)
   | ((bArr[3] & 0xff) << 0)));
        }

        public static string StringToHexArray(string input)
        {
            char[] values = input.ToCharArray();
            StringBuilder sb = new StringBuilder(input.Length * 3);
            foreach (char letter in values)
            {
                // Get the integral value of the character.
                int value = Convert.ToInt32(letter);
                // Convert the decimal value to a hexadecimal value in string form.
                string hexOutput = String.Format("{0:X}", value);
                sb.Append(Convert.ToString(value, 16).PadLeft(2, '0').PadRight(3, ' '));
            }

            return sb.ToString().ToUpper();



        }
    }

附上查找資料過程中有用的一些資料地址：

https://www.cnblogs.com/ThreeS/articles/9377547.html

https://www.cnblogs.com/screes/p/5633383.html

還有一個關於補零的：https://blog.csdn.net/qq_22889875/article/details/79320678