¿Le resultó útil esta página?
Sus comentarios sobre este contenido son muy importantes. Háganos saber su opinión.
¿Tiene comentarios adicionales?
Caracteres restantes: 1500
Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Convert.ToByte (Método) (String, Int32)

Convierte la representación de cadena de un número en una base especificada en un entero de 8 bits sin signo equivalente.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

public static byte ToByte(
	string value,
	int fromBase
)

Parámetros

value
Tipo: System.String
Cadena que contiene el número que se va a convertir.
fromBase
Tipo: System.Int32
Base del número de value, que debe ser 2, 8, 10 ó 16.

Valor devuelto

Tipo: System.Byte
Un entero de 8 bits sin signo equivalente al número de value, o 0 (cero) si value es null.

ExcepciónCondición
ArgumentException

fromBase no es 2, 8, 10 ó 16.

O bien

value, que representa un número sin signo que no está en base 10, con un signo negativo como prefijo.

ArgumentOutOfRangeException

value es String.Empty.

FormatException

value contiene un carácter que no es un dígito válido en la base especificada por fromBase. Si el primer carácter de value no es válido, el mensaje de excepción indica que no hay dígitos para convertir; de lo contrario, el mensaje indica que value contiene caracteres finales no válidos.

OverflowException

value, que representa un número sin signo en base 10, con un signo negativo como prefijo.

O bien

value representa un número menor que Byte.MinValue o mayor que Byte.MaxValue.

Si fromBase es 16, es posible colocar delante del número especificado por el parámetro value el prefijo "0x" ó "0X".

Dado que el tipo de datos Byte sólo admite valores sin signo, el método ToByte(String, Int32) asume que value se expresa mediante la representación binaria sin signo. En otras palabras, los ocho bits se utilizan para representar el valor numérico y no hay ningún bit de signo. Como resultado, es posible escribir código en el que un valor de byte con signo que esté fuera del intervalo del tipo de datos Byte se convierta en un valor Byte sin que el método inicie ninguna excepción. El ejemplo siguiente convierte MinValue en su representación de cadena hexadecimal y, a continuación, llama al método ToByte(String, Int32). En lugar de iniciar una excepción, el método muestra el mensaje "0x80 se convierte en 128".


// Create a hexadecimal value out of range of the Byte type.
string value = SByte.MinValue.ToString("X");
// Convert it back to a number.
try
{
   byte number = Convert.ToByte(value, 16);
   Console.WriteLine("0x{0} converts to {1}.", value, number);
}   
catch (OverflowException)
{
   Console.WriteLine("Unable to convert '0x{0}' to a byte.", value);
}   


Cuando se realizan operaciones binarias o conversiones numéricas, siempre es responsabilidad del programador comprobar que un método u operador utiliza la representación numérica adecuada para interpretar un valor determinado. En el ejemplo siguiente se muestra una técnica para asegurarse de que el método no utiliza la representación binaria sin signo de forma inadecuada al convertir una representación de cadena hexadecimal en un valor Byte. El ejemplo determina si un valor representa un entero con o sin signo mientras que convierte ese valor en su representación de cadena. Al volver a convertir el valor en un valor Byte, el ejemplo comprueba si el valor original era un entero con signo. Si es así, y su bit de orden superior está establecido (lo que indica que el valor es negativo y que utiliza la representación complementaria de dos en lugar de la representación binaria sin signo), el método inicia una excepción.


// Create a negative hexadecimal value out of range of the Byte type.
sbyte sourceNumber = SByte.MinValue;
bool isSigned = Math.Sign((sbyte)sourceNumber.GetType().GetField("MinValue").GetValue(null)) == -1;
string value = sourceNumber.ToString("X");
byte targetNumber;
try
{
   targetNumber = Convert.ToByte(value, 16);
   if (isSigned && ((targetNumber & 0x80) != 0))
      throw new OverflowException();
   else 
      Console.WriteLine("0x{0} converts to {1}.", value, targetNumber);
}
catch (OverflowException)
{
   Console.WriteLine("Unable to convert '0x{0}' to an unsigned byte.", value);
} 
// Displays the following to the console:
//    Unable to convert '0x80' to an unsigned byte.     


El siguiente ejemplo intenta interpretar una matriz de cadenas como la representación de valores binario, octal, decimal y hexadecimal.


using System;

public class Example
{
   public static void Main()
   {
      int[] bases = { 2, 8, 10, 16 };
      string[] values = { "-1", "1", "08", "0F", "11" , "12", "30",                
                          "101", "255", "FF", "10000000", "80" };
      byte number;
      foreach (int numBase in bases)
      {
         Console.WriteLine("Base {0}:", numBase);
         foreach (string value in values)
         {
            try {
               number = Convert.ToByte(value, numBase);
               Console.WriteLine("   Converted '{0}' to {1}.", value, number);
            }   
            catch (FormatException) {
               Console.WriteLine("   '{0}' is not in the correct format for a base {1} byte value.", 
                                 value, numBase);
            }                     
            catch (OverflowException) {
               Console.WriteLine("   '{0}' is outside the range of the Byte type.", value);
            }   
            catch (ArgumentException) {
               Console.WriteLine("   '{0}' is invalid in base {1}.", value, numBase);
            }
         }                                 
      } 
   }
}
// The example displays the following output:
//    Base 2:
//       '-1' is invalid in base 2.
//       Converted '1' to 1.
//       '08' is not in the correct format for a base 2 conversion.
//       '0F' is not in the correct format for a base 2 conversion.
//       Converted '11' to 3.
//       '12' is not in the correct format for a base 2 conversion.
//       '30' is not in the correct format for a base 2 conversion.
//       Converted '101' to 5.
//       '255' is not in the correct format for a base 2 conversion.
//       'FF' is not in the correct format for a base 2 conversion.
//       Converted '10000000' to 128.
//       '80' is not in the correct format for a base 2 conversion.
//    Base 8:
//       '-1' is invalid in base 8.
//       Converted '1' to 1.
//       '08' is not in the correct format for a base 8 conversion.
//       '0F' is not in the correct format for a base 8 conversion.
//       Converted '11' to 9.
//       Converted '12' to 10.
//       Converted '30' to 24.
//       Converted '101' to 65.
//       Converted '255' to 173.
//       'FF' is not in the correct format for a base 8 conversion.
//       '10000000' is outside the range of the Byte type.
//       '80' is not in the correct format for a base 8 conversion.
//    Base 10:
//       '-1' is outside the range of the Byte type.
//       Converted '1' to 1.
//       Converted '08' to 8.
//       '0F' is not in the correct format for a base 10 conversion.
//       Converted '11' to 11.
//       Converted '12' to 12.
//       Converted '30' to 30.
//       Converted '101' to 101.
//       Converted '255' to 255.
//       'FF' is not in the correct format for a base 10 conversion.
//       '10000000' is outside the range of the Byte type.
//       Converted '80' to 80.
//    Base 16:
//       '-1' is invalid in base 16.
//       Converted '1' to 1.
//       Converted '08' to 8.
//       Converted '0F' to 15.
//       Converted '11' to 17.
//       Converted '12' to 18.
//       Converted '30' to 48.
//       '101' is outside the range of the Byte type.
//       '255' is outside the range of the Byte type.
//       Converted 'FF' to 255.
//       '10000000' is outside the range of the Byte type.
//       Converted '80' to 128.


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft