Comment convertir des nombres entre hexadécimal et décimal

Réponses:

281

Pour convertir de décimal en hexadécimal, faites ...

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

Pour convertir hexadécimal en décimal, procédez soit ...

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

ou 

int decValue = Convert.ToInt32(hexValue, 16);
— Andy McCluggage
source
1
Je voudrais comprendre comment cette ligne decValue.ToString ("X") la convertit en Hex.
— gizgok
20
La variable decValue est de type Int32. Int32 a une surcharge ToString () qui peut accepter l'une des nombreuses chaînes de format qui dictent la façon dont la valeur sera représentée sous forme de chaîne. La chaîne de format "X" signifie Hexidecimal donc 255.ToString ("X") renverra la chaîne hexadécimale "FF". Pour plus d'informations, consultez msdn.microsoft.com/en-us/library/dwhawy9k.aspx
— Andy McCluggage
2
Bonne réponse. J'utilise en fait int.TryParse au lieu de int.Parse pour éviter d'avoir à utiliser le bloc try catch ennuyeux.
— ROFLwTIME
9
@VadymStetsiak Convert.ToInt32 appelle simplement Int32.Parse (int.Parse) (face palm)
— Cole Johnson
@ColeJohnson int.Parsen'a pas d'option pour vous de spécifier la base comme un int, juste comme l'un des rares NumberStyles. Pour la base 16, c'est très bien, mais en tant que solution générale, il est bon de savoir comment les deux fonctionnent.
— Tim S.
54

Hex -> décimal:

Convert.ToInt64(hexValue, 16);

Décimal -> Hex

string.format("{0:x}", decValue);
— Jonathan Rupp
source
6
+1, ce Convert.ToInt64(hexValue, 16);qui est bien, c'est qu'il effectuera la conversion si le 0xpréfixe est présent ou non, alors que certaines des autres solutions ne le seront pas.
— Craig le
@Craig salut, donc je dois faire la conversion en fonction de la taille de la valeur hexadécimale ou je peux appliquer ToInt64 pour toutes les valeurs hexadécimales, y aura-t-il un impact?
— user1219310
26

On dirait que tu peux dire

Convert.ToInt64(value, 16)

pour obtenir la décimale à partir de hexdécimal.

L’inverse est:

otherVar.ToString("X");
— Jesper Blad Jensen
source
J'obtiens System.FormatException: Le format spécifié 'x' n'est pas valide
— c_Reg_c_Lark
13

Si vous voulez des performances maximales lors de la conversion d'un nombre hexadécimal en nombre décimal, vous pouvez utiliser l'approche avec un tableau pré-rempli de valeurs hexadécimales.

Voici le code qui illustre cette idée. Mes tests de performance ont montré qu'il peut être 20% -40% plus rapide que 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
source
Génie! Je me demande s'il est possible de faire en sorte que le compilateur d'octets utilise automatiquement cette approche dans Convert.ToInt32?
— Jeff Halverson
1
Je ne vois aucune raison pour laquelle cela ne peut être fait. Cependant, la maintenance de la baie consommera de la mémoire supplémentaire.
— Vadym Stetsiak
8

De 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
source
J'ai utilisé cette méthode pour créer une petite application dotnet 4.0 en quelques minutes, fonctionne très bien avec seulement quelques lignes de code.
— RatherLogical
2 
String stringrep = myintvar.ToString("X");

int num = int.Parse("FF", System.Globalization.NumberStyles.HexNumber);
— Sklivvz
source
1 
    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.
    }
— Codeur extatique
source
1

Ce n'est pas vraiment le moyen le plus simple mais ce code source vous permet de corriger tous les types de nombre octal, c'est-à-dire 23.214, 23 et 0.512 et ainsi de suite. J'espère que ceci vous aidera..

    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
source
2
Bienvenue sur stackoverflow. pourriez-vous s'il vous plaît expliquer un peu votre code (mybe juste une courte phrase). Merci!
— Daniele B
1

Essayez d'utiliser BigNumber en C # - Représente un entier signé arbitrairement grand.

Programme

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

Production

4F30DC39A5B10A824134D5B18EEA3707AC854EE565414ED2E498DCFDE1A15DA5FEB6074AE248458435BD417F06F674EB29A2CFECF

Exceptions possibles,

ArgumentNullException - la valeur est nulle.

FormatException - la valeur n'est pas au format correct.

Conclusion

Vous pouvez convertir une chaîne et stocker une valeur dans BigNumber sans contraintes sur la taille du nombre sauf si la chaîne est vide et non-analphabets

— Aravin
source
0

S'il s'agit d'une très grosse chaîne hexadécimale au-delà de la capacité de l'entier normal:

Pour .NET 3.5, nous pouvons utiliser la classe BigInteger de BouncyCastle:

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

.NET 4.0 a la classe BigInteger .

— msanjay
source
0

Ma version est je pense un peu plus compréhensible car mes connaissances en C # ne sont pas si élevées. J'utilise cet algorithme: http://easyguyevo.hubpages.com/hub/Convert-Hex-to-Decimal (l'exemple 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
source
0

Convertir binaire en hexadécimal

Convert.ToString(Convert.ToUInt32(binary1, 2), 16).ToUpper()
— Bijou
source
-1

Une méthode d'extension pour convertir un tableau d'octets en une représentation hexadécimale. Cela remplit chaque octet avec des zéros non significatifs.

    /// <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();
    }
— Luke Puplett
source
-1

Voici ma fonction:

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();
    }
}
— Chris Panayotoff
source
Cela pourrait être un bon candidat pour une Convertméthode d'extension afin que l'on puisse écrire: int hexa = Convert.ToHexadecimal(11);=)
— Will Marcouiller
-1

Ma solution est un peu comme un retour aux sources, mais elle fonctionne sans utiliser de fonctions intégrées pour convertir entre les systèmes numériques.

    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;
    }
— Krisztián Molnár
source
-1 
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);
        }

    }

}
— samets
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.