如何在C#中转换十六进制数和十进制数?

===============>>#1 票数:265 已采纳

要从十进制转换为十六进制,请...

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

要从十六进制转换为十进制,请执行...

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

要么

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

===============>>#2 票数:51

十六进制 - >十进制:

Convert.ToInt64(hexValue, 16);

十进制 - >十六进制

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

===============>>#3 票数:26

看起来你可以说

Convert.ToInt64(value, 16)

从十六进制中获取小数。

另一种方式是:

otherVar.ToString("X");

===============>>#4 票数:12

如果要在从十六进制转换为十进制数时获得最大性能,则可以使用预先填充的十六进制到十进制值表的方法。

以下是说明该想法的代码。 我的性能测试表明,它比Convert.ToInt32(...)快20%-40%:

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;
      }
  }

===============>>#5 票数:5

来自Geekpedia

// 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);

===============>>#6 票数:2

    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.
    }

===============>>#7 票数:2

十六进制到十进制转换

Convert.ToInt32(number, 16);

十进制到十六进制转换

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

有关详细信息,请查看此文章

===============>>#8 票数:2

这不是最简单的方法,但是这个源代码可以让你找到任何类型的八进制数,即23.214,23和0.512,依此类推。 希望对你有帮助..

    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));
    }    

===============>>#9 票数:2

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

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

===============>>#10 票数:1

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

程序

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

产量

4F30DC39A5B10A824134D5B18EEA3707AC854EE565414ED2E498DCFDE1A15DA5FEB6074AE248458435BD417F06F674EB29A2CFECF

可能的例外情况,

ArgumentNullException - value为null。

FormatException - 值的格式不正确。

结论

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

===============>>#11 票数:0

这是我的功能:

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();
    }
}

===============>>#12 票数:0

我认为我的版本更容易理解,因为我的C#知识不是那么高。 我正在使用这个算法: http//easyguyevo.hubpages.com/hub/Convert-Hex-to-Decimal (例2)

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("\nEnter Hexadecimal value: ");
        string hexNum = Console.ReadLine().ToUpper();

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

        Console.ReadKey();
    }
}

===============>>#13 票数:0

将二进制转换为Hex

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

===============>>#14 票数:0

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

    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;
    }

===============>>#15 票数:0

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);
        }

    }

}

===============>>#16 票数:0

如果它是超出普通整数容量的非常大的十六进制字符串:

对于.NET 3.5,我们可以使用BouncyCastle的BigInteger类:

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

.NET 4.0具有BigInteger类。

===============>>#17 票数:-1

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

    /// <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();
    }

  ask by Andy McCluggage translate from so

未解决问题?本站智能推荐:

4回复

如何在C#中将大十进制数字转换为十六进制(例如:588063595292424954445828)

该数字大于int & long但可以Decimal形式容纳。 但是普通的ToString或Convert方法在Decimal不起作用。
1回复

将十进制度数格式的纬度转换为十六进制值

我有一个以十进制度数格式的纬度值(32.60601045)。 如何将其转换为十六进制字符串? 我有一个C#程序,可以读取十六进制字符串并将其解码为不同的字段。 我知道字符串中某处存在纬度,其值会转换为32.60601045,因此我想将32.60601045的期望值转换为十六进制字符串,
1回复

如何将十六进制字符串转换为十进制值

我试图将十六进制字符串转换为十进制值,但它没有给我预期的结果 我试过convert.toint32(hexa,16) , convert.todecimal(hexa) 。 我有一个字符串看起来像这样: 1 12 94 201 198 我把它转换成: 10
1回复

从包含十六进制和十进制值的字符串输出数字

我正在从网站上抓取数据以获取对我的同事有用的数据,而不必经常刷新页面。 C#代码直接从HTML中提取数据。 但是数据以一种奇怪的方式加密,并以人类无法读取的字符串形式返回,这对我们没有帮助。 例如,在表格中,产品编号可以显示为“ 14501219”。 在HTML中,包含数据的元素
1回复

十六进制到十进制的转换

第一段代码在输出b.txt时将其每一行打印在新行中,第二段代码是从十六进制到十进制的转换。 我不太擅长编写大型程序,因此我分担了任务,而是编写了较小的程序。 我在合并这两个程序时遇到麻烦。 有人可以帮忙吗? 这是第二个程序
2回复

十六进制到十进制转换的未明确答案

我写的从十六进制到十进制数字的转换是有效的,但会得到一些意外的结果。 预期结果:十六进制数字“ 0000000F”,输出为十进制“ 15” 就我而言 1]如果“ 0000000F”是十六进制值,并且其转换为“ 1532” 2]如果“ 000000FF”是十六进制值,并且其
1回复

无法正确将十六进制转换为十进制

我在理解十六进制字节时遇到麻烦。 当手册中以十六进制表示的Header ID为7Fh时,则表示0111 1111对吗? 根据在线十六进制十进制转换器,它将转换为十进制127。 我看到的输出是 我在这里做错了什么?
2回复

PHP将十六进制转换为十进制不起作用

我正在尝试将十六进制值0d0c140d2f3b转换为十进制。 hexdec()和base_convert()给我的值为14345527177019 该值应为13 12 20 13 47 59 如果我应该使用其他功能,请告诉我。 谢谢
2回复

在Matlab中将十进制数组转换为十六进制数组

假设我在matlab工作区中有一个1x32双数组输入 。 此变量具有所有正的十进制值。 我想每个值转换为十六进制和它存储在另一个阵列输出 我使用dec2hex(Input) ,它会生成一个带有十六进制值的字符串。 现在,我想要一个十六进制数字而不是字符串的数组。 我如何将此十六进制
1回复

为什么javascript在分配给变量时会自动将十六进制值转换为十进制?

我正在尝试将十六进制格式的一些数据存储到JavaScript中的变量中,并以相同的格式读取数据。 当我尝试将变量分配给十六进制值并显示它时,我得到的十进制值等于十六进制。 我得到a = 15而不是a = 0x0F 。 为什么会这样呢? 是否可以本身获取十六进制格式的值?