Convert.ToSByte Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

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

Sobrecargas

ToSByte(SByte)	Devuelve el entero de 8 bits con signo especificado; no se realiza ninguna conversión real.
ToSByte(String, Int32)	Convierte la representación de cadena de un número en una base especificada en un entero de 8 bits con signo equivalente.
ToSByte(String, IFormatProvider)	Convierte la representación de cadena especificada de un número en un entero de 8 bits con signo equivalente, utilizando la información de formato específica de la referencia cultural especificada.
ToSByte(Object, IFormatProvider)	Convierte el valor del objeto especificado en un entero de 8 bits con signo, utilizando la información de formato específica de la referencia cultural especificada.
ToSByte(UInt64)	Convierte el valor del entero de 64 bits sin signo especificado en un entero de 8 bits con signo equivalente.
ToSByte(UInt32)	Convierte el valor del entero de 32 bits sin signo especificado en un entero de 8 bits con signo equivalente.
ToSByte(String)	Convierte la representación de cadena especificada de un número en un entero de 8 bits con signo equivalente.
ToSByte(Single)	Convierte el valor del número de punto flotante de precisión simple especificado en un entero de 8 bits con signo equivalente.
ToSByte(Object)	Convierte el valor del objeto especificado en un entero de 8 bits con signo.
ToSByte(UInt16)	Convierte el valor del entero de 16 bits sin signo especificado en el entero de 8 bits con signo equivalente.
ToSByte(Int32)	Convierte el valor del entero con signo de 32 bits especificado en un entero de 8 bits con signo equivalente.
ToSByte(Int64)	Convierte el valor del entero con signo de 64 bits especificado en un entero de 8 bits con signo equivalente.
ToSByte(Byte)	Convierte el valor del entero de 8 bits sin signo especificado en el entero de 8 bits con signo equivalente.
ToSByte(Char)	Convierte el valor del carácter Unicode especificado en el entero de 8 bits con signo equivalente.
ToSByte(DateTime)	Al llamar a este método siempre se produce InvalidCastException.
ToSByte(Boolean)	Convierte el valor booleano especificado en el entero de 8 bits con signo equivalente.
ToSByte(Double)	Convierte el valor del número de punto flotante de precisión doble especificado en un entero de 8 bits con signo equivalente.
ToSByte(Int16)	Convierte el valor del entero con signo de 16 bits especificado en el entero de 8 bits con signo equivalente.
ToSByte(Decimal)	Convierte el valor del número decimal especificado en un entero de 8 bits con signo equivalente.

ToSByte(SByte)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

Devuelve el entero de 8 bits con signo especificado; no se realiza ninguna conversión real.

C#

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

Parámetros

value

SByte

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

Devoluciones

SByte

value se devuelve sin cambios.

Atributos

CLSCompliantAttribute

