Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Convert.ToByte (String, Int32)

 

Publicado: octubre de 2016

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
Type: System.String

Cadena que contiene el número que se va a convertir.

fromBase
Type: System.Int32

Base del número de value, que debe ser 2, 8, 10 o 16.

Valor devuelto

Type: System.Byte

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

Exception Condition
ArgumentException

fromBase no es 2, 8, 10 o 16.

-o-

value, que representa un número sin signo que no sea de base 10, tiene un signo negativo como prefijo.

ArgumentOutOfRangeException

El valor de value es String.Empty.

FormatException

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

OverflowException

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

-o-

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

Si fromBase es 16, puede anteponer el número especificado por el value parámetro con "0 x" o "0 X".

Dado que la Byte tipo de datos admite valores sin signo, solo el ToByte(String, Int32) método supone que value se expresa mediante la representación binaria sin signo. En otras palabras, todos los ocho bits se utilizan para representar el valor numérico y un bit de inicio de sesión no está presente. Como resultado, es posible escribir código en el que un byte con signo de un valor que está fuera del intervalo de la Byte tipo de datos se convierte en un Byte valor sin el método de generación de una excepción. El ejemplo siguiente se convierte MinValue a su representación de cadena hexadecimal y, a continuación, las llamadas del ToByte(String, Int32) método. En lugar de producir una excepción, el método muestra el mensaje "0 x 80 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 desarrollador para 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 incorrectamente sin signo representación binaria cuando convierte una representación de cadena hexadecimal a un Byte valor. El ejemplo determina si un valor representa un con signo o un entero sin signo mientras que convierte ese valor en su representación de cadena. Cuando el ejemplo se convierte el valor de vuelta a un Byte valor, 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 los dos es el complemento en lugar de la representación binaria sin signo), el método produce 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.     

Como alternativa, en el ejemplo siguiente se intenta interpretar una matriz de cadenas como la representación de valores binarios, octales, decimales y hexadecimales.

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.

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: