Как преобразовать числа из шестнадцатеричного в десятичное

Чтобы преобразовать десятичное число в шестнадцатеричное, выполните ...

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

Чтобы преобразовать шестнадцатеричный формат в десятичный, выполните одно из следующих действий:

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

or

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

Шестнадцатеричный -> десятичный:

Convert.ToInt64(hexValue, 16);

Десятичный -> Шестнадцатеричный

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

Похоже, ты можешь сказать

Convert.ToInt64(value, 16)

чтобы получить десятичную дробь из шестнадцатеричной.

Другой способ:

otherVar.ToString("X");

Если вам нужна максимальная производительность при преобразовании из шестнадцатеричного числа в десятичное, вы можете использовать подход с предварительно заполненной таблицей шестнадцатеричных значений.

Вот код, который иллюстрирует эту идею. Мои тесты производительности показали, что он может быть на 20% -40% быстрее, чем Convert.ToInt32 (...):

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:

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

Преобразование шестнадцатеричных чисел в десятичные

Convert.ToInt32(number, 16);

Преобразование десятичных чисел в шестнадцатеричные

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

Подробнее см. в этой статье

Это не самый простой способ, но этот исходный код позволяет вам исправить любые типы восьмеричных чисел, например, 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));
    }    

Если это действительно большая шестнадцатеричная строка, превышающая емкость обычного целого числа:

Для .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.

Попробуйте использовать BigNumber в C # - представляет произвольно большое целое число со знаком.

Программа

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

Вывод

4F30DC39A5B10A824134D5B18EEA3707AC854EE565414ED2E498DCFDE1A15DA5FEB6074AE248458435BD417F06F674EB29A2CFECF

Возможные исключения,

ArgumentNullException - значение равно нулю.

FormatException - значение имеет неправильный формат.

Вывод

Вы можете преобразовать строку и сохранить значение в BigNumber без ограничений на размер числа, если только строка не пуста и не является аналфабетом.

Моя версия, я думаю, более понятна, потому что мои знания 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();
    }
}

Преобразовать двоичный файл в шестнадцатеричный

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

Вы можете использовать этот код и установить длину шестнадцатеричного кода и детали:

const int decimal_places = 4;
const int int_places = 4;
static readonly string decimal_places_format = $"X{decimal_places}";
static readonly string int_places_format = $"X{int_places}";

public static string DecimaltoHex(decimal number)
{
    var n = (int)Math.Truncate(number);
    var f = (int)Math.Truncate((number - n) * ((decimal)Math.Pow(10, decimal_places)));
    return $"{string.Format($"{{0:{int_places_format}}}", n)}{string.Format($"{{0:{decimal_places_format}}}", f)}";
}

public static decimal HextoDecimal(string number)
{
    var n = number.Substring(0, number.Length - decimal_places);
    var f = number.Substring(number.Length - decimal_places);
    return decimal.Parse($"{int.Parse(n, System.Globalization.NumberStyles.HexNumber)}.{int.Parse(f, System.Globalization.NumberStyles.HexNumber)}");
}

Это сработало для меня:

public static decimal HexToDec(string hex)
{
  if (hex.Length % 2 == 1)
    hex = "0" + hex;
  byte[] raw = new byte[hex.Length / 2];
  decimal d = 0;
    for (int i = 0; i < raw.Length; i++)
    {
      raw[i] = Convert.ToByte(hex.Substring(i * 2, 2), 16);
      d += Math.Pow(256, (raw.Length - 1 - i)) * raw[i];
    }
    return d.ToString();
  return d;
}

Десятичный - Hexa

        var decValue = int.Parse(Console.ReadLine());
        string hex = string.Format("{0:x}", decValue);
        Console.WriteLine(hex);

Hexa - Decimal (используйте пространство имен: using System.Globalization;)

        var hexval = Console.ReadLine();
        int decValue = int.Parse(hexval, NumberStyles.HexNumber);
        Console.WriteLine(decValue);

Метод расширения для преобразования массива байтов в шестнадцатеричное представление. Это дополняет каждый байт ведущими нулями.

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

Вот моя функция:

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

Мое решение немного похоже на основы, но оно работает без использования каких-либо встроенных функций для преобразования между системами счисления.

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