Convertir un entier en hexadécimal et inversement

Comment puis-je convertir les éléments suivants?

2934 (entier) à B76 (hex)

Permettez-moi d'expliquer ce que j'essaie de faire. J'ai des ID utilisateur dans ma base de données qui sont stockés sous forme d'entiers. Plutôt que de demander aux utilisateurs de référencer leurs identifiants, je veux les laisser utiliser la valeur hexadécimale. La raison principale est qu'il est plus court.

Donc, non seulement je dois passer de l'entier à l'hex, mais je dois aussi passer de l'hex à l'entier.

Existe-t-il un moyen simple de le faire en C #?

// Store integer 182
int intValue = 182;
// Convert integer 182 as a hex in a string variable
string hexValue = intValue.ToString("X");
// Convert the hex string back to the number
int intAgain = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber);

depuis http://www.geekpedia.com/KB8_How-do-I-convert-from-decimal-to-hex-and-hex-to-decimal.html

Utilisation:

int myInt = 2934;
string myHex = myInt.ToString("X");  // Gives you hexadecimal
int myNewInt = Convert.ToInt32(myHex, 16);  // Back to int again.

Consultez Comment: convertir entre des chaînes hexadécimales et des types numériques (Guide de programmation C #) pour plus d'informations et d'exemples.

Essayez ce qui suit pour le convertir en hexadécimal

public static string ToHex(this int value) {
  return String.Format("0x{0:X}", value);
}

Et encore une fois

public static int FromHex(string value) {
  // strip the leading 0x
  if ( value.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) {
    value = value.Substring(2);
  }
  return Int32.Parse(value, NumberStyles.HexNumber);
}

int valInt = 12;
Console.WriteLine(valInt.ToString("X"));  // C  ~ possibly single-digit output 
Console.WriteLine(valInt.ToString("X2")); // 0C ~ always double-digit output

string HexFromID(int ID)
{
    return ID.ToString("X");
}

int IDFromHex(string HexID)
{
    return int.Parse(HexID, System.Globalization.NumberStyles.HexNumber);
}

Je remets vraiment en question la valeur de cela, cependant. Votre objectif déclaré est de réduire la valeur, ce qui sera le cas, mais ce n'est pas un objectif en soi. Vous voulez vraiment dire soit rendre plus facile à retenir ou plus facile à taper.

Si vous voulez dire plus facile à retenir, vous faites un pas en arrière. Nous savons que c'est toujours la même taille, juste encodé différemment. Mais vos utilisateurs ne sauront pas que les lettres sont limitées à «A-F», et donc l'ID occupera le même espace conceptuel pour eux que si la lettre «AZ» était autorisée. Donc, au lieu d'être comme mémoriser un numéro de téléphone, c'est plus comme mémoriser un GUID (de longueur équivalente).

Si vous voulez dire taper, au lieu de pouvoir utiliser le clavier, l'utilisateur doit maintenant utiliser la partie principale du clavier. Il sera probablement plus difficile à taper, car ce ne sera pas un mot que leurs doigts reconnaîtront.

Une bien meilleure option consiste à les laisser choisir un vrai nom d'utilisateur.

Vers hex:

string hex = intValue.ToString("X");

À int:

int intValue = int.Parse(hex, System.Globalization.NumberStyles.HexNumber)

J'ai créé ma propre solution pour convertir int en chaîne hexadécimale et retour avant de trouver cette réponse. Sans surprise, c'est beaucoup plus rapide que la solution .net car il y a moins de surcharge de code.

        /// <summary>
        /// Convert an integer to a string of hexidecimal numbers.
        /// </summary>
        /// <param name="n">The int to convert to Hex representation</param>
        /// <param name="len">number of digits in the hex string. Pads with leading zeros.</param>
        /// <returns></returns>
        private static String IntToHexString(int n, int len)
        {
            char[] ch = new char[len--];
            for (int i = len; i >= 0; i--)
            {
                ch[len - i] = ByteToHexChar((byte)((uint)(n >> 4 * i) & 15));
            }
            return new String(ch);
        }

        /// <summary>
        /// Convert a byte to a hexidecimal char
        /// </summary>
        /// <param name="b"></param>
        /// <returns></returns>
        private static char ByteToHexChar(byte b)
        {
            if (b < 0 || b > 15)
                throw new Exception("IntToHexChar: input out of range for Hex value");
            return b < 10 ? (char)(b + 48) : (char)(b + 55);
        }

        /// <summary>
        /// Convert a hexidecimal string to an base 10 integer
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        private static int HexStringToInt(String str)
        {
            int value = 0;
            for (int i = 0; i < str.Length; i++)
            {
                value += HexCharToInt(str[i]) << ((str.Length - 1 - i) * 4);
            }
            return value;
        }

        /// <summary>
        /// Convert a hex char to it an integer.
        /// </summary>
        /// <param name="ch"></param>
        /// <returns></returns>
        private static int HexCharToInt(char ch)
        {
            if (ch < 48 || (ch > 57 && ch < 65) || ch > 70)
                throw new Exception("HexCharToInt: input out of range for Hex value");
            return (ch < 58) ? ch - 48 : ch - 55;
        }

Code temporel:

static void Main(string[] args)
        {
            int num = 3500;
            long start = System.Diagnostics.Stopwatch.GetTimestamp();
            for (int i = 0; i < 2000000; i++)
                if (num != HexStringToInt(IntToHexString(num, 3)))
                    Console.WriteLine(num + " = " + HexStringToInt(IntToHexString(num, 3)));
            long end = System.Diagnostics.Stopwatch.GetTimestamp();
            Console.WriteLine(((double)end - (double)start)/(double)System.Diagnostics.Stopwatch.Frequency);

            for (int i = 0; i < 2000000; i++)
                if (num != Convert.ToInt32(num.ToString("X3"), 16))
                    Console.WriteLine(i);
            end = System.Diagnostics.Stopwatch.GetTimestamp();
            Console.WriteLine(((double)end - (double)start)/(double)System.Diagnostics.Stopwatch.Frequency);
            Console.ReadLine(); 
        }

Résultats:

Digits : MyCode : .Net
1 : 0.21 : 0.45
2 : 0.31 : 0.56
4 : 0.51 : 0.78
6 : 0.70 : 1.02
8 : 0.90 : 1.25

CADRE NET

Très bien expliqué et peu de lignes de programmation BON TRAVAIL

// Store integer 182
int intValue = 182;
// Convert integer 182 as a hex in a string variable
string hexValue = intValue.ToString("X");
// Convert the hex string back to the number
int intAgain = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber);

