关于C＃：如何在十六进制和十进制之间转换数字

How to convert numbers between hexadecimal and decimal

如何在C＃中的十六进制数和十进制数之间转换？

要将十进制转换为十六进制，请执行以下操作...

1	string hexValue = decValue.ToString("X");

要将十六进制转换为十进制，请执行以下任一操作：

1	int decValue = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber);

要么

1	int decValue = Convert.ToInt32(hexValue, 16);

十六进制->小数：

1	Convert.ToInt64(hexValue, 16);

十进制->十六进制

1	string.format("{0:x}", decValue);

看来你可以说

1	Convert.ToInt64(value, 16)

从十六进制获取小数。

另一种方法是：

1	otherVar.ToString("X");

如果要在从十六进制到十进制数的转换中获得最佳性能，则可以将方法与预填充的十六进制到十进制值的表一起使用。

这是说明该想法的代码。我的性能测试表明，它可以比Convert.ToInt32(...)快20％-40％：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class TableConvert
{
static sbyte[] unhex_table =
{ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1
,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
};

public static int Convert(string hexNumber)
{
int decValue = unhex_table[(byte)hexNumber[0]];
for (int i = 1; i < hexNumber.Length; i++)
{
decValue *= 16;
decValue += unhex_table[(byte)hexNumber[i]];
}
return decValue;
}
}

从Geekpedia：

1
2
3
4
5
6
7
8

// Store integer 182
int decValue = 182;

// Convert integer 182 as a hex in a string variable
string hexValue = decValue.ToString("X");

// Convert the hex string back to the number
int decAgain = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber);

十六进制到十进制转换

1	Convert.ToInt32(number, 16);

十进制到十六进制转换

1	int.Parse(number, System.Globalization.NumberStyles.HexNumber)

有关更多详细信息，请查看本文

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

static string chex(byte e) // Convert a byte to a string representing that byte in hexadecimal
{
string r ="";
string chars ="0123456789ABCDEF";
r += chars[e >> 4];
return r += chars[e &= 0x0F];
} // Easy enough...

static byte CRAZY_BYTE(string t, int i) // Take a byte, if zero return zero, else throw exception (i=0 means false, i>0 means true)
{
if (i == 0) return 0;
throw new Exception(t);
}

static byte hbyte(string e) // Take 2 characters: these are hex chars, convert it to a byte
{ // WARNING: This code will make small children cry. Rated R.
e = e.ToUpper(); //
string msg ="INVALID CHARS"; // The message that will be thrown if the hex str is invalid

byte[] t = new byte[] // Gets the 2 characters and puts them in seperate entries in a byte array.
{ // This will throw an exception if (e.Length != 2).
(byte)e[CRAZY_BYTE("INVALID LENGTH", e.Length ^ 0x02)],
(byte)e[0x01]
};

for (byte i = 0x00; i < 0x02; i++) // Convert those [ascii] characters to [hexadecimal] characters. Error out if either character is invalid.
{
t[i] -= (byte)((t[i] >= 0x30) ? 0x30 : CRAZY_BYTE(msg, 0x01)); // Check for 0-9
t[i] -= (byte)((!(t[i] < 0x0A)) ? (t[i] >= 0x11 ? 0x07 : CRAZY_BYTE(msg, 0x01)) : 0x00); // Check for A-F
}

return t[0x01] |= t[0x00] <<= 0x04; // The moment of truth.
}

这并不是真正最简单的方法，但是此源代码使您可以纠正任何类型的八进制数，即23.214、23和0.512等。希望这个能对您有所帮助..

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

