Konvertieren Sie eine Ganzzahl in eine Hexadezimalzahl und wieder zurück

Wie kann ich Folgendes konvertieren?

2934 (Ganzzahl) bis B76 (Hex)

Lassen Sie mich erklären, was ich versuche zu tun. Ich habe Benutzer-IDs in meiner Datenbank, die als Ganzzahlen gespeichert sind. Anstatt dass Benutzer auf ihre IDs verweisen, möchte ich sie den Hex-Wert verwenden lassen. Der Hauptgrund ist, weil es kürzer ist.

Ich muss also nicht nur von Integer zu Hex gehen, sondern auch von Hex zu Integer.

Gibt es eine einfache Möglichkeit, dies in C # zu tun?

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

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

Verwenden:

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

Siehe Gewusst wie: Konvertieren zwischen Hexadezimalzeichenfolgen und numerische Datentypen (C # Programming Guide) für weitere Informationen und Beispiele.

Versuchen Sie Folgendes, um es in hex umzuwandeln

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

Und wieder zurück

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

Ich bezweifle jedoch wirklich den Wert davon. Ihr erklärtes Ziel ist es, den Wert zu verkürzen, was es auch sein wird, aber das ist kein Ziel an sich. Du meinst wirklich, entweder das Erinnern erleichtern oder das Tippen erleichtern.

Wenn Sie leichter zu merken meinen, dann machen Sie einen Schritt zurück. Wir wissen, dass es immer noch dieselbe Größe hat, nur anders codiert. Ihre Benutzer wissen jedoch nicht, dass die Buchstaben auf "A-F" beschränkt sind, und daher belegt die ID für sie denselben konzeptionellen Platz, als ob der Buchstabe "AZ" zulässig wäre. Anstatt sich eine Telefonnummer zu merken, ist es eher so, als würde man sich eine GUID (gleicher Länge) merken.

Wenn Sie tippen möchten, muss der Benutzer jetzt den Hauptteil der Tastatur verwenden, anstatt die Tastatur verwenden zu können. Es ist wahrscheinlich schwieriger zu tippen, weil es kein Wort ist, das ihre Finger erkennen.

Eine viel bessere Option ist es, sie tatsächlich einen echten Benutzernamen auswählen zu lassen.

Zu verhexen:

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

Zu int:

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

Ich habe meine eigene Lösung für die Konvertierung von int in Hex-Zeichenfolgen und zurück erstellt, bevor ich diese Antwort gefunden habe. Es überrascht nicht, dass es erheblich schneller als die .net-Lösung ist, da der Code-Overhead geringer ist.

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

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

Ergebnisse:

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

NETZRAHMEN

Sehr gut erklärt und wenige Programmierzeilen GUTER JOB

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

Etwas aus der alten Schule sehr altes Verfahren von Pascal konvertiert 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;
        }
    }

Ganzzahl im Hex-Wert mit Null-Auffüllung drucken (falls erforderlich):

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

int a = 72;

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

hex zu int:

int b = 0xB76;

Console.WriteLine (b);