Como converter números entre hexadecimal e decimal em c #?

Como você converter entre números hexadecimais e números decimais em c #?

Para converter de decimal para hex …

string hexValue = decValue.ToString("X"); 

Para converter de hexadecimal para decimal …

 int decValue = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber); 

ou

 int decValue = Convert.ToInt32(hexValue, 16); 

Hex -> decimal:

 Convert.ToInt64(hexValue, 16); 

Decimal -> Hex

 string.format("{0:x}", decValue); 

Parece que você pode dizer

 Convert.ToInt64(value, 16) 

para obter o decimal de hexadecimal.

O inverso é:

 otherVar.ToString("X"); 

Se você deseja desempenho máximo ao fazer a conversão de hexadecimal para número decimal, é possível usar a abordagem com tabela pré-preenchida de valores hexadecimais.

Aqui está o código que ilustra essa ideia. Meus testes de desempenho mostraram que ele pode ser 20% -40% mais rápido do que o Convert.ToInt32 (…):

 class TableConvert { static sbyte[] unhex_table = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1 ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 }; public static int Convert(string hexNumber) { int decValue = unhex_table[(byte)hexNumber[0]]; for (int i = 1; i < hexNumber.Length; i++) { decValue *= 16; decValue += unhex_table[(byte)hexNumber[i]]; } return decValue; } } 
  static string chex(byte e) // Convert a byte to a string representing that byte in hexadecimal { string r = ""; string chars = "0123456789ABCDEF"; r += chars[e >> 4]; return r += chars[e &= 0x0F]; } // Easy enough... static byte CRAZY_BYTE(string t, int i) // Take a byte, if zero return zero, else throw exception (i=0 means false, i>0 means true) { if (i == 0) return 0; throw new Exception(t); } static byte hbyte(string e) // Take 2 characters: these are hex chars, convert it to a byte { // WARNING: This code will make small children cry. Rated R. e = e.ToUpper(); // string msg = "INVALID CHARS"; // The message that will be thrown if the hex str is invalid byte[] t = new byte[] // Gets the 2 characters and puts them in seperate entries in a byte array. { // This will throw an exception if (e.Length != 2). (byte)e[CRAZY_BYTE("INVALID LENGTH", e.Length ^ 0x02)], (byte)e[0x01] }; for (byte i = 0x00; i < 0x02; i++) // Convert those [ascii] characters to [hexadecimal] characters. Error out if either character is invalid. { t[i] -= (byte)((t[i] >= 0x30) ? 0x30 : CRAZY_BYTE(msg, 0x01)); // Check for 0-9 t[i] -= (byte)((!(t[i] < 0x0A)) ? (t[i] >= 0x11 ? 0x07 : CRAZY_BYTE(msg, 0x01)) : 0x00); // Check for AF } return t[0x01] |= t[0x00] <<= 0x04; // The moment of truth. } 

De Geekpedia :

 // Store integer 182 int decValue = 182; // Convert integer 182 as a hex in a string variable string hexValue = decValue.ToString("X"); // Convert the hex string back to the number int decAgain = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber); 