public string octal_to_decimal(string m_value)
{
double i, j, x = 0;
Int64 main_value;
int k = 0;
bool pw = true, ch;
int position_pt = m_value.IndexOf(".");
if (position_pt == -1)
{
main_value = Convert.ToInt64(m_value);
ch = false;
}
else
{
main_value = Convert.ToInt64(m_value.Remove(position_pt, m_value.Length - position_pt));
ch = true;
}

while (k <= 1)
{
do
{
i = main_value % 10; // Return Remainder
i = i * Convert.ToDouble(Math.Pow(8, x)); // calculate power
if (pw)
x++;
else
x--;
o_to_d = o_to_d + i; // Saving Required calculated value in main variable
main_value = main_value / 10; // Dividing the main value
}
while (main_value >= 1);
if (ch)
{
k++;
main_value = Convert.ToInt64(Reversestring(m_value.Remove(0, position_pt + 1)));
}
else
k = 2;
pw = false;
x = -1;
}
return (Convert.ToString(o_to_d));
}

1
2
3

String stringrep = myintvar.ToString("X");

int num = int.Parse("FF", System.Globalization.NumberStyles.HexNumber);

尝试在C＃中使用BigNumber-表示任意大的有符号整数。

程序

1
2
3
4

using System.Numerics;
...
var bigNumber = BigInteger.Parse("837593454735734579347547357233757342857087879423437472347757234945743");
Console.WriteLine(bigNumber.ToString("X"));

输出量

1	4F30DC39A5B10A824134D5B18EEA3707AC854EE565414ED2E498DCFDE1A15DA5FEB6074AE248458435BD417F06F674EB29A2CFECF

可能的例外，

ArgumentNullException-值为null。

FormatException-值的格式不正确。

结论

您可以转换字符串并将值存储在BigNumber中，而不受数字大小的限制，除非字符串为空且非字母

如果它是一个超出正常整数容量的非常大的十六进制字符串：

对于.NET 3.5，我们可以使用BouncyCastle的BigInteger类：

1
2
3

String hex ="68c7b05d0000000002f8";
// results in"494809724602834812404472"
String decimal = new Org.BouncyCastle.Math.BigInteger(hex, 16).ToString();

.NET 4.0具有BigInteger类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

class HexToDecimal
{
static void Main()
{
while (true)
{
Console.Write("Enter digit number to convert:");
int n = int.Parse(Console.ReadLine()); // set hexadecimal digit number
Console.Write("Enter hexadecimal number:");
string str = Console.ReadLine();
str.Reverse();

char[] ch = str.ToCharArray();
int[] intarray = new int[n];

decimal decimalval = 0;

for (int i = ch.Length - 1; i >= 0; i--)
{
if (ch[i] == '0')
intarray[i] = 0;
if (ch[i] == '1')
intarray[i] = 1;
if (ch[i] == '2')
intarray[i] = 2;
if (ch[i] == '3')
intarray[i] = 3;
if (ch[i] == '4')
intarray[i] = 4;
if (ch[i] == '5')
intarray[i] = 5;
if (ch[i] == '6')
intarray[i] = 6;
if (ch[i] == '7')
intarray[i] = 7;
if (ch[i] == '8')
intarray[i] = 8;
if (ch[i] == '9')
intarray[i] = 9;
if (ch[i] == 'A')
intarray[i] = 10;
if (ch[i] == 'B')
intarray[i] = 11;
if (ch[i] == 'C')
intarray[i] = 12;
if (ch[i] == 'D')
intarray[i] = 13;
if (ch[i] == 'E')
intarray[i] = 14;
if (ch[i] == 'F')
intarray[i] = 15;

decimalval += intarray[i] * (decimal)Math.Pow(16, ch.Length - 1 - i);

}

Console.WriteLine(decimalval);
}

}

}

这是我的功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

