Converti un numero intero in esadecimale e viceversa

Come posso convertire quanto segue?

2934 (intero) in B76 (esadecimale)

Lasciami spiegare cosa sto cercando di fare. Ho ID utente nel mio database che sono memorizzati come numeri interi. Invece di fare in modo che gli utenti facciano riferimento ai loro ID, desidero che utilizzino il valore esadecimale. Il motivo principale è perché è più corto.

Quindi non solo devo passare da intero a esadecimale, ma devo anche passare da esadecimale a intero.

C'è un modo semplice per farlo in 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);

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

Uso:

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

Vedere Procedura: convertire tra stringhe esadecimali e tipi numerici (Guida per programmatori C #) per ulteriori informazioni ed esempi.

Prova quanto segue per convertirlo in esadecimale

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

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

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

Metto in dubbio il valore di questo, però. Il tuo obiettivo dichiarato è quello di ridurre il valore, cosa che farà, ma questo non è un obiettivo in sé. Intendi davvero o rendere più facile da ricordare o più facile da scrivere.

Se vuoi dire più facile da ricordare, allora stai facendo un passo indietro. Sappiamo che ha ancora le stesse dimensioni, codificato in modo diverso. Ma i tuoi utenti non sapranno che le lettere sono limitate a "A-F", quindi l'ID occuperà per loro lo stesso spazio concettuale come se fosse consentita la lettera "AZ". Quindi, invece di essere come memorizzare un numero di telefono, è più come memorizzare un GUID (di lunghezza equivalente).

Se intendi digitare, anziché essere in grado di utilizzare la tastiera, ora l'utente deve utilizzare la parte principale della tastiera. È probabile che sia più difficile da scrivere, perché non sarà una parola che le dita riconoscono.

Un'opzione molto migliore è quella di consentire loro di scegliere un vero nome utente.

All'esagono:

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

Per int:

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

Ho creato la mia soluzione per convertire int in stringa esadecimale e viceversa prima di trovare questa risposta. Non sorprende che sia considerevolmente più veloce della soluzione .net poiché c'è meno sovraccarico di codice.

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

Codice temporale:

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

risultati:

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

QUADRO NETTO

Molto ben spiegato e poche righe di programmazione BUON LAVORO

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

Qualcosa della vecchia scuola vecchia procedura di pascal convertita in 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;
        }
    }

Stampa numero intero in valore esadecimale con riempimento zero (se necessario):

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

int a = 72;

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

hex a int:

int b = 0xB76;

Console.WriteLine (b);