C # convertit un entier en hex et retour
Comment puis-je convertir ce qui suit?
2934 (entier) à B76 (hex)
Laissez-moi vous expliquer ce que j'essaie de faire. J'ai des identifiants utilisateur dans ma base de données qui sont stockés sous forme d'entiers. Plutôt que d'avoir des utilisateurs référençant leurs identifiants, je veux les laisser utiliser la valeur hexadécimale. La raison principale est parce que c'est plus court.
Donc, non seulement il faut que je passe d'un entier à l'hex, mais il faut aussi que je passe d'un hex à un entier.
Existe-t-il un moyen simple de faire cela 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
Utilisation:
int myInt = 2934;
string myHex = myInt.ToString("X"); // Gives you hexadecimal
int myNewInt = Convert.ToInt32(myHex, 16); // Back to int again.
Voir Procédure: convertir entre des chaînes hexadécimales et des types numériques (Guide de programmation C #) pour plus d'informations et des exemples.
Essayez ce qui suit pour le convertir en hexadécimal
public static string ToHex(this int value) {
return String.Format("0x{0:X}", value);
}
Et retour
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);
}
string HexFromID(int ID)
{
return ID.ToString("X");
}
int IDFromHex(string HexID)
{
return int.Parse(HexID, System.Globalization.NumberStyles.HexNumber);
}
Je remets vraiment en question la valeur de ceci, cependant. Votre objectif déclaré est de réduire la valeur, ce qui sera le cas, mais ce n'est pas un objectif en soi. Vous voulez vraiment dire que ce soit plus facile à retenir ou plus facile à taper.
Si vous voulez dire plus facile à retenir, alors vous faites un pas en arrière. Nous savons que c'est toujours la même taille, mais encodé différemment. Mais vos utilisateurs ne sauront pas que les lettres sont limitées à "A-F", de sorte que l'ID occupera le même espace conceptuel que si la lettre "A-Z" était autorisée. Ainsi, au lieu d'être comme de mémoriser un numéro de téléphone, cela revient à mémoriser un GUID (de longueur équivalente).
Si vous voulez dire taper, au lieu de pouvoir utiliser le clavier, l'utilisateur doit maintenant utiliser la partie principale du clavier. Il sera probablement plus difficile de taper, car ce ne sera pas un mot que leurs doigts reconnaîtront.
Une meilleure option consiste à les laisser choisir un nom d'utilisateur réel.
int valInt = 12;
Console.WriteLine(valInt.ToString("X")); // C ~ possibly single-digit output
Console.WriteLine(valInt.ToString("X2")); // 0C ~ always double-digit output
Pour Hex:
string hex = intValue.ToString("X");
Pour int:
int intValue = int.Parse(hex, System.Globalization.NumberStyles.HexNumber)
J'ai créé ma propre solution pour convertir int en chaîne hexadécimale avant de trouver cette réponse. Sans surprise, elle est considérablement plus rapide que la solution .net, car elle génère moins de temps système.
/// <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;
}
Code de chronométrage:
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();
}
Résultats:
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
Une réponse tardive à la mode, mais avez-vous envisagé une sorte d'implémentation de Integer raccourcissant? Si le seul objectif est de rendre l'ID utilisateur aussi court que possible, il serait intéressant de savoir s'il existe une autre raison apparente pour laquelle vous avez spécifiquement besoin d'une conversion hexadécimale - à moins que je ne l'aie oublié bien sûr. Est-il clair et connu (le cas échéant) que les ID utilisateur sont en réalité une représentation hexadécimale de la valeur réelle?
NET FRAMEWORK
Très bien expliqué et quelques lignes de programmation GOOD 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
Quelque chose de l'ancienne procédure très ancienne de Pascal converti en 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;
}
}
Je ne peux pas écrire de commentaires, mais certaines personnes ont tort de dire que intValue.ToString("X2") va "spécifier le nombre de chiffres" ou produire "toujours une sortie à deux chiffres". Ce n'est pas vrai, le 2 spécifie minimum nombre de chiffres. Donc, si vous avez une couleur ARGB noire opaque, la méthode produira FF000000 not 00
Imprimer le nombre entier en valeur hexadécimale avec un remplissage à zéro (si nécessaire):
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