C#实现十六进制与十进制相互转换以及及不同进制表示

目录

前言C#中数字的进制表示形式十六进制转十进制

代码实现十六进制转十进制C#内置方法16转10进制

Convert.ToInt32()int.Parse()和int.TryParse



十进制转十六进制

代码实现十进制转十六进制C#内置方法10转16进制

Convert.ToString() 转换数字为不同的进制.ToString()方法string.Format()Convert.ToString()实现将数字转换为特定进制的字符串



实现进制转换的Winform程序参考总结

前言

在程序中，十六进制的表示形式通常为字符串；而十进制则为数字整型（本质的内存存储都是01二进制）。数字的进制表示一般使用的不多，通常最大的需求是进制之间的相互转换。C#中提供了内置的转换方法，同时，我们也可以依据不同进制之间的规则自己实现进制之间的转换。

C#中数字的进制表示形式

对于进制的表示，编程语言基本上都提供了特殊前缀表示不同进制的数字，一般0x/0X表示16进制、0o/0O表示8进制、0b/0B表示2进制，十进制数字则没有特殊前缀，直接输入数字即可。

C#中没有对8进制数字的直接表示形式。对于这个几乎用不到的历史遗留的进制，编程中很少会使用。通常比较常用的是2进制和16进制。

比如，下面举例的不同进制的数字表示形式：

1. // 16进制表示
2. var hexadecimal = 0xaf2;
3. Console.WriteLine(hexadecimal); // 2802
5. // 2进制表示
6. var binary = 0b1011110000;
7. Console.WriteLine(binary);  // 752
9. // 10进制
10. var decimal_ = 910;
11. Console.WriteLine(decimal_); // 910

复制代码

十六进制转十进制

十六进制到十进制的转换可以通过下面的步骤实现：

从十六进制数字的最右侧（个位）开始获取每一位的数字获取的数字乘以16^n，n从0开始将相乘后的结果相加到最终值以等值的十进制对应十六进制，比如 A或a作为10，B或b作为11

代码实现十六进制转十进制

下面的代码使用上面介绍的算法，实现将十六进制字符串转换为十进制数字，通过遍历十六进制的字符得到最后的值。

使用正则验证传入的是否是合格的16进制字符串。

1. /// <summary>
2. /// Hex十六进制数字转十进制
3. /// </summary>
4. /// <param name="hex"></param>
5. /// <returns></returns>
6. public static int HexToDecimal(string hex)
7. {
8.    if (!Regex.Match(hex, "^[0-9A-F]$", RegexOptions.IgnoreCase).Success)
9.    {
10.        throw new Exception("不是十六进制数字");
11.    }
13.    var decimalValue = 0;
15.    var hexUp = hex.ToUpper();
16.    // 从最后一位到第一位循环获取每位的值，并乘以基数的n-1次方
17.    for (int i = hexUp.Length-1; i >= 0; i--)
18.    {
19.        int currV = 0;
20.        switch (hexUp[i])
21.        {
22.            case 'A':
23.                currV = 10;
24.                break;
25.            case 'B':
26.                currV = 11;
27.                break;
28.            case 'C':
29.                currV = 12;
30.                break;
31.            case 'D':
32.                currV = 13;
33.                break;
34.            case 'E':
35.                currV = 14;
36.                break;
37.            case 'F':
38.                currV = 15;
39.                break;
40.            case '0':
41.                currV = 0;
42.                break;
43.            case '1':
44.                currV = 1;
45.                break;
46.            case '2':
47.                currV = 2;
48.                break;
49.            case '3':
50.                currV = 3;
51.                break;
52.            case '4':
53.                currV = 4;
54.                break;
55.            case '5':
56.                currV = 5;
57.                break;
58.            case '6':
59.                currV = 6;
60.                break;
61.            case '7':
62.                currV = 7;
63.                break;
64.            case '8':
65.                currV = 8;
66.                break;
67.            case '9':
68.                currV = 9;
69.                break;
70.            default:
71.                break;
72.        }
74.        for (int n = 0; n < hexUp.Length - 1 -i; n++)
75.        {
76.            currV *= 16;
77.        }
78.        decimalValue += currV;
79.    }
80.    return decimalValue;
81. }

