C # convertir entier en hexadécimal et retour

Utilisation:

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

Voir Comment: Convertir Entre les Chaînes Hexadécimales et les Types Numériques (Guide de Programmation C# ) pour plus d'informations et d'exemples.

Essayez ce qui suit pour convertir en hexadécimal

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

Et retour à nouveau

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

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

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

Je doute vraiment de la valeur de ceci, cependant. Vous êtes objectif déclaré est de rendre la valeur plus courte, ce qui sera le cas, mais ce n'est pas un objectif en soi. Vous voulez vraiment dire soit le rendre plus facile à retenir ou plus facile à taper.

Si vous voulez dire plus facile à retenir, alors vous faites un pas en arrière. Nous savons que c'est toujours la même taille, juste codée 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 comme si la lettre "A-Z" é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 est susceptible d'être plus difficile à taper, parce que ce ne sera pas un mot que leurs doigts reconnaissent.

Une bien meilleure option est de les laisser choisir un vrai nom d'utilisateur.

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

Vers Hexadécimal:

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 de synchronisation:

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

Une réponse tardive à la mode, mais avez-vous envisagé une sorte de Integer raccourcissement de la mise en œuvre? Si le seul but est de rendre l'ID utilisateur aussi court que possible, je serais intéressé de savoir s'il y a une autre raison apparente pour laquelle vous avez spécifiquement besoin d'une conversion hexadécimale - sauf si je l'ai manqué bien sûr. Est-il clair et connu (si nécessaire) que les ID utilisateur sont en réalité une représentation hexadécimale de la valeur réelle?

Int à hex:

Int a = 72;

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

Hexadécimal à int:

Int b = 0xB76;

Console.WriteLine (b);