C# convert integer to hex and back again

Użycie:

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

Zobacz Jak: konwertować między Szesnastkowymi ciągami znaków i typami liczbowymi (C# Programming Guide) Więcej informacji i przykłady.

Spróbuj przekonwertować go na hex

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

I z powrotem

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śli masz na myśli pisanie, zamiast używać klawiatury, użytkownik musi teraz użyć głównej części klawiatury. Prawdopodobnie będzie trudniej pisać, ponieważ nie będzie to słowo, które rozpoznają ich palce.

O wiele lepszą opcją jest umożliwienie im wybrania prawdziwej nazwy użytkownika.

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

Do Hex:

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

Do int:

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

Stworzyłem własne rozwiązanie do konwersji int na ciąg Hex i z powrotem, zanim znalazłem tę odpowiedź. Nic dziwnego, że jest znacznie szybszy niż rozwiązanie. NET, ponieważ jest mniej narzutu kodu.

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

Kod czasu:

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

Wyniki:

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

Modnie spóźniona odpowiedź, ale czy rozważaliście jakiś rodzaj Integer skrócenia implementacji? Jeśli jedynym celem jest, aby identyfikator użytkownika jak najkrótszy, byłbym zainteresowany, aby wiedzieć, czy jest jakiś inny oczywisty powód, dlaczego konkretnie wymagają konwersji szesnastkowej-chyba, że przegapiłem to oczywiście. Czy jest jasne i znane (jeśli jest to wymagane), że identyfikatory użytkowników są w rzeczywistości szesnastkową reprezentacją rzeczywistej wartości?

Int to hex:

Int a = 72;

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

Hex do int:

Int b = 0xb76;

Konsola.WriteLine (b);