PASCAL >> C #

http://files.hddguru.com/download/Software/Seagate/St_mem.pas

Quelque chose de la vieille école très ancienne procédure de pascal converti en C #

    /// <summary>
    /// Conver number from Decadic to Hexadecimal
    /// </summary>
    /// <param name="w"></param>
    /// <returns></returns>
    public string MakeHex(int w)
    {
        try
        {
           char[] b =  {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
           char[] S = new char[7];

              S[0] = b[(w >> 24) & 15];
              S[1] = b[(w >> 20) & 15];
              S[2] = b[(w >> 16) & 15];
              S[3] = b[(w >> 12) & 15];
              S[4] = b[(w >> 8) & 15];
              S[5] = b[(w >> 4) & 15];
              S[6] = b[w & 15];

              string _MakeHex = new string(S, 0, S.Count());

              return _MakeHex;
        }
        catch (Exception ex)
        {

            throw;
        }
    }

Imprimer un entier en valeur hexadécimale avec un remplissage nul (si nécessaire):

int intValue = 1234;

Console.WriteLine("{0,0:D4} {0,0:X3}", intValue); 

https://docs.microsoft.com/en-us/dotnet/standard/base-types/how-to-pad-a-number-with-leading-zeros

int en hex:

int a = 72;

Console.WriteLine ("{0: X}", a);

hex à int:

int b = 0xB76;

Console.WriteLine (b);