C# convierte entero a hexadecimal y viceversa

Question

¿Cómo puedo convertir lo siguiente?

2934 (entero) a B76 (hex)

Voy a explicar lo que estoy tratando de hacer. Tengo ID de usuario en mi base de datos que se almacenan como enteros. En lugar de hacer que los usuarios hagan referencia a sus identificaciones, quiero permitirles usar el valor hexadecimal. La razón principal es porque es más corto.

Así que no solo necesito ir de entero a hexadecimal, sino que también necesito ir de hexágono a entero.

¿Hay alguna manera fácil de hacerlo en C#?

Answer 1

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

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

Answer 2

Uso:

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

Ver How to: Convert Between Hexadecimal Strings and Numeric Types (C# Programming Guide) para obtener más información y ejemplos.

Answer 3

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

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

Realmente cuestiono el valor de esto. El objetivo declarado es hacer que el valor sea más corto, lo que será, pero eso no es un objetivo en sí mismo. Realmente quieres decir que sea más fácil de recordar o más fácil de escribir.

Si quieres decir que es más fácil de recordar, estás dando un paso atrás. Sabemos que sigue siendo del mismo tamaño, solo codificado de manera diferente. Pero sus usuarios no sabrán que las letras están restringidas a 'A-F', por lo que la ID ocupará el mismo espacio conceptual para ellas como si la letra 'A-Z' estuviera permitida. Entonces, en lugar de memorizar un número de teléfono, es más como memorizar un GUID (de longitud equivalente).

Si quiere decir escribir, en lugar de poder usar el teclado, el usuario ahora debe usar la parte principal del teclado. Es probable que sea más difícil escribir, porque no será una palabra que reconozcan sus dedos.

Una opción mucho mejor es realmente dejarles elegir un nombre de usuario real.

Answer 4

intentar lo siguiente para convertirlo a hexadecimal

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

y viceversa

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

Answer 5

a Hex:

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

a int:

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

Answer 6

Una respuesta tardía a la moda, pero ¿ha considerado una especie de aplicación Integer acortando? Si el único objetivo es hacer que la identificación del usuario sea lo más breve posible, me interesaría saber si existe alguna otra razón aparente por la que requiera específicamente la conversión hexadecimal, a menos que la haya olvidado, por supuesto. ¿Es claro y conocido (si es necesario) que las identificaciones de usuario son en realidad una representación hexadecimal del valor real?

Answer 7

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

Answer 8

Creé mi propia solución para convertir int a cadena hexadecimal y viceversa antes de encontrar esta respuesta. No es sorprendente que sea considerablemente más rápido que la solución .NET ya que hay menos sobrecarga de código. código

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

Timing:

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

Resultados:

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 

Answer 9

int a hex:

int a = 72;

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

hexagonal para INT:

int b = 0xB76;

Console.WriteLine (b);