Konwertuj liczbę całkowitą na szesnastkową iz powrotem

Jak mogę przekonwertować następujące elementy?

2934 (liczba całkowita) do B76 (hex)

Pozwól mi wyjaśnić, co próbuję zrobić. Mam w bazie danych identyfikatory użytkowników, które są przechowywane jako liczby całkowite. Zamiast pozwolić użytkownikom odwoływać się do ich identyfikatorów, chcę pozwolić im używać wartości szesnastkowej. Głównym powodem jest to, że jest krótszy.

Więc nie tylko muszę przechodzić od liczby całkowitej do liczby szesnastkowej, ale także muszę przechodzić od wartości szesnastkowej do liczby całkowitej.

Czy jest łatwy sposób to zrobić w 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);

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

Posługiwać się:

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

Zobacz : Konwersja między łańcuchami szesnastkowymi a typami numerycznymi (Podręcznik programowania w języku C #), aby uzyskać więcej informacji i przykładów.

Spróbuj wykonać poniższe czynności, aby przekonwertować go na hex

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

I jeszcze raz

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

Naprawdę jednak kwestionuję wartość tego. Twoim celem jest zmniejszenie wartości, co będzie, ale nie jest to celem samym w sobie. Naprawdę masz na myśli albo ułatwić zapamiętanie, albo łatwiejsze pisanie.

Jeśli masz na myśli łatwiej zapamiętać, to robisz krok do tyłu. Wiemy, że wciąż ma ten sam rozmiar, tylko zakodowany inaczej. Ale użytkownicy nie będą wiedzieli, że litery są ograniczone do „A-F”, a zatem identyfikator zajmie dla nich takie samo miejsce pojęciowe, jak gdyby litera „AZ” była dozwolona. Zamiast zapamiętywać numer telefonu, przypomina zapamiętywanie identyfikatora GUID (o równoważnej długości).

Jeśli masz na myśli pisanie, zamiast móc korzystać z klawiatury, użytkownik musi teraz korzystać z 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.

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 iz powrotem, zanim znalazłem tę odpowiedź. Nic dziwnego, że jest znacznie szybszy niż rozwiązanie .net, ponieważ narzut kodu jest mniejszy.

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

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

RAMY NETTO

Bardzo dobrze wyjaśnione i kilka linii programowania DOBRA PRACA

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

Coś ze starej szkoły bardzo stara procedura pascala przekonwertowana na 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;
        }
    }

Wydrukuj liczbę całkowitą w wartości szesnastkowej z dopełnieniem zerowym (w razie potrzeby):

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

int a = 72;

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

hex do int:

int b = 0xB76;

Console.WriteLine (b);