Convertir entero a hexadecimal y viceversa

¿Cómo puedo convertir lo siguiente?

2934 (entero) a B76 (hexadecimal)

Déjame explicarte lo que estoy tratando de hacer. Tengo ID de usuario en mi base de datos que se almacenan como enteros. En lugar de que los usuarios hagan referencia a sus ID, quiero dejar que usen el valor hexadecimal. La razón principal es porque es más corta.

Entonces, no solo necesito ir de entero a hexadecimal, sino que también necesito ir de hexadecimal a entero.

¿Hay una manera fácil de hacer esto 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);

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

Utilizar:

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

Consulte Cómo convertir entre cadenas hexadecimales y tipos numéricos (Guía de programación de C #) para obtener más información y ejemplos.

Pruebe lo siguiente para convertirlo a hexadecimal

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

Y de regreso

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

Sin embargo, realmente cuestiono el valor de esto. Su objetivo declarado es hacer que el valor sea más corto, lo que será, pero ese 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 más fácil de recordar, entonces estás dando un paso atrás. Sabemos que sigue siendo del mismo tamaño, simplemente 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 ellos que si se permitiera la letra 'AZ'. Entonces, en lugar de ser como 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 de escribir, porque no será una palabra que sus dedos reconozcan.

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

Al maleficio:

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

Para int:

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

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.

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

Código de tiempo:

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

NET FRAMEWORK

Muy bien explicado y pocas líneas de programación BUEN TRABAJO

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

Algo de la vieja escuela muy antiguo procedimiento de pascal convertido a 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;
        }
    }

Imprimir entero en valor hexadecimal con relleno de cero (si es necesario):

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 a hex:

int a = 72;

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

hexadecimal a int:

int b = 0xB76;

Console.WriteLine (b);