Convert.ToByte Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Convierte un valor especificado en un entero de 8 bits sin signo.

Sobrecargas

ToByte(String)	Convierte la representación de cadena especificada de un número en un entero de 8 bits sin signo equivalente.
ToByte(UInt16)	Convierte el valor del entero de 16 bits sin signo especificado en un entero de 8 bits sin signo equivalente.
ToByte(UInt32)	Convierte el valor del entero de 32 bits sin signo especificado en un entero de 8 bits sin signo equivalente.
ToByte(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.
ToByte(Object, IFormatProvider)	Convierte el valor del objeto especificado en un entero de 8 bits sin signo, usando la información de formato específica de la referencia cultural indicada.
ToByte(String, IFormatProvider)	Convierte la representación de cadena especificada de un número en un entero de 8 bits sin signo equivalente, usando la información de formato específica de la referencia cultural indicada.
ToByte(Single)	Convierte el valor del número de punto flotante de precisión sencilla especificado en un entero de 8 bits sin signo equivalente.
ToByte(UInt64)	Convierte el valor del entero de 64 bits sin signo especificado en un entero de 8 bits sin signo equivalente.
ToByte(SByte)	Convierte el valor del entero de 8 bits con signo especificado en un entero de 8 bits sin signo equivalente.
ToByte(DateTime)	Cuando se llama a este método, siempre se produce InvalidCastException.
ToByte(Int64)	Convierte el valor del entero de 64 bits con signo especificado en un entero de 8 bits sin signo equivalente.
ToByte(Byte)	Devuelve el entero de 8 bits sin signo especificado; no se efectúa una conversión real.
ToByte(Char)	Convierte el valor del carácter Unicode especificado en un entero de 8 bits sin signo equivalente.
ToByte(Decimal)	Convierte el valor del número decimal especificado en un entero de 8 bits sin signo equivalente.
ToByte(Boolean)	Convierte el valor booleano especificado en un entero de 8 bits sin signo equivalente.
ToByte(Int16)	Convierte el valor del entero de 16 bits con signo especificado en un entero de 8 bits sin signo equivalente.
ToByte(Int32)	Convierte el valor del entero de 32 bits con signo especificado en un entero de 8 bits sin signo equivalente.
ToByte(Double)	Convierte el valor del número de punto flotante de precisión doble especificado en un entero de 8 bits sin signo equivalente.
ToByte(Object)	Convierte el valor del objeto especificado en un entero de 8 bits sin signo.

ToByte(String)

Source:

Convert.cs

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

C#

public static byte ToByte (string? value);

Parámetros

value

String

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

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value, o cero si value es null.

Excepciones

FormatException

value no está formado por un signo opcional seguido de una secuencia de dígitos (de 0 a 9).

OverflowException

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

Ejemplos

En el ejemplo siguiente se define una matriz de cadenas y se intenta convertir cada cadena en .Byte Tenga en cuenta que mientras una null cadena analiza en cero, String.Empty produce un FormatException. Tenga en cuenta también que, aunque los espacios iniciales y finales analizan correctamente, los símbolos de formato, como símbolos de moneda, separadores de grupo o separadores decimales, no.

C#

using System;

public class Example
{
   public static void Main()
   {
      String[] values = { null, "", "0xC9", "C9", "101", "16.3",
                          "$12", "$12.01", "-4", "1,032", "255",
                          "   16  " };
      foreach (var value in values) {
         try {
            byte number = Convert.ToByte(value);
            Console.WriteLine("'{0}' --> {1}",
                              value == null ? "<null>" : value, number);
         }
         catch (FormatException) {
            Console.WriteLine("Bad Format: '{0}'",
                              value == null ? "<null>" : value);
         }
         catch (OverflowException) {
            Console.WriteLine("OverflowException: '{0}'", value);
         }
      }
   }
}
// The example displays the following output:
//     '<null>' --> 0
//     Bad Format: ''
//     Bad Format: '0xC9'
//     Bad Format: 'C9'
//     '101' --> 101
//     Bad Format: '16.3'
//     Bad Format: '$12'
//     Bad Format: '$12.01'
//     OverflowException: '-4'
//     Bad Format: '1,032'
//     '255' --> 255
//     '   16  ' --> 16

Comentarios

El uso del ToByte(String) método equivale a pasar value al Byte.Parse(String) método . value se interpreta mediante las convenciones de formato de la referencia cultural actual.

Si prefiere no controlar una excepción si se produce un error en la conversión, puede llamar al Byte.TryParse método en su lugar. Devuelve un Boolean valor que indica si la conversión se realizó correctamente o no.

Consulte también

• Parse(String)

ToByte(UInt16)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

Convierte el valor del entero de 16 bits sin signo especificado en un entero de 8 bits sin signo equivalente.

C#

[System.CLSCompliant(false)]
public static byte ToByte (ushort value);

Parámetros

value

UInt16

Entero de 16 bits sin signo que se va a convertir.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es mayor que Byte.MaxValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de enteros Byte de 16 bits sin signo en valores.

C#

ushort[] numbers = { UInt16.MinValue, 121, 340, UInt16.MaxValue };
byte result;
foreach (ushort number in numbers)
{
   try {
      result = Convert.ToByte(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//       Converted the UInt16 value 0 to the Byte value 0.
//       Converted the UInt16 value 121 to the Byte value 121.
//       The UInt16 value 340 is outside the range of the Byte type.
//       The UInt16 value 65535 is outside the range of the Byte type.

ToByte(UInt32)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

Convierte el valor del entero de 32 bits sin signo especificado en un entero de 8 bits sin signo equivalente.

C#

[System.CLSCompliant(false)]
public static byte ToByte (uint value);

Parámetros

value

UInt32

Entero de 32 bits sin signo que se va a convertir.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es mayor que Byte.MaxValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de enteros Byte sin signo en valores.

C#

uint[] numbers = { UInt32.MinValue, 121, 340, UInt32.MaxValue };
byte result;
foreach (uint number in numbers)
{
   try {
      result = Convert.ToByte(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//       Converted the UInt32 value 0 to the Byte value 0.
//       Converted the UInt32 value 121 to the Byte value 121.
//       The UInt32 value 340 is outside the range of the Byte type.
//       The UInt32 value 4294967295 is outside the range of the Byte type.

ToByte(String, Int32)

Source:

Convert.cs

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

C#

public static byte ToByte (string? value, int fromBase);

Parámetros

value

String

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

fromBase

Int32

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

Devoluciones

Byte

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

Excepciones

ArgumentException

fromBase no es 2, 8, 10 o 16.

O bien

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

ArgumentOutOfRangeException

value es 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 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.

Ejemplos

En el ejemplo siguiente se intenta interpretar alternativamente una matriz de cadenas como representación de valores binarios, octales, decimales y hexadecimales.

C#

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.

Comentarios

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

Dado que el Byte tipo de datos solo admite valores sin firmar, el ToByte(String, Int32) método supone que value se expresa mediante una representación binaria sin signo. En otras palabras, los ocho bits se usan para representar el valor numérico y un bit de signo no está presente. Como resultado, es posible escribir código en el que un valor de byte firmado que está fuera del intervalo del tipo de Byte datos se convierte en un Byte valor sin que el método produzca una excepción. En el ejemplo siguiente se convierte MinValue en su representación de cadena hexadecimal y, a continuación, se llama al ToByte(String, Int32) método . En lugar de iniciar una excepción, el método muestra el mensaje "0x80 convierte en 128".

C#

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

Al realizar operaciones binarias o conversiones numéricas, siempre es responsabilidad del desarrollador comprobar que un método o operador usa 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 usa de forma inapropiada una representación binaria sin firmar cuando convierte una representación de cadena hexadecimal en un Byte valor. En el ejemplo se determina si un valor representa un entero con signo o sin signo mientras convierte ese valor en su representación de cadena. Cuando el ejemplo convierte el valor en un Byte valor, comprueba si el valor original era un entero con signo. Si es así, y si se establece su bit de orden alto (lo que indica que el valor es negativo y que usa el complemento de dos en lugar de una representación binaria sin signo), el método produce una excepción.

C#

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

ToByte(Object, IFormatProvider)

Source:

Convert.cs

Convierte el valor del objeto especificado en un entero de 8 bits sin signo, usando la información de formato específica de la referencia cultural indicada.

C#

public static byte ToByte (object? value, IFormatProvider? provider);

Parámetros

value

Object

Objeto que implementa la interfaz IConvertible.

provider

IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value, o cero si value es null.

Excepciones

FormatException

value no está en el formato de la propiedad de un valor Byte.

InvalidCastException

value no implementa IConvertible.

O bien

No se admite la conversión de value al tipo Byte.

OverflowException

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

Ejemplos

En el ejemplo siguiente se define una clase ByteString que implementa la interfaz IConvertible . La clase almacena la representación de cadena de un valor de byte junto con un campo de signo, de modo que pueda representar valores de bytes firmados y sin signo.

C#

using System;
using System.Globalization;

public enum SignBit { Negative=-1, Zero=0, Positive=1 };

public struct ByteString : IConvertible
{
   private SignBit signBit;
   private string byteString;

   public SignBit Sign
   {
      set { signBit = value; }
      get { return signBit; }
   }

   public string Value
   {
      set {
         if (value.Trim().Length > 2)
            throw new ArgumentException("The string representation of a byte cannot have more than two characters.");
         else
            byteString = value;
      }
      get { return byteString; }
   }

   // IConvertible implementations.
   public TypeCode GetTypeCode() {
      return TypeCode.Object;
   }

   public bool ToBoolean(IFormatProvider provider)
   {
      if (signBit == SignBit.Zero)
         return false;
      else
         return true;
   }

   public byte ToByte(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         throw new OverflowException(String.Format("{0} is out of range of the Byte type.", Convert.ToSByte(byteString, 16)));
      else
         return Byte.Parse(byteString, NumberStyles.HexNumber);
   }

   public char ToChar(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative) {
         throw new OverflowException(String.Format("{0} is out of range of the Char type.", Convert.ToSByte(byteString, 16)));
      }
      else {
         byte byteValue = Byte.Parse(this.byteString, NumberStyles.HexNumber);
         return Convert.ToChar(byteValue);
      }
   }

   public DateTime ToDateTime(IFormatProvider provider)
   {
      throw new InvalidCastException("ByteString to DateTime conversion is not supported.");
   }

   public decimal ToDecimal(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
      {
         sbyte byteValue = SByte.Parse(byteString, NumberStyles.HexNumber);
         return Convert.ToDecimal(byteValue);
      }
      else
      {
         byte byteValue = Byte.Parse(byteString, NumberStyles.HexNumber);
         return Convert.ToDecimal(byteValue);
      }
   }

   public double ToDouble(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Convert.ToDouble(SByte.Parse(byteString, NumberStyles.HexNumber));
      else
         return Convert.ToDouble(Byte.Parse(byteString, NumberStyles.HexNumber));
   }

   public short ToInt16(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Convert.ToInt16(SByte.Parse(byteString, NumberStyles.HexNumber));
      else
         return Convert.ToInt16(Byte.Parse(byteString, NumberStyles.HexNumber));
   }

   public int ToInt32(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Convert.ToInt32(SByte.Parse(byteString, NumberStyles.HexNumber));
      else
         return Convert.ToInt32(Byte.Parse(byteString, NumberStyles.HexNumber));
   }

   public long ToInt64(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Convert.ToInt64(SByte.Parse(byteString, NumberStyles.HexNumber));
      else
         return Convert.ToInt64(Byte.Parse(byteString, NumberStyles.HexNumber));
   }

   public sbyte ToSByte(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         try {
            return Convert.ToSByte(Byte.Parse(byteString, NumberStyles.HexNumber));
         }
         catch (OverflowException e) {
            throw new OverflowException(String.Format("{0} is outside the range of the SByte type.",
                                                   Byte.Parse(byteString, NumberStyles.HexNumber)), e);
         }
      else
         return SByte.Parse(byteString, NumberStyles.HexNumber);
   }

   public float ToSingle(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         return Convert.ToSingle(SByte.Parse(byteString, NumberStyles.HexNumber));
      else
         return Convert.ToSingle(Byte.Parse(byteString, NumberStyles.HexNumber));
   }

   public string ToString(IFormatProvider provider)
   {
      return "0x" + this.byteString;
   }

   public object ToType(Type conversionType, IFormatProvider provider)
   {
      switch (Type.GetTypeCode(conversionType))
      {
         case TypeCode.Boolean:
            return this.ToBoolean(null);
         case TypeCode.Byte:
            return this.ToByte(null);
         case TypeCode.Char:
            return this.ToChar(null);
         case TypeCode.DateTime:
            return this.ToDateTime(null);
         case TypeCode.Decimal:
            return this.ToDecimal(null);
         case TypeCode.Double:
            return this.ToDouble(null);
         case TypeCode.Int16:
            return this.ToInt16(null);
         case TypeCode.Int32:
            return this.ToInt32(null);
         case TypeCode.Int64:
            return this.ToInt64(null);
         case TypeCode.Object:
            if (typeof(ByteString).Equals(conversionType))
               return this;
            else
               throw new InvalidCastException(String.Format("Conversion to a {0} is not supported.", conversionType.Name));
         case TypeCode.SByte:
            return this.ToSByte(null);
         case TypeCode.Single:
            return this.ToSingle(null);
         case TypeCode.String:
            return this.ToString(null);
         case TypeCode.UInt16:
            return this.ToUInt16(null);
         case TypeCode.UInt32:
            return this.ToUInt32(null);
         case TypeCode.UInt64:
            return this.ToUInt64(null);
         default:
            throw new InvalidCastException(String.Format("Conversion to {0} is not supported.", conversionType.Name));
      }
   }

   public UInt16 ToUInt16(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         throw new OverflowException(String.Format("{0} is outside the range of the UInt16 type.",
                                                   SByte.Parse(byteString, NumberStyles.HexNumber)));
      else
         return Convert.ToUInt16(Byte.Parse(byteString, NumberStyles.HexNumber));
   }

   public UInt32 ToUInt32(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         throw new OverflowException(String.Format("{0} is outside the range of the UInt32 type.",
                                                   SByte.Parse(byteString, NumberStyles.HexNumber)));
      else
         return Convert.ToUInt32(Byte.Parse(byteString, NumberStyles.HexNumber));
   }

   public UInt64 ToUInt64(IFormatProvider provider)
   {
      if (signBit == SignBit.Negative)
         throw new OverflowException(String.Format("{0} is outside the range of the UInt64 type.",
                                                   SByte.Parse(byteString, NumberStyles.HexNumber)));
      else
         return Convert.ToUInt64(Byte.Parse(byteString, NumberStyles.HexNumber));
   }
}

En el ejemplo siguiente se crean instancias de varios ByteString objetos y se llama al ToByte(Object, IFormatProvider) método para convertirlos en valores de bytes. Ilustra que el ToByte(Object, IFormatProvider) método encapsula una llamada al IConvertible.ToByte método del objeto que se va a convertir.

C#

public class Class1
{
   public static void Main()
   {
      byte positiveByte = 216;
      sbyte negativeByte = -101;

      ByteString positiveString = new ByteString();
      positiveString.Sign = (SignBit) Math.Sign(positiveByte);
      positiveString.Value = positiveByte.ToString("X2");

      ByteString negativeString = new ByteString();
      negativeString.Sign = (SignBit) Math.Sign(negativeByte);
      negativeString.Value = negativeByte.ToString("X2");

      try {
         Console.WriteLine("'{0}' converts to {1}.", positiveString.Value, Convert.ToByte(positiveString));
      }
      catch (OverflowException) {
         Console.WriteLine("0x{0} is outside the range of the Byte type.", positiveString.Value);
      }

      try {
         Console.WriteLine("'{0}' converts to {1}.", negativeString.Value, Convert.ToByte(negativeString));
      }
      catch (OverflowException) {
         Console.WriteLine("0x{0} is outside the range of the Byte type.", negativeString.Value);
      }
   }
}
// The example displays the following output:
//       'D8' converts to 216.
//       0x9B is outside the range of the Byte type.

Comentarios

provider permite al usuario especificar información de conversión específica de la referencia cultural sobre el contenido de value. Los tipos base omiten provider; sin embargo, el parámetro se puede usar si value es un tipo definido por el usuario que implementa la IConvertible interfaz.

ToByte(String, IFormatProvider)

Source:

Convert.cs

Convierte la representación de cadena especificada de un número en un entero de 8 bits sin signo equivalente, usando la información de formato específica de la referencia cultural indicada.

C#

public static byte ToByte (string? value, IFormatProvider? provider);

Parámetros

value

String

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

provider

IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value, o cero si value es null.

Excepciones

FormatException

value no está formado por un signo opcional seguido de una secuencia de dígitos (de 0 a 9).

OverflowException

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

Ejemplos

En el ejemplo siguiente se crea un objeto personalizado NumberFormatInfo que define el signo positivo como "pos" y el signo negativo como "neg", que usa en llamadas al ToByte(String, IFormatProvider) método . A continuación, llama ToByte(String, IFormatProvider) al método repetidamente para convertir cada elemento de una matriz de cadenas en un Byte valor.

C#

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Create a NumberFormatInfo object and set several of its
      // properties that apply to unsigned bytes.
      NumberFormatInfo provider = new NumberFormatInfo();

      // These properties affect the conversion.
      provider.PositiveSign = "pos ";
      provider.NegativeSign = "neg ";

      // This property does not affect the conversion.
      // The input string cannot have a decimal separator.
      provider.NumberDecimalSeparator = ".";

      // Define an array of numeric strings.
      string[] numericStrings = { "234", "+234", "pos 234", "234.", "255",
                                  "256", "-1" };

      foreach (string numericString in numericStrings)
      {
         Console.Write("'{0,-8}' ->   ", numericString);
         try {
            byte number = Convert.ToByte(numericString, provider);
            Console.WriteLine(number);
         }
         catch (FormatException) {
            Console.WriteLine("Incorrect Format");
         }
         catch (OverflowException) {
            Console.WriteLine("Overflows a Byte");
         }
      }
   }
}
// The example displays the following output:
//       '234     ' ->   234
//       '+234    ' ->   Incorrect Format
//       'pos 234 ' ->   234
//       '234.    ' ->   Incorrect Format
//       '255     ' ->   255
//       '256     ' ->   Overflows a Byte
//       '-1      ' ->   Incorrect Format

Comentarios

provider es una IFormatProvider instancia de que obtiene un NumberFormatInfo objeto . El NumberFormatInfo objeto proporciona información específica de la referencia cultural sobre el formato de value. Si provider es null, se usa el NumberFormatInfo objeto de la referencia cultural actual.

Si prefiere no controlar una excepción si se produce un error en la conversión, puede llamar al Byte.TryParse método en su lugar. Devuelve un Boolean valor que indica si la conversión se realizó correctamente o no.

Consulte también

• Parse(String)

ToByte(Single)

Source:

Convert.cs

Convierte el valor del número de punto flotante de precisión sencilla especificado en un entero de 8 bits sin signo equivalente.

C#

public static byte ToByte (float value);

Parámetros

value

Single

Número de punto flotante de precisión sencilla.

Devoluciones

Byte

value, se redondea al entero de 8 bits sin signo más próximo. Si value está en medio de dos números enteros, se devuelve el número par, es decir, 4,5 se convierte en 4 y 5,5 se convierte en 6.

Excepciones

OverflowException

value es mayor que Byte.MaxValue o menor que Byte.MinValue.

Ejemplos

En el ejemplo siguiente se convierte un Single valor en .Byte

C#

public void ConvertByteSingle(byte byteVal) {
    float floatVal;

    // Byte to float conversion will not overflow.
    floatVal = System.Convert.ToSingle(byteVal);
    System.Console.WriteLine("The byte as a float is {0}.",
        floatVal);

    // Float to byte conversion can overflow.
    try {
        byteVal = System.Convert.ToByte(floatVal);
        System.Console.WriteLine("The float as a byte is {0}.",
            byteVal);
    }
    catch (System.OverflowException) {
        System.Console.WriteLine(
            "The float value is too large for a byte.");
    }
}

Consulte también

• Round

ToByte(UInt64)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

Convierte el valor del entero de 64 bits sin signo especificado en un entero de 8 bits sin signo equivalente.

C#

[System.CLSCompliant(false)]
public static byte ToByte (ulong value);

Parámetros

value

UInt64

Entero de 64 bits sin signo que se va a convertir.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es mayor que Byte.MaxValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de enteros largos Byte sin signo en valores.

C#

ulong[] numbers= { UInt64.MinValue, 121, 340, UInt64.MaxValue };
byte result;
foreach (ulong number in numbers)
{
   try {
      result = Convert.ToByte(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException)
   {
      Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//       Converted the UInt64 value 0 to the Byte value 0.
//       Converted the UInt64 value 121 to the Byte value 121.
//       The UInt64 value 340 is outside the range of the Byte type.
//       The UInt64 value 18446744073709551615 is outside the range of the Byte type.

ToByte(SByte)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

Convierte el valor del entero de 8 bits con signo especificado en un entero de 8 bits sin signo equivalente.

C#

[System.CLSCompliant(false)]
public static byte ToByte (sbyte value);

Parámetros

value

SByte

El entero de 8 bits con signo que se va a convertir.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es menor que Byte.MinValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de SByte valores en Byte valores.

C#

sbyte[] numbers = { SByte.MinValue, -1, 0, 10, SByte.MaxValue };
byte result;
foreach (sbyte number in numbers)
{
   try {
      result = Convert.ToByte(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException)
   {
      Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//       The SByte value -128 is outside the range of the Byte type.
//       The SByte value -1 is outside the range of the Byte type.
//       Converted the SByte value 0 to the Byte value 0.
//       Converted the SByte value 10 to the Byte value 10.
//       Converted the SByte value 127 to the Byte value 127.

ToByte(DateTime)

Source:

Convert.cs

Cuando se llama a este método, siempre se produce InvalidCastException.

C#

public static byte ToByte (DateTime value);

Parámetros

value

DateTime

Valor de fecha y hora que se va a convertir.

Devoluciones

Byte

No se admite esta conversión. No se devuelve ningún valor.

Excepciones

InvalidCastException

No se admite esta conversión.

ToByte(Int64)

Source:

Convert.cs

Convierte el valor del entero de 64 bits con signo especificado en un entero de 8 bits sin signo equivalente.

C#

public static byte ToByte (long value);

Parámetros

value

Int64

Entero de 64 bits con signo que se va a convertir.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value.

Excepciones

OverflowException

value es menor que Byte.MinValue o mayor que Byte.MaxValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de Int64 valores en Byte valores.

C#

long[] numbers = { Int64.MinValue, -1, 0, 121, 340, Int64.MaxValue };
byte result;
foreach (long number in numbers)
{
   try {
      result = Convert.ToByte(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//       The Int64 value -9223372036854775808 is outside the range of the Byte type.
//       The Int64 value -1 is outside the range of the Byte type.
//       Converted the Int64 value 0 to the Byte value 0.
//       Converted the Int64 value 121 to the Byte value 121.
//       The Int64 value 340 is outside the range of the Byte type.
//       The Int64 value 9223372036854775807 is outside the range of the Byte type.

ToByte(Byte)

Source:

Convert.cs

Devuelve el entero de 8 bits sin signo especificado; no se efectúa una conversión real.

C#

public static byte ToByte (byte value);

Parámetros

value

Byte

Entero de 8 bits sin signo que se va a devolver.

Devoluciones

Byte

value se devuelve sin cambios.

ToByte(Char)

Source:

Convert.cs

Convierte el valor del carácter Unicode especificado en un entero de 8 bits sin signo equivalente.

C#

public static byte ToByte (char value);

Parámetros

value

Char

Carácter Unicode que se va a convertir.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value.

Excepciones

OverflowException

value representa un número mayor que Byte.MaxValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de Char valores en Byte valores.

C#

char[] chars = { 'a', 'z', '\x0007', '\x03FF' };
foreach (char ch in chars)
{
   try {
      byte result = Convert.ToByte(ch);
      Console.WriteLine("{0} is converted to {1}.", ch, result);
   }
   catch (OverflowException) {
      Console.WriteLine("Unable to convert u+{0} to a byte.",
                        Convert.ToInt16(ch).ToString("X4"));
   }
}
// The example displays the following output:
//       a is converted to 97.
//       z is converted to 122.
//        is converted to 7.
//       Unable to convert u+03FF to a byte.

Comentarios

Este método devuelve un valor de byte sin signo que representa el código numérico del Char objeto que se le ha pasado. En .NET, un Char objeto es un valor de 16 bits. Esto significa que el método es adecuado para devolver los códigos numéricos de caracteres en el intervalo de caracteres ASCII o en los controles Unicode C0 y basic latin, y C1 Controls and Latin-1 Supplement ranges, de U+0000 a U+00FF.

ToByte(Decimal)

Source:

Convert.cs

Convierte el valor del número decimal especificado en un entero de 8 bits sin signo equivalente.

C#

public static byte ToByte (decimal value);

Parámetros

value

Decimal

Número que se va a convertir.

Devoluciones

Byte

value, se redondea al entero de 8 bits sin signo más próximo. Si value está en medio de dos números enteros, se devuelve el número par, es decir, 4,5 se convierte en 4 y 5,5 se convierte en 6.

Excepciones

OverflowException

value es mayor que Byte.MaxValue o menor que Byte.MinValue.

Comentarios

En el ejemplo siguiente se convierte un Byte valor en Decimal y un Decimal valor en .Byte

C#

public void ConvertByteDecimal(byte byteVal) {
    decimal decimalVal;

    // Byte to decimal conversion will not overflow.
    decimalVal = System.Convert.ToDecimal(byteVal);
    System.Console.WriteLine("The byte as a decimal is {0}.",
        decimalVal);

    // Decimal to byte conversion can overflow.
    try {
        byteVal = System.Convert.ToByte(decimalVal);
        System.Console.WriteLine("The Decimal as a byte is {0}.",
            byteVal);
    }
    catch (System.OverflowException) {
        System.Console.WriteLine(
            "The decimal value is too large for a byte.");
    }
}

ToByte(Boolean)

Source:

Convert.cs

Convierte el valor booleano especificado en un entero de 8 bits sin signo equivalente.

C#

public static byte ToByte (bool value);

Parámetros

value

Boolean

Valor booleano que se va a convertir.

Devoluciones

Byte

Número 1 si value es true; en caso contrario, 0.

Ejemplos

En el ejemplo siguiente se muestra la conversión de Boolean a Byte valores.

C#

bool falseFlag = false;
bool trueFlag = true;

Console.WriteLine("{0} converts to {1}.", falseFlag,
                  Convert.ToByte(falseFlag));
Console.WriteLine("{0} converts to {1}.", trueFlag,
                  Convert.ToByte(trueFlag));
// The example displays the following output:
//       False converts to 0.
//       True converts to 1.

ToByte(Int16)

Source:

Convert.cs

Convierte el valor del entero de 16 bits con signo especificado en un entero de 8 bits sin signo equivalente.

C#

public static byte ToByte (short value);

Parámetros

value

Int16

Entero de 16 bits con signo que se va a convertir.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value.

Excepciones

OverflowException

value es menor que Byte.MinValue o mayor que Byte.MaxValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de Int16 valores en Byte valores.

C#

short[] numbers = { Int16.MinValue, -1, 0, 121, 340, Int16.MaxValue };
byte result;
foreach (short number in numbers)
{
   try {
      result = Convert.ToByte(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//       The Int16 value -32768 is outside the range of the Byte type.
//       The Int16 value -1 is outside the range of the Byte type.
//       Converted the Int16 value 0 to the Byte value 0.
//       Converted the Int16 value 121 to the Byte value 121.
//       The Int16 value 340 is outside the range of the Byte type.
//       The Int16 value 32767 is outside the range of the Byte type.

ToByte(Int32)

Source:

Convert.cs

Convierte el valor del entero de 32 bits con signo especificado en un entero de 8 bits sin signo equivalente.

C#

public static byte ToByte (int value);

Parámetros

value

Int32

Entero de 32 bits con signo que se va a convertir.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value.

Excepciones

OverflowException

value es menor que Byte.MinValue o mayor que Byte.MaxValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de Int32 valores en Byte valores.

C#

int[] numbers = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue };
byte result;
foreach (int number in numbers)
{
   try {
      result = Convert.ToByte(number);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        number.GetType().Name, number,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//       The Int32 value -2147483648 is outside the range of the Byte type.
//       The Int32 value -1 is outside the range of the Byte type.
//       Converted the Int32 value 0 to the Byte value 0.
//       Converted the Int32 value 121 to the Byte value 121.
//       The Int32 value 340 is outside the range of the Byte type.
//       The Int32 value 2147483647 is outside the range of the Byte type.

ToByte(Double)

Source:

Convert.cs

Convierte el valor del número de punto flotante de precisión doble especificado en un entero de 8 bits sin signo equivalente.

C#

public static byte ToByte (double value);

Parámetros

value

Double

Número de punto flotante de precisión doble que se va a convertir.

Devoluciones

Byte

value, se redondea al entero de 8 bits sin signo más próximo. Si value está en medio de dos números enteros, se devuelve el número par, es decir, 4,5 se convierte en 4 y 5,5 se convierte en 6.

Excepciones

OverflowException

value es mayor que Byte.MaxValue o menor que Byte.MinValue.

Ejemplos

En el ejemplo siguiente se convierte un Byte valor en Double y un Double valor en .Byte

C#

public void ConvertDoubleByte(double doubleVal) {
    byte	byteVal = 0;

    // Double to byte conversion can overflow.
    try {
        byteVal = System.Convert.ToByte(doubleVal);
        System.Console.WriteLine("{0} as a byte is: {1}.",
            doubleVal, byteVal);
    }
    catch (System.OverflowException) {
        System.Console.WriteLine(
            "Overflow in double-to-byte conversion.");
    }

    // Byte to double conversion cannot overflow.
    doubleVal = System.Convert.ToDouble(byteVal);
    System.Console.WriteLine("{0} as a double is: {1}.",
        byteVal, doubleVal);
}

ToByte(Object)

Source:

Convert.cs

Convierte el valor del objeto especificado en un entero de 8 bits sin signo.

C#

public static byte ToByte (object? value);

Parámetros

value

Object

Objeto que implementa la interfaz IConvertible o null.

Devoluciones

Byte

Un entero de 8 bits sin signo equivalente a value, o cero si value es null.

Excepciones

FormatException

value no está en el formato de la propiedad de un valor Byte.

InvalidCastException

value no implementa IConvertible.

O bien

No se admite la conversión de value al tipo Byte.

OverflowException

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

Ejemplos

En el ejemplo siguiente se usa el ToByte(Object) método para convertir una matriz de objetos en Byte valores.

C#

object[] values = { true, -12, 163, 935, 'x', "104", "103.0", "-1",
                    "1.00e2", "One", 1.00e2};
byte result;
foreach (object value in values)
{
   try {
      result = Convert.ToByte(value);
      Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                        value.GetType().Name, value,
                        result.GetType().Name, result);
   }
   catch (OverflowException)
   {
      Console.WriteLine("The {0} value {1} is outside the range of the Byte type.",
                        value.GetType().Name, value);
   }
   catch (FormatException)
   {
      Console.WriteLine("The {0} value {1} is not in a recognizable format.",
                        value.GetType().Name, value);
   }
   catch (InvalidCastException)
   {
      Console.WriteLine("No conversion to a Byte exists for the {0} value {1}.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//       Converted the Boolean value True to the Byte value 1.
//       The Int32 value -12 is outside the range of the Byte type.
//       Converted the Int32 value 163 to the Byte value 163.
//       The Int32 value 935 is outside the range of the Byte type.
//       Converted the Char value x to the Byte value 120.
//       Converted the String value 104 to the Byte value 104.
//       The String value 103.0 is not in a recognizable format.
//       The String value -1 is outside the range of the Byte type.
//       The String value 1.00e2 is not in a recognizable format.
//       The String value One is not in a recognizable format.
//       Converted the Double value 100 to the Byte value 100.

Comentarios

Si value no nulles , este método encapsula una llamada a la IConvertible.ToByte implementación del tipo subyacente de value.