Convertir entier en hexadécimal et de retour à nouveau

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

Essayez ce qui suit pour convertir en hexadécimal

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

Et de retour à nouveau

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

J'ai vraiment en question la valeur de cela, cependant. Vous êtes à l'objectif déclaré est de faire de la valeur plus courte, qui elle, mais ce n'est pas un but en soi. - Vous vraiment dire soit de le rendre plus facile à mémoriser ou plus facile à taper.

Si tu veux plus facile à mémoriser, puis vous prenez un pas en arrière. Nous savons que c'est toujours la même taille, il suffit de encodés différemment. Mais vos utilisateurs ne savent pas que les lettres sont limitées à "A-F", et donc l'ID d'occuper le même espace conceptuel pour eux, comme si la lettre 'A-Z' ont été autorisés. Donc, au lieu d'être à mémoriser un numéro de téléphone, c'est plus comme la mémorisation d'un GUID (de longueur équivalente).

Si tu veux taper, au lieu d'être en mesure d'utiliser le clavier, l'utilisateur doit utiliser la partie principale du clavier. Il est susceptible d'être plus difficiles à saisir, car il ne sera pas un mot de leurs doigts reconnaître.

Une bien meilleure option est de les laisser choisir un nom d'utilisateur réel.

J'ai créé ma propre solution pour la conversion de int en chaîne Hexadécimale et revenir avant que j'ai trouvé cette réponse. Il n'est pas surprenant, c'est beaucoup plus rapide que la .net une solution, car il y a moins de code frais généraux.

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

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

NET FRAMEWORK

Très bien expliqué et quelques lignes de programmation
BON TRAVAIL

//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 la vieille école très ancienne procédure 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;
}
}

Impression entier en hexadécimal valeur zéro-padding (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