ToSByte(String, Int32)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (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

SByte

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

Atributos

CLSCompliantAttribute

Excepciones

ArgumentException

fromBase no es 2, 8, 10 o 16.

-o-

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

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; De lo contrario, el mensaje indica que value contiene caracteres finales no válidos.

OverflowException

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

-o-

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

Ejemplos

En el ejemplo siguiente se intenta interpretar los elementos de una matriz de cadenas como la representación binaria, octal y hexadecimal de valores numéricos para convertirlos en bytes sin signo.

C#

using System;

public class Example
{
   public static void Main()
   {
      int[] baseValues = { 2, 8, 16};
      string[] values = { "FF", "81", "03", "11", "8F", "01", "1C", "111",
                          "123", "18A" };

      // Convert to each supported base.
      foreach (int baseValue in baseValues)
      {
         Console.WriteLine("Converting strings in base {0}:", baseValue);
         foreach (string value in values)
         {
            Console.Write("   '{0,-5}  -->  ", value + "'");
            try {
               Console.WriteLine(Convert.ToSByte(value, baseValue));
            }
            catch (FormatException) {
               Console.WriteLine("Bad Format");
            }
            catch (OverflowException) {
               Console.WriteLine("Out of Range");
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       Converting strings in base 2:
//          'FF'    -->  Bad Format
//          '81'    -->  Bad Format
//          '03'    -->  Bad Format
//          '11'    -->  3
//          '8F'    -->  Bad Format
//          '01'    -->  1
//          '1C'    -->  Bad Format
//          '111'   -->  7
//          '123'   -->  Bad Format
//          '18A'   -->  Bad Format
//
//       Converting strings in base 8:
//          'FF'    -->  Bad Format
//          '81'    -->  Bad Format
//          '03'    -->  3
//          '11'    -->  9
//          '8F'    -->  Bad Format
//          '01'    -->  1
//          '1C'    -->  Bad Format
//          '111'   -->  73
//          '123'   -->  83
//          '18A'   -->  Bad Format
//
//       Converting strings in base 16:
//          'FF'    -->  -1
//          '81'    -->  -127
//          '03'    -->  3
//          '11'    -->  17
//          '8F'    -->  -113
//          '01'    -->  1
//          '1C'    -->  28
//          '111'   -->  Out of Range
//          '123'   -->  Out of Range
//          '18A'   -->  Out of Range

Comentarios

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

Dado que el signo negativo no se admite para representaciones numéricas que no son base 10, el método ToSByte(String, Int32) supone que los números negativos usan la representación complementaria de dos. En otras palabras, el método siempre interpreta el bit de orden superior de un byte (bit 7) como su bit de signo. Como resultado, es posible escribir código en el que un número no base 10 que está fuera del intervalo del tipo de datos SByte se convierte en un valor de SByte sin que el método inicie una excepción. En el ejemplo siguiente se convierte MaxValue en su representación de cadena hexadecimal y, a continuación, se llama al método ToSByte(String, Int32). En lugar de producir una excepción, el método muestra el mensaje "0xff convierte a -1".

C#

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

Al realizar operaciones binarias o conversiones numéricas, siempre es responsabilidad del desarrollador comprobar que un método usa la representación numérica adecuada para interpretar un valor determinado. Como se muestra en el ejemplo siguiente, puede asegurarse de que el método controla los desbordamientos adecuadamente al determinar primero si un valor representa un tipo sin signo o un tipo firmado al convertirlo en su representación de cadena hexadecimal. Inicie una excepción si el valor original era un tipo sin signo, pero la conversión a un byte firmado produce un valor cuyo bit de signo está activado.

C#

// Create a hexadecimal value out of range of the SByte type.
byte sourceNumber = byte.MaxValue;
bool isSigned = Math.Sign(Convert.ToDouble(sourceNumber.GetType().GetField("MinValue").GetValue(null))) == -1;
string value = Convert.ToString(sourceNumber, 16);
sbyte targetNumber;
try
{
   targetNumber = Convert.ToSByte(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 a signed byte.", value);
}
// Displays the following to the console:
//    Unable to convert '0xff' to a signed byte.

ToSByte(String, IFormatProvider)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (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

SByte

Entero de 8 bits con signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

ArgumentNullException

value es null.

FormatException

value no consta de un signo opcional seguido de una secuencia de dígitos (de 0 a 9).

OverflowException

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

Ejemplos

En el ejemplo siguiente se convierten representaciones de cadena de valores de SByte con el método ToSByte mediante un objeto IFormatProvider.

C#

// Example of the Convert.ToSByte( string ) and
// Convert.ToSByte( string, IFormatProvider ) methods.
using System;
using System.Globalization;

class ToSByteProviderDemo
{
    static string format = "{0,-20}{1,-20}{2}";

     // Get the exception type name; remove the namespace prefix.
    static string GetExceptionType( Exception ex )
    {
        string exceptionType = ex.GetType( ).ToString( );
        return exceptionType.Substring(
            exceptionType.LastIndexOf( '.' ) + 1 );
    }

    static void ConvertToSByte( string numericStr,
        IFormatProvider provider )
    {
        object defaultValue;
        object providerValue;

        // Convert numericStr to SByte without a format provider.
        try
        {
            defaultValue = Convert.ToSByte( numericStr );
        }
        catch( Exception ex )
        {
            defaultValue = GetExceptionType( ex );
        }

        // Convert numericStr to SByte with a format provider.
        try
        {
            providerValue = Convert.ToSByte( numericStr, provider );
        }
        catch( Exception ex )
        {
            providerValue = GetExceptionType( ex );
        }

        Console.WriteLine( format, numericStr,
            defaultValue, providerValue );
    }

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

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

        // These properties do not affect the conversion.
        // The input string cannot have decimal and group separators.
        provider.NumberDecimalSeparator = ".";
        provider.NumberNegativePattern = 0;

        Console.WriteLine("This example of\n" +
            "  Convert.ToSByte( string ) and \n" +
            "  Convert.ToSByte( string, IFormatProvider ) " +
            "\ngenerates the following output. It converts " +
            "several strings to \nSByte values, using " +
            "default formatting or a NumberFormatInfo object.\n" );
        Console.WriteLine( format, "String to convert",
            "Default/exception", "Provider/exception" );
        Console.WriteLine( format, "-----------------",
            "-----------------", "------------------" );

        // Convert strings, with and without an IFormatProvider.
        ConvertToSByte( "123", provider );
        ConvertToSByte( "+123", provider );
        ConvertToSByte( "pos 123", provider );
        ConvertToSByte( "-123", provider );
        ConvertToSByte( "neg 123", provider );
        ConvertToSByte( "123.", provider );
        ConvertToSByte( "(123)", provider );
        ConvertToSByte( "128", provider );
        ConvertToSByte( "-129", provider );
    }
}

/*
This example of
  Convert.ToSByte( string ) and
  Convert.ToSByte( string, IFormatProvider )
generates the following output. It converts several strings to
SByte values, using default formatting or a NumberFormatInfo object.

String to convert   Default/exception   Provider/exception
-----------------   -----------------   ------------------
123                 123                 123
+123                123                 FormatException
pos 123             FormatException     123
-123                -123                FormatException
neg 123             FormatException     -123
123.                FormatException     FormatException
(123)               FormatException     FormatException
128                 OverflowException   OverflowException
-129                OverflowException   FormatException
*/

Comentarios

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

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

Consulte también

• Parse(String)

ToSByte(Object, IFormatProvider)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (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

SByte

Entero de 8 bits con signo equivalente a value, o cero si value es null.

Atributos

CLSCompliantAttribute

Excepciones

FormatException

value no está en un formato adecuado.

InvalidCastException

value no implementa la interfaz IConvertible.

-o-

No se admite la conversión.

OverflowException

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

Ejemplos

En el ejemplo siguiente se define una clase ByteString que almacena bytes firmados y sin signo como cadenas hexadecimales junto con un campo que indica el signo del byte. La clase ByteString implementa la interfaz IConvertible. Su método IConvertible.ToSByte llama al método Parse(String, IFormatProvider) para realizar la conversión. Si se produce un error, inicia una OverflowException.

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)
   {
      try {
         return SByte.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);
      }
   }

   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 muestra cómo el método Convert.ToSByte(Object, IFormatProvider) llama a la implementación IConvertible.ToSByte de la clase ByteString.

C#

public class Class1
{
   public static void Main()
   {
      sbyte positiveByte = 120;
      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.ToSByte(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.ToSByte(negativeString));
      }
      catch (OverflowException) {
         Console.WriteLine("0x{0} is outside the range of the Byte type.", negativeString.Value);
      }
   }
}
// The example displays the following output:
//       '78' converts to 120.
//       '9B' converts to -101.

Comentarios

provider permite al usuario especificar información de conversión específica de la referencia cultural sobre el contenido de value. Por ejemplo, si value es un String que representa un número, provider podría proporcionar información específica de la referencia cultural sobre la notación utilizada para representar ese número.

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 interfaz IConvertible.

ToSByte(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 con signo equivalente.

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (ulong value);

Parámetros

value

UInt64

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

Devoluciones

SByte

Entero de 8 bits con signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

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

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de enteros largos en un byte firmado.

C#

ulong[] numbers = { UInt64.MinValue, 121, 340, UInt64.MaxValue };
sbyte result;

foreach (ulong number in numbers)
{
   try {
      result = Convert.ToSByte(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 SByte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    Converted the UInt64 value 0 to the SByte value 0.
//    Converted the UInt64 value 121 to the SByte value 121.
//    The UInt64 value 340 is outside the range of the SByte type.
//    The UInt64 value 18446744073709551615 is outside the range of the SByte type.

ToSByte(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 con signo equivalente.

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (uint value);

Parámetros

value

UInt32

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

Devoluciones

SByte

Entero de 8 bits con signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

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

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de enteros en un byte firmado.

C#

uint[] numbers = { UInt32.MinValue, 121, 340, UInt32.MaxValue };
sbyte result;

foreach (uint number in numbers)
{
   try {
      result = Convert.ToSByte(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 SByte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    Converted the UInt32 value 0 to the SByte value 0.
//    Converted the UInt32 value 121 to the SByte value 121.
//    The UInt32 value 340 is outside the range of the SByte type.
//    The UInt32 value 4294967295 is outside the range of the SByte type.

ToSByte(String)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (string? value);

Parámetros

value

String

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

Devoluciones

SByte

Entero de 8 bits con signo equivalente al número de value, o 0 (cero) si el valor es null.

Atributos

CLSCompliantAttribute

Excepciones

FormatException

value no consta de un signo opcional seguido de una secuencia de dígitos (de 0 a 9).

OverflowException

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

Ejemplos

En el ejemplo siguiente se convierten representaciones de cadena de valores de SByte con el método ToSByte mediante el formato predeterminado.

C#

// Example of the Convert.ToSByte( string ) and
// Convert.ToSByte( string, IFormatProvider ) methods.
using System;
using System.Globalization;

class ToSByteProviderDemo
{
    static string format = "{0,-20}{1,-20}{2}";

     // Get the exception type name; remove the namespace prefix.
    static string GetExceptionType( Exception ex )
    {
        string exceptionType = ex.GetType( ).ToString( );
        return exceptionType.Substring(
            exceptionType.LastIndexOf( '.' ) + 1 );
    }

    static void ConvertToSByte( string numericStr,
        IFormatProvider provider )
    {
        object defaultValue;
        object providerValue;

        // Convert numericStr to SByte without a format provider.
        try
        {
            defaultValue = Convert.ToSByte( numericStr );
        }
        catch( Exception ex )
        {
            defaultValue = GetExceptionType( ex );
        }

        // Convert numericStr to SByte with a format provider.
        try
        {
            providerValue = Convert.ToSByte( numericStr, provider );
        }
        catch( Exception ex )
        {
            providerValue = GetExceptionType( ex );
        }

        Console.WriteLine( format, numericStr,
            defaultValue, providerValue );
    }

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

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

        // These properties do not affect the conversion.
        // The input string cannot have decimal and group separators.
        provider.NumberDecimalSeparator = ".";
        provider.NumberNegativePattern = 0;

        Console.WriteLine("This example of\n" +
            "  Convert.ToSByte( string ) and \n" +
            "  Convert.ToSByte( string, IFormatProvider ) " +
            "\ngenerates the following output. It converts " +
            "several strings to \nSByte values, using " +
            "default formatting or a NumberFormatInfo object.\n" );
        Console.WriteLine( format, "String to convert",
            "Default/exception", "Provider/exception" );
        Console.WriteLine( format, "-----------------",
            "-----------------", "------------------" );

        // Convert strings, with and without an IFormatProvider.
        ConvertToSByte( "123", provider );
        ConvertToSByte( "+123", provider );
        ConvertToSByte( "pos 123", provider );
        ConvertToSByte( "-123", provider );
        ConvertToSByte( "neg 123", provider );
        ConvertToSByte( "123.", provider );
        ConvertToSByte( "(123)", provider );
        ConvertToSByte( "128", provider );
        ConvertToSByte( "-129", provider );
    }
}

/*
This example of
  Convert.ToSByte( string ) and
  Convert.ToSByte( string, IFormatProvider )
generates the following output. It converts several strings to
SByte values, using default formatting or a NumberFormatInfo object.

String to convert   Default/exception   Provider/exception
-----------------   -----------------   ------------------
123                 123                 123
+123                123                 FormatException
pos 123             FormatException     123
-123                -123                FormatException
neg 123             FormatException     -123
123.                FormatException     FormatException
(123)               FormatException     FormatException
128                 OverflowException   OverflowException
-129                OverflowException   FormatException
*/

Comentarios

El uso del método ToSByte(String) equivale a pasar value al método SByte.Parse(String). 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 método SByte.TryParse en su lugar. Devuelve un Boolean valor que indica si la conversión se realizó correctamente o no.

Consulte también

• Parse(String)

ToSByte(Single)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (float value);

Parámetros

value

Single

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

Devoluciones

SByte

value, redondeado al entero de 8 bits con signo más cercano. Si value está a mitad de camino entre 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.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

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

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de valores de Single en un byte firmado.

C#

object[] values = { true, -12, 163, 935, 'x', "104", "103.0", "-1",
                    "1.00e2", "One", 1.00e2};
sbyte result;

foreach (object value in values)
{
   try {
      result = Convert.ToSByte(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 SByte 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 SByte value 1.
//    Converted the Int32 value -12 to the SByte value -12.
//    The Int32 value 163 is outside the range of the SByte type.
//    The Int32 value 935 is outside the range of the SByte type.
//    Converted the Char value x to the SByte value 120.
//    Converted the String value 104 to the SByte value 104.
//    The String value 103.0 is not in a recognizable format.
//    Converted the String value -1 to the SByte value -1.
//    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 SByte value 100.

Consulte también

• Single
• Round

ToSByte(Object)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (object? value);

Parámetros

value

Object

Objeto que implementa la interfaz IConvertible o null.

Devoluciones

SByte

Entero de 8 bits con signo equivalente a value, o cero si value es null.

Atributos

CLSCompliantAttribute

Excepciones

FormatException

value no está en un formato adecuado.

InvalidCastException

value no implementa la interfaz IConvertible.

-o-

No se admite la conversión.

OverflowException

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

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de objetos en un byte firmado.

C#

object[] values = { true, -12, 163, 935, 'x', "104", "103.0", "-1",
                    "1.00e2", "One", 1.00e2};
sbyte result;

foreach (object value in values)
{
   try {
      result = Convert.ToSByte(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 SByte 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 SByte value 1.
//    Converted the Int32 value -12 to the SByte value -12.
//    The Int32 value 163 is outside the range of the SByte type.
//    The Int32 value 935 is outside the range of the SByte type.
//    Converted the Char value x to the SByte value 120.
//    Converted the String value 104 to the SByte value 104.
//    The String value 103.0 is not in a recognizable format.
//    Converted the String value -1 to the SByte value -1.
//    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 SByte value 100.

Comentarios

El valor devuelto es el resultado de invocar el método IConvertible.ToSByte del tipo subyacente de value.

ToSByte(UInt16)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (ushort value);

Parámetros

value

UInt16

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

Devoluciones

SByte

Entero de 8 bits con signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

es mayor que SByte.MaxValue.

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento en una matriz de enteros de 16 bits sin signo en un byte con signo.

C#

ushort[] numbers = { UInt16.MinValue, 121, 340, UInt16.MaxValue };
sbyte result;

foreach (ushort number in numbers)
{
   try {
      result = Convert.ToSByte(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 SByte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    Converted the UInt16 value 0 to the SByte value 0.
//    Converted the UInt16 value 121 to the SByte value 121.
//    The UInt16 value 340 is outside the range of the SByte type.
//    The UInt16 value 65535 is outside the range of the SByte type.

ToSByte(Int32)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (int value);

Parámetros

value

Int32

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

Devoluciones

SByte

Entero de 8 bits con signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

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

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de enteros con signo en un byte firmado.

C#

int[] numbers = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue };
sbyte result;

foreach (int number in numbers)
{
   try {
      result = Convert.ToSByte(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 SByte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Int32 value -2147483648 is outside the range of the SByte type.
//    Converted the Int32 value -1 to the SByte value -1.
//    Converted the Int32 value 0 to the SByte value 0.
//    Converted the Int32 value 121 to the SByte value 121.
//    The Int32 value 340 is outside the range of the SByte type.
//    The Int32 value 2147483647 is outside the range of the SByte type.

ToSByte(Int64)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (long value);

Parámetros

value

Int64

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

Devoluciones

SByte

Entero de 8 bits con signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

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

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de enteros largos en un byte firmado.

C#

long[] numbers = { Int64.MinValue, -1, 0, 121, 340, Int64.MaxValue };
sbyte result;
foreach (long number in numbers)
{
   try {
      result = Convert.ToSByte(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 SByte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Int64 value -9223372036854775808 is outside the range of the SByte type.
//    Converted the Int64 value -1 to the SByte value -1.
//    Converted the Int64 value 0 to the SByte value 0.
//    Converted the Int64 value 121 to the SByte value 121.
//    The Int64 value 340 is outside the range of the SByte type.
//    The Int64 value 9223372036854775807 is outside the range of the SByte type.

ToSByte(Byte)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

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

Parámetros

value

Byte

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

Devoluciones

SByte

Entero de 8 bits con signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

es mayor que SByte.MaxValue.

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de bytes en un byte firmado.

C#

byte[] numbers = { Byte.MinValue, 10, 100, Byte.MaxValue };
sbyte result;

foreach (byte number in numbers)
{
   try {
      result = Convert.ToSByte(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 SByte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    Converted the Byte value 0 to the SByte value 0.
//    Converted the Byte value 10 to the SByte value 10.
//    Converted the Byte value 100 to the SByte value 100.
//    The Byte value 255 is outside the range of the SByte type.

ToSByte(Char)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (char value);

Parámetros

value

Char

Carácter Unicode que se va a convertir.

Devoluciones

SByte

Entero de 8 bits con signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

es mayor que SByte.MaxValue.

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de valores de Char en un byte firmado.

C#

char[] chars = { 'a', 'z', '\u0007', '\u0200', '\u1023' };
foreach (char ch in chars)
{
   try {
      sbyte result = Convert.ToSByte(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+00C8 to a byte.
//    Unable to convert u+03FF to a byte.

ToSByte(DateTime)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

Al llamar a este método siempre se produce InvalidCastException.

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (DateTime value);

Parámetros

value

DateTime

Valor de fecha y hora que se va a convertir.

Devoluciones

SByte

Esta conversión no se admite. No se devuelve ningún valor.

Atributos

CLSCompliantAttribute

Excepciones

InvalidCastException

Esta conversión no se admite.

ToSByte(Boolean)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (bool value);

Parámetros

value

Boolean

Valor booleano que se va a convertir.

Devoluciones

SByte

Número 1 si value es true; de lo contrario, 0.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se convierten los valores booleanos true y false en valores de bytes firmados.

C#

bool falseFlag = false;
bool trueFlag = true;

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

ToSByte(Double)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (double value);

Parámetros

value

Double

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

Devoluciones

SByte

value, redondeado al entero de 8 bits con signo más cercano. Si value está a mitad de camino entre 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.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

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

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de valores de Double en un byte firmado.

C#

double[] numbers = { Double.MinValue, -129.5, -12.7, 0, 16,
                     103.6, 255.0, 1.63509e17, Double.MaxValue};
sbyte result;

foreach (double number in numbers)
{
   try {
      result = Convert.ToSByte(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 SByte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Double value -1.79769313486232E+308 is outside the range of the SByte type.
//    The Double value -129.5 is outside the range of the SByte type.
//    Converted the Double value -12.7 to the SByte value -13.
//    Converted the Double value 0 to the SByte value 0.
//    Converted the Double value 16 to the SByte value 16.
//    Converted the Double value 103.6 to the SByte value 104.
//    The Double value 255 is outside the range of the SByte type.
//    The Double value 1.63509E+17 is outside the range of the SByte type.
//    The Double value 1.79769313486232E+308 is outside the range of the SByte type.

Consulte también

• Double
• Round

ToSByte(Int16)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (short value);

Parámetros

value

Int16

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

Devoluciones

SByte

Entero de 8 bits con signo equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

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

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de enteros de 16 bits con signo en un byte con signo.

C#

short[] numbers = { Int16.MinValue, -1, 0, 121, 340, Int16.MaxValue };
sbyte result;
foreach (short number in numbers)
{
   try {
      result = Convert.ToSByte(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 SByte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Int16 value -32768 is outside the range of the SByte type.
//    Converted the Int16 value -1 to the SByte value -1.
//    Converted the Int16 value 0 to the SByte value 0.
//    Converted the Int16 value 121 to the SByte value 121.
//    The Int16 value 340 is outside the range of the SByte type.
//    The Int16 value 32767 is outside the range of the SByte type.

ToSByte(Decimal)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

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

C#

[System.CLSCompliant(false)]
public static sbyte ToSByte (decimal value);

Parámetros

value

Decimal

Número decimal que se va a convertir.

Devoluciones

SByte

value, redondeado al entero de 8 bits con signo más cercano. Si value está a mitad de camino entre 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.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

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

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de valores de Decimal en un byte firmado.

C#

decimal[] numbers = { Decimal.MinValue, -129.5m, -12.7m, 0m, 16m,
                      103.6m, 255.0m, Decimal.MaxValue };
sbyte result;

foreach (decimal number in numbers)
{
   try {
      result = Convert.ToSByte(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 SByte type.",
                        number.GetType().Name, number);
   }
}
// The example displays the following output:
//    The Decimal value -79228162514264337593543950335 is outside the range of the SByte type.
//    The Decimal value -129.5 is outside the range of the SByte type.
//    Converted the Decimal value -12.7 to the SByte value -13.
//    Converted the Decimal value 0 to the SByte value 0.
//    Converted the Decimal value 16 to the SByte value 16.
//    Converted the Decimal value 103.6 to the SByte value 104.
//    The Decimal value 255 is outside the range of the SByte type.
//    The Decimal value 79228162514264337593543950335 is outside the range of the SByte type.

Consulte también

• Round