复制代码

基本逻辑和介绍的一致。
参考文章中给出了更加清晰的逻辑处理，和介绍的处理算法完全逻辑一致，尤其Multiplier的使用，比较巧妙，推荐。代码如下：

1. /// <summary>
2. /// 另一种16进制转10进制的处理方式，Multiplier参与*16的循环很巧妙，对Multiplier的处理很推荐，逻辑统一
3. /// </summary>
4. /// <param name="HexaDecimalString"></param>
5. /// <returns></returns>
6. public static int HexaToDecimal(string HexaDecimalString)
7. {
8.    int Decimal = 0;
9.    int Multiplier = 1;
11.    for (int i = HexaDecimalString.Length - 1; i >= 0; i--)
12.    {
13.        Decimal += HexaToDecimal(HexaDecimalString[i]) * Multiplier;
14.        Multiplier *= 16;
15.    }
16.    return Decimal;
17. }
19. static int HexaToDecimal(char c)
20. {
21.    switch (c)
22.    {
23.        case '0':
24.            return 0;
25.        case '1':
26.            return 1;
27.        case '2':
28.            return 2;
29.        case '3':
30.            return 3;
31.        case '4':
32.            return 4;
33.        case '5':
34.            return 5;
35.        case '6':
36.            return 6;
37.        case '7':
38.            return 7;
39.        case '8':
40.            return 8;
41.        case '9':
42.            return 9;
43.        case 'A':
44.        case 'a':
45.            return 10;
46.        case 'B':
47.        case 'b':
48.            return 11;
49.        case 'C':
50.        case 'c':
51.            return 12;
52.        case 'D':
53.        case 'd':
54.            return 13;
55.        case 'E':
56.        case 'e':
57.            return 14;
58.        case 'F':
59.        case 'f':
60.            return 15;
61.    }
62.    return -1;
63. }

复制代码

C#内置方法16转10进制


Convert.ToInt32()

Convert.ToInt32的第二个参数可以指定进制数，从而转为32位的10进制int整型。

1. Convert.ToInt32(hexStr,16)

复制代码

同理，可以根据需要，将2进制、8进制的字符串转换为10进制的int类型。

int.Parse()和int.TryParse

int.Parse(hexStr,System.Globalization.NumberStyles.HexNumber) 第二个参数指定当前为HexNumber数字，实现16转10进制。
int.TryParse同理。

十进制转十六进制


代码实现十进制转十六进制

实现步骤对应上面16转10进制的过程，代码如下：

1. /// <summary>
2. /// 十进制数字转十六进制
3. /// </summary>
4. /// <param name="dec">十进制数字</param>
5. /// <param name="lower">16进制结果是否为小写，默认false</param>
6. /// <returns></returns>
7. public static string DecimalToHex(int dec, bool lower = false)
8. {
9.    var hexBuilder = new StringBuilder();
10.    while (dec != 0)
11.    {
12.        var currV = dec % 16;
14.        char currHex;
15.        switch (currV)
16.        {
17.            case 0:
18.                currHex = '0';
19.                break;
20.            case 1:
21.                currHex = '1';
22.                break;
23.            case 2:
24.                currHex = '2';
25.                break;
26.            case 3:
27.                currHex = '3';
28.                break;
29.            case 4:
30.                currHex = '4';
31.                break;
32.            case 5:
33.                currHex = '5';
34.                break;
35.            case 6:
36.                currHex = '6';
37.                break;
38.            case 7:
39.                currHex = '7';
40.                break;
41.            case 8:
42.                currHex = '8';
43.                break;
44.            case 9:
45.                currHex = '9';
46.                break;
47.            case 10:
48.                currHex = 'A';
49.                break;
50.            case 11:
51.                currHex = 'B';
52.                break;
53.            case 12:
54.                currHex = 'C';
55.                break;
56.            case 13:
57.                currHex = 'D';
58.                break;
59.            case 14:
60.                currHex = 'E';
61.                break;
62.            case 15:
63.                currHex = 'F';
64.                break;
65.            default:
66.                currHex = '-';
67.                break;
68.        }
69.        // 从个位即最右边开始往前获取16进制值
70.        hexBuilder.Insert(0, currHex);
72.        dec /= 16;
73.    }
75.    return lower ? hexBuilder.ToString().ToLower() : hexBuilder.ToString();
76. }

