¿Cómo se convierte entre números hexadecimales y decimales en C#?¿Cómo convertir números entre hexadecimal y decimal en C#?
Respuesta
convertir de decimal a hexadecimal hacer ...
string hexValue = decValue.ToString("X");
convertir de hexadecimal a decimal o bien hacer ...
int decValue = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber);
o
int decValue = Convert.ToInt32(hexValue, 16);
String stringrep = myintvar.ToString("X");
int num = int.Parse("FF", System.Globalization.NumberStyles.HexNumber);
Parece que se puede decir
Convert.ToInt64(value, 16)
para obtener el decimal de hexdecimal.
El revés es:
otherVar.ToString("X");
consigo System.FormatException: El formato especificado 'X' es inválida –
// 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);
Hex -> decimales:
Convert.ToInt64(hexValue, 16);
decimal -> Hex
string.format("{0:x}", decValue);
1 Lo bueno de 'Convert.ToInt64 (hexValue, 16);' es que va a hacer la conversión si el '0x' el prefijo está allí o no, mientras que, algunas de las otras soluciones no lo harán. – Craig
@Craig hola, entonces tengo que hacer la conversión según el tamaño de valor hexadecimal o puedo aplicar ToInt64 para todo el valor hexadecimal, ¿habrá algún impacto? – user1219310
static string chex(byte e) // Convert a byte to a string representing that byte in hexadecimal
{
string r = "";
string chars = "ABCDEF";
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 A-F
}
return t[0x01] |= t[0x00] <<= 0x04; // The moment of truth.
}
Este no es la forma más fácil, pero este código fuente le permite corregir cualquier tipo de número octal, es decir, 23.214, 23 y 0.512 y así sucesivamente. Esperamos que esto ayudará a ..
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));
}
bienvenida en stackoverflow. ¿podría explicar un poco su código (mybe solo una frase corta). Gracias! –
Si es una cadena hexadecimal muy grande allá de la capacidad del entero de lo normal:
para .NET 3.5, podemos utilizar la clase BigInteger de BouncyCastle:
String hex = "68c7b05d0000000002f8";
// results in "494809724602834812404472"
String decimal = new Org.BouncyCastle.Math.BigInteger(hex, 16).ToString();
.NET 4.0 tiene la clase BigInteger.
Método de extensión para convertir una matriz de bytes en una representación hexadecimal. Esto rellena cada byte con ceros a la izquierda.
/// <summary>
/// Turns the byte array into its Hex representation.
/// </summary>
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();
}
Si desea obtener el máximo rendimiento cuando se hace la conversión de hexadecimal a decimal, puede utilizar el enfoque con mesa rellena previamente de los valores-hex-a decimal.
Aquí está el código que ilustra esa idea. Mi performance tests demuestran que puede ser de 20% -40% más rápido que 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;
}
}
Enfoque interesante –
Genius! Me pregunto si es posible hacer que el compilador de bytes automáticamente use este enfoque dentro de Convert.ToInt32? –
No veo ninguna razón por la cual no se puede hacer. Sin embargo, mantener una matriz consumirá memoria adicional. –
Aquí es mi función:
using System;
using System.Collections.Generic;
class HexadecimalToDecimal
{
static Dictionary<char, int> hexdecval = new Dictionary<char, int>{
{'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();
}
}
Este podría ser un buen candidato para un método de extensión ** 'Convert' ** para que uno pueda escribir:' int hexa = Convert.ToHexadecimal (11); '=) –
Mi versión es que creo que un poco más comprensible porque mi conocimiento C# no es tan alto. estoy usando este algoritmo: http://easyguyevo.hubpages.com/hub/Convert-Hex-to-Decimal (el ejemplo 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();
}
}
Convert binario a Hex
Convert.ToString(Convert.ToUInt32(binary1, 2), 16).ToUpper()
Hex a decimal Conversión
Convert.ToInt32(number, 16);
decimal a Hex Conversión
int.Parse(number, System.Globalization.NumberStyles.HexNumber)
Esto parece ser solo una repetición de [esta respuesta ] (https://stackoverflow.com/a/74223). – Pang
- 1. Convertir decimal a hexadecimal con Erlang?
- 2. Cómo convertir hexadecimal a decimal en una declaración de sustitución?
- 3. ¿Cómo puedo convertir un número decimal a hexadecimal en VIM?
- 4. ¿Cómo se convierten números entre diferentes bases en JavaScript?
- 5. ¿Convertir entero/decimal a hexadecimal en un Arduino?
- 6. ¿Cómo puedo convertir entre notación científica y decimal en Perl?
- 7. hexadecimal a 64 decimal firmado
- 8. Diferencia entre decimal y decimal
- 9. ¿Cómo convertir manualmente el valor decimal a cadena hexadecimal en C?
- 10. C# Convertir Char a Byte (representación hexadecimal)
- 11. hexadecimal la conversión a decimal
- 12. convierten eficientemente entre Hex, binario, y decimal en C/C++
- 13. ¿Cómo convierto hexadecimal a decimal en Python?
- 14. Python convierte decimal a hexadecimal
- 15. Convertir decimal <-> hex
- 16. ¿Cómo se convierte hexadecimal a decimal usando VB.NET?
- 17. De decimal a hexadecimal en python
- 18. Objetivo-C Decimal a Base 16 Conversión hexadecimal
- 19. Conversiones entre decimal y base 36
- 20. cómo analizar hexadecimal o decimal int en Python
- 21. C# Convertir objeto a Decimal
- 22. ¿Cómo puedo convertir el decimal? a decimal
- 23. Imprimir variables en formato hexadecimal o decimal
- 24. cómo convertir hexadecimal a RGB
- 25. Convertir cadena hexadecimal a larga
- 26. Conversión de hexadecimal a decimal en el ceceo común
- 27. Oracle: ¿Cómo convierto hexadecimal a decimal en Oracle SQL?
- 28. Diferencia entre DECIMAL y NUMERIC
- 29. ¿Cómo puedo convertir números hexadecimales a binarios en C++?
- 30. Convertir hexadecimal a doble
Me gustaría entender cómo esta línea decValue.ToString ("X") lo convierte en hexadecimal. – gizgok
La variable decValue es de tipo Int32. Int32 tiene una sobrecarga de ToString() que puede aceptar una de varias cadenas de formato que dictan cómo se representará el valor como una cadena. La cadena de formato "X" significa hexadecimal, por lo que 255.ToString ("X") devolverá la cadena hexadecimal "FF". Para obtener más información, consulte http://msdn.microsoft.com/en-us/library/dwhawy9k.aspx –
Convert.ToInt32 tiene un mejor rendimiento que int.Parse (...) –