Esta não é a maneira mais fácil, mas este código fonte permite que você corrija qualquer tipo de número octal, isto é, 23.214, 23 e 0.512 e assim por diante. Espero que isso ajude você ..

  public string octal_to_decimal(string m_value) { double i, j, x = 0; Int64 main_value; int k = 0; bool pw = true, ch; int position_pt = m_value.IndexOf("."); if (position_pt == -1) { main_value = Convert.ToInt64(m_value); ch = false; } else { main_value = Convert.ToInt64(m_value.Remove(position_pt, m_value.Length - position_pt)); ch = true; } while (k <= 1) { do { i = main_value % 10; // Return Remainder i = i * Convert.ToDouble(Math.Pow(8, x)); // calculate power if (pw) x++; else x--; o_to_d = o_to_d + i; // Saving Required calculated value in main variable main_value = main_value / 10; // Dividing the main value } while (main_value >= 1); if (ch) { k++; main_value = Convert.ToInt64(Reversestring(m_value.Remove(0, position_pt + 1))); } else k = 2; pw = false; x = -1; } return (Convert.ToString(o_to_d)); } 

Hex para conversão decimal

 Convert.ToInt32(number, 16); 

Decimal para Conversão Hex

 int.Parse(number, System.Globalization.NumberStyles.HexNumber) 

Para mais detalhes, confira este artigo

 String stringrep = myintvar.ToString("X"); int num = int.Parse("FF", System.Globalization.NumberStyles.HexNumber); 

Tente usar BigNumber em c # – representa um inteiro assinado arbitrariamente grande.

Programa

 using System.Numerics; ... var bigNumber = BigInteger.Parse("837593454735734579347547357233757342857087879423437472347757234945743"); Console.WriteLine(bigNumber.ToString("X")); 

Saída

 4F30DC39A5B10A824134D5B18EEA3707AC854EE565414ED2E498DCFDE1A15DA5FEB6074AE248458435BD417F06F674EB29A2CFECF 

Possíveis exceções,

ArgumentNullException – value é nulo.

FormatException – o valor não está no formato correto.

Conclusão

Você pode converter string e armazenar um valor em BigNumber sem restrições sobre o tamanho do número, a menos que a string esteja vazia e não-analphabets

Aqui está minha function:

 using System; using System.Collections.Generic; class HexadecimalToDecimal { static Dictionary hexdecval = new Dictionary{ {'0', 0}, {'1', 1}, {'2', 2}, {'3', 3}, {'4', 4}, {'5', 5}, {'6', 6}, {'7', 7}, {'8', 8}, {'9', 9}, {'a', 10}, {'b', 11}, {'c', 12}, {'d', 13}, {'e', 14}, {'f', 15}, }; static decimal HexToDec(string hex) { decimal result = 0; hex = hex.ToLower(); for (int i = 0; i < hex.Length; i++) { char valAt = hex[hex.Length - 1 - i]; result += hexdecval[valAt] * (int)Math.Pow(16, i); } return result; } static void Main() { Console.WriteLine("Enter Hexadecimal value"); string hex = Console.ReadLine().Trim(); //string hex = "29A"; Console.WriteLine("Hex {0} is dec {1}", hex, HexToDec(hex)); Console.ReadKey(); } } 

Se é uma string hexadecimal muito grande além da capacidade do inteiro normal:

Para o .NET 3.5, podemos usar a class BigInteger do BouncyCastle:

 String hex = "68c7b05d0000000002f8"; // results in "494809724602834812404472" String decimal = new Org.BouncyCastle.Math.BigInteger(hex, 16).ToString(); 

O .NET 4.0 possui a class BigInteger .

Minha versão é que eu acho um pouco mais compreensível porque o meu conhecimento em C # não é tão alto. Estou usando este algoritmo: http://easyguyevo.hubpages.com/hub/Convert-Hex-to-Decimal (The Example 2)

 using System; using System.Collections.Generic; static class Tool { public static string DecToHex(int x) { string result = ""; while (x != 0) { if ((x % 16) < 10) result = x % 16 + result; else { string temp = ""; switch (x % 16) { case 10: temp = "A"; break; case 11: temp = "B"; break; case 12: temp = "C"; break; case 13: temp = "D"; break; case 14: temp = "E"; break; case 15: temp = "F"; break; } result = temp + result; } x /= 16; } return result; } public static int HexToDec(string x) { int result = 0; int count = x.Length - 1; for (int i = 0; i < x.Length; i++) { int temp = 0; switch (x[i]) { case 'A': temp = 10; break; case 'B': temp = 11; break; case 'C': temp = 12; break; case 'D': temp = 13; break; case 'E': temp = 14; break; case 'F': temp = 15; break; default: temp = -48 + (int)x[i]; break; // -48 because of ASCII } result += temp * (int)(Math.Pow(16, count)); count--; } return result; } } class Program { static void Main(string[] args) { Console.Write("Enter Decimal value: "); int decNum = int.Parse(Console.ReadLine()); Console.WriteLine("Dec {0} is hex {1}", decNum, Tool.DecToHex(decNum)); Console.Write("\nEnter Hexadecimal value: "); string hexNum = Console.ReadLine().ToUpper(); Console.WriteLine("Hex {0} is dec {1}", hexNum, Tool.HexToDec(hexNum)); Console.ReadKey(); } } 

Converter binário para Hex

 Convert.ToString(Convert.ToUInt32(binary1, 2), 16).ToUpper() 

Um método de extensão para converter uma matriz de bytes em uma representação hexadecimal. Isso preenche cada byte com zeros à esquerda.

  ///  /// Turns the byte array into its Hex representation. ///  public static string ToHex(this byte[] y) { StringBuilder sb = new StringBuilder(); foreach (byte b in y) { sb.Append(b.ToString("X").PadLeft(2, "0"[0])); } return sb.ToString(); }