复制代码

C#内置方法10转16进制


Convert.ToString() 转换数字为不同的进制

Convert.ToString(dec, 16)的第二个参数可以指定要换为的字符串的进制数。
它转换的结构是小写表示的16进制，且个位数时为单数，即如果是5，其结果为"5"，如果是F，其结果为"F"。

.ToString()方法

dec.ToString("X2") 或 dec.ToString("X") 将整型转为16进制。

X2表示个位是两位的16进制，比如5表示为"05"，F表示为"0F"。在用Hex格式表示二进制时很常用，2位16进制FF正好表示8位一个字节。X表示16进制格式。

dec.ToString("x2") 或 dec.ToString("x") 中使用小写x，则转换为对应的小写的16进制字符串，比如15转换为"f"或"0f"。【X对应为大写】。

string.Format()

与.ToString()方法同样的格式化要求。
string.Format("{0:X2}", dec) 或 string.Format("{0:X}",dec) 将整型转为16进制。

Convert.ToString()实现将数字转换为特定进制的字符串

将decimal_2分别转换为16进制、8进制、2进制的字符串

1. var decimal_2 = 15;
2. Console.WriteLine($"{decimal_2}的16进制表示{Convert.ToString(decimal_2, 16)}");
3. Console.WriteLine($"{decimal_2}的8进制表示{Convert.ToString(decimal_2, 8)}");
4. Console.WriteLine($"{decimal_2}的2进制表示{Convert.ToString(decimal_2, 2)}");
5. // 15的16进制表示f
6. // 15的8进制表示17
7. // 15的2进制表示1111

复制代码

实现进制转换的Winform程序

新建一个简单的Winform项目HEXAndDECInterConvert，窗体添加从16进制的TextBox输入框转为10进制TextBox输出框、从10进制的TextBox输入框转为16进制TextBox输出框。
在输入框的TextChanged中，分别完成进制的转换

1. hexFromTxt.TextChanged += HexFromTxt_TextChanged;
2. decFromTxt.TextChanged += DecFromTxt_TextChanged;
4. // .......
6.         private void DecFromTxt_TextChanged(object sender, EventArgs e)
7.         {
8.             var decStr = decFromTxt.Text.Trim();
9.             if (!int.TryParse(decStr, out int dec))
10.             {
11.                 // 不是数字或者不能正确的转为数字则清空
12.                 decFromTxt.Text =hexToTxt.Text = "";
13.                 return;
14.             }
16.             var hex1 = HexDecConvert.DecimalToHex(dec);
17.             hexToTxt.Text = hex1;
19.             var tmp = Convert.ToString(dec, 16); // ab..f等为小写表示
20.             // X2表示两位的16进制，比如5表示为05
21.             // X表示16进制格式
22.             var tmp2 = dec.ToString("X2");
23.             var tmp3 = string.Format("{0:X2}", dec);
25.         }
27.         private void HexFromTxt_TextChanged(object sender, EventArgs e)
28.         {
29.             var hex = hexFromTxt.Text.Trim();
30.             var dec1 = HexDecConvert.HexToDecimal(hex);
31.             var dec2 = HexDecConvert.HexaToDecimal(hex);
32.             decToTxt.Text = dec1.ToString();
33.             decToTxt2.Text = dec2.ToString();
35.         }

复制代码

效果如下：

参考

4 ways in C# to convert a hexadecimal value to Decimal

总结

到此这篇关于C#实现十六进制与十进制相互转换以及及不同进制表示的文章就介绍到这了,更多相关C#十六进制与十进制相互转换内容请搜索中国红客联盟以前的文章或继续浏览下面的相关文章希望大家以后多多支持中国红客联盟！