Как преобразовать числа между шестнадцатеричным и десятичным в C #?

Как конвертировать шестнадцатеричные и десятичные числа в C #?

вопрос задан 16.09.2008
Andy McCluggage
19067 репутация

15 ответов


  • 0 рейтинг

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

        /// 
    /// Turns the byte array into its Hex representation. ///
     
        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();
        }
    
    ответ дан Luke Puplett, с репутацией 19115, 12.07.2011
  • 0 рейтинг
        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.
        }
    
    ответ дан Ecstatic Coder, с репутацией 31, 20.03.2010
  • 0 рейтинг

    Преобразование из шестнадцатеричной системы в десятичную

    Convert.ToInt32(number, 16);
    

    Десятичное в шестнадцатеричное преобразование

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

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

    ответ дан user7925882, с репутацией 49, 22.05.2017
  • 0 рейтинг

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

    using System;
    using System.Collections.Generic;
    class HexadecimalToDecimal
    {
        static Dictionary hexdecval = new Dictionary{
            {'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();
        }
    }
    
    ответ дан Христо Панайотов, с репутацией 823, 12.01.2014
  • 0 рейтинг

    Преобразование двоичного кода в шестнадцатеричное

    Convert.ToString(Convert.ToUInt32(binary1, 2), 16).ToUpper()
    
    ответ дан Jewel, с репутацией 11, 29.04.2015
  • 0 рейтинг

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

    Программа

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

    Выход

    4F30DC39A5B10A824134D5B18EEA3707AC854EE565414ED2E498DCFDE1A15DA5FEB6074AE248458435BD417F06F674EB29A2CFECF
    

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

    ArgumentNullException - значение является нулем.

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

    Заключение

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

    ответ дан Aravin, с репутацией 1833, 30.03.2018
  • 0 рейтинг

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

    для. NET 3. 5, мы можем использовать класс BigInteger BouncyCastle:

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

    . NET 4. 0 имеет класс BigInteger .

    ответ дан msanjay, с репутацией 1189, 1.06.2011
  • 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();
        }
    }
    
    ответ дан Mihók Balázs, с репутацией 3, 9.02.2015
  • 0 рейтинг

    Это не самый простой способ, но этот исходный код позволяет вам исправить любые типы восьмеричных чисел i. е 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));
        }    
    
    ответ дан Omair, с репутацией 21, 17.12.2010
  • 0 рейтинг

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

    Вот код, который иллюстрирует эту идею. Мои тесты производительности показали, что он может быть на 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;
          }
      }
    
    ответ дан Vadym Stetsiak, с репутацией 1669, 3.02.2012
  • 0 рейтинг
    String stringrep = myintvar.ToString("X");
    
    int num = int.Parse("FF", System.Globalization.NumberStyles.HexNumber);
    
    ответ дан Sklivvz, с репутацией 23395, 16.09.2008
  • 0 рейтинг

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

    Convert.ToInt64(value, 16)
    

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

    Обратный путь:

    otherVar.ToString("X");
    
    ответ дан Jesper Blad Jensen, с репутацией 2351, 16.09.2008
  • 0 рейтинг

    Из 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);
    
    ответ дан Rob, с репутацией 463, 16.09.2008
  • 0 рейтинг

    Hex - & gt; десятичное число:

    Convert.ToInt64(hexValue, 16);
    

    Десятичное число - & gt; Шестнадцатеричный

    string.format("{0:x}", decValue);
    
    ответ дан Jonathan Rupp, с репутацией 13414, 16.09.2008
  • 0 рейтинг

    Для перевода из десятичного числа в шестнадцатеричное сделать , ,

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

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

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

    или

    int decValue = Convert.ToInt32(hexValue, 16);
    
    ответ дан Andy McCluggage, с репутацией 19067, 16.09.2008