using System;
using System.Collections.Generic;
class HexadecimalToDecimal
{
static Dictionary<char, int> hexdecval = new Dictionary<char, int>{
{'0', 0},
{'1', 1},
{'2', 2},
{'3', 3},
{'4', 4},
{'5', 5},
{'6', 6},
{'7', 7},
{'8', 8},
{'9', 9},
{'a', 10},
{'b', 11},
{'c', 12},
{'d', 13},
{'e', 14},
{'f', 15},
};

static decimal HexToDec(string hex)
{
decimal result = 0;
hex = hex.ToLower();

for (int i = 0; i < hex.Length; i++)
{
char valAt = hex[hex.Length - 1 - i];
result += hexdecval[valAt] * (int)Math.Pow(16, i);
}

return result;
}

static void Main()
{

Console.WriteLine("Enter Hexadecimal value");
string hex = Console.ReadLine().Trim();

//string hex ="29A";
Console.WriteLine("Hex {0} is dec {1}", hex, HexToDec(hex));

Console.ReadKey();
}
}

我的版本更容易理解，因为我的C＃知识不是很高。
我正在使用此算法：http://easyguyevo.hubpages.com/hub/Convert-Hex-to-Decimal(示例2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

using System;
using System.Collections.Generic;

static class Tool
{
public static string DecToHex(int x)
{
string result ="";

while (x != 0)
{
if ((x % 16) < 10)
result = x % 16 + result;
else
{
string temp ="";

switch (x % 16)
{
case 10: temp ="A"; break;
case 11: temp ="B"; break;
case 12: temp ="C"; break;
case 13: temp ="D"; break;
case 14: temp ="E"; break;
case 15: temp ="F"; break;
}

result = temp + result;
}

x /= 16;
}

return result;
}

public static int HexToDec(string x)
{
int result = 0;
int count = x.Length - 1;
for (int i = 0; i < x.Length; i++)
{
int temp = 0;
switch (x[i])
{
case 'A': temp = 10; break;
case 'B': temp = 11; break;
case 'C': temp = 12; break;
case 'D': temp = 13; break;
case 'E': temp = 14; break;
case 'F': temp = 15; break;
default: temp = -48 + (int)x[i]; break; // -48 because of ASCII
}

result += temp * (int)(Math.Pow(16, count));
count--;
}

return result;
}
}

class Program
{
static void Main(string[] args)
{
Console.Write("Enter Decimal value:");
int decNum = int.Parse(Console.ReadLine());

Console.WriteLine("Dec {0} is hex {1}", decNum, Tool.DecToHex(decNum));

Console.Write("
Enter Hexadecimal value:");
string hexNum = Console.ReadLine().ToUpper();

Console.WriteLine("Hex {0} is dec {1}", hexNum, Tool.HexToDec(hexNum));

Console.ReadKey();
}
}

将二进制转换为十六进制

1	Convert.ToString(Convert.ToUInt32(binary1, 2), 16).ToUpper()

我的解决方案有点像回到基础，但是它可以在不使用任何内置函数在数字系统之间转换的情况下工作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public static string DecToHex(long a)
{
int n = 1;
long b = a;
while (b > 15)
{
b /= 16;
n++;
}
string[] t = new string[n];
int i = 0, j = n - 1;
do
{
if (a % 16 == 10) t[i] ="A";
else if (a % 16 == 11) t[i] ="B";
else if (a % 16 == 12) t[i] ="C";
else if (a % 16 == 13) t[i] ="D";
else if (a % 16 == 14) t[i] ="E";
else if (a % 16 == 15) t[i] ="F";
else t[i] = (a % 16).ToString();
a /= 16;
i++;
}
while ((a * 16) > 15);
string[] r = new string[n];
for (i = 0; i < n; i++)
{
r[i] = t[j];
j--;
}
string res = string.Concat(r);
return res;
}

一种用于将字节数组转换为十六进制表示形式的扩展方法。这用前导零填充每个字节。

1
2
3
4
5
6
7
8
9
10
11
12

/// <summary>
/// Turns the byte array into its Hex representation.
/// </summary>
public static string ToHex(this byte[] y)
{
StringBuilder sb = new StringBuilder();
foreach (byte b in y)
{
sb.Append(b.ToString("X").PadLeft(2,"0"[0]));
}
return sb.ToString();
}