Convert.ToSingle Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Convierte un valor especificado en un número de punto flotante de precisión sencilla.

Sobrecargas

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

ToSingle(String, IFormatProvider)

Source:

Convert.cs

Convierte la representación de cadena especificada de un número en un número de punto flotante de precisión sencilla equivalente, usando la información de formato específica de la referencia cultural indicada.

C#

public static float ToSingle (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

Single

Un número de punto flotante de precisión sencilla equivalente al número de value, o 0 (cero) si value es null.

Excepciones

FormatException

value no es un número con un formato válido.

OverflowException

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

Ejemplos

En el ejemplo siguiente se usan IFormatProvider objetos que representan las referencias culturales en-US y fr-FR cuando convierte los elementos de una matriz de cadenas numéricas en Single valores.

C#

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values = { "123456789", "12345.6789", "12 345,6789",
                          "123,456.789", "123 456,789", "123,456,789.0123",
                          "123 456 789,0123", "1.235e12", "1.03221e-05",
                          Double.MaxValue.ToString() };
      CultureInfo[] cultures = { new CultureInfo("en-US"),
                                 new CultureInfo("fr-FR") };

      foreach (CultureInfo culture in cultures)
      {
         Console.WriteLine("String -> Single Conversion Using the {0} Culture",
                           culture.Name);
         foreach (string value in values)
         {
            Console.Write("{0,22}  ->  ", value);
            try {
               Console.WriteLine(Convert.ToSingle(value, culture));
            }
            catch (FormatException) {
               Console.WriteLine("FormatException");
            }
            catch (OverflowException) {
               Console.WriteLine("OverflowException");
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    String -> Single Conversion Using the en-US Culture
//                 123456789  ->  1.234568E+08
//                12345.6789  ->  12345.68
//               12 345,6789  ->  FormatException
//               123,456.789  ->  123456.8
//               123 456,789  ->  FormatException
//          123,456,789.0123  ->  1.234568E+08
//          123 456 789,0123  ->  FormatException
//                  1.235e12  ->  1.235E+12
//               1.03221e-05  ->  1.03221E-05
//     1.79769313486232E+308  ->  Overflow
//
//    String -> Single Conversion Using the fr-FR Culture
//                 123456789  ->  1.234568E+08
//                12345.6789  ->  FormatException
//               12 345,6789  ->  12345.68
//               123,456.789  ->  FormatException
//               123 456,789  ->  123456.8
//          123,456,789.0123  ->  FormatException
//          123 456 789,0123  ->  1.234568E+08
//                  1.235e12  ->  FormatException
//               1.03221e-05  ->  FormatException
//     1.79769313486232E+308  ->  FormatException

Comentarios

El valor devuelto es el resultado de invocar el Single.Parse método en value.

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 para NumberFormatInfo la referencia cultural actual.

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

ToSingle(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 número de punto flotante de precisión sencilla equivalente.

C#

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

Parámetros

value

SByte

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

Devoluciones

Single

Un entero de 8 bits con signo equivalente a value.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de bytes con signo en un Single valor .

C#

sbyte[] numbers = { SByte.MinValue, -23, 0, 17, SByte.MaxValue };
float result;

foreach (sbyte number in numbers)
{
   result = Convert.ToSingle(number);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     number.GetType().Name, number,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the SByte value '-128' to the Single value -128.
//    Converted the SByte value '-23' to the Single value -23.
//    Converted the SByte value '0' to the Single value 0.
//    Converted the SByte value '17' to the Single value 17.
//    Converted the SByte value '127' to the Single value 127.

ToSingle(Object, IFormatProvider)

Source:

Convert.cs

Convierte el valor del objeto especificado en un número de punto flotante de precisión sencilla, usando la información de formato específica de la referencia cultural indicada.

C#

public static float ToSingle (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

Single

Un número de punto flotante de precisión sencilla equivalente a value, o cero si value es null.

Excepciones

FormatException

value no tiene un formato adecuado.

InvalidCastException

value no implementa IConvertible.

OverflowException

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

Ejemplos

En el ejemplo siguiente se define una clase Temperature que implementa la interfaz IConvertible . Su implementación del IConvertible.ToSingle método devuelve el valor interno de una variable privada Single que representa la temperatura.

C#

using System;
using System.Globalization;

public class Temperature : IConvertible
{
   private float m_Temp;

   public Temperature(float temperature)
   {
      this.m_Temp = temperature;
   }

   public float Celsius
   {
      get { return this.m_Temp; }
   }

   public float Kelvin
   {
      get { return this.m_Temp + 273.15f; }
   }

   public float Fahrenheit
   {
      get { return (float) Math.Round(this.m_Temp * 9 / 5 + 32, 2); }
   }

   public override string ToString()
   {
      return m_Temp.ToString("N2") + " °C";
   }

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

   public bool ToBoolean(IFormatProvider provider)
   {
      if (m_Temp == 0)
         return false;
      else
         return true;
   }

   public byte ToByte(IFormatProvider provider)
   {
      if (m_Temp < Byte.MinValue || m_Temp > Byte.MaxValue)
         throw new OverflowException(String.Format("{0} is out of range of the Byte type.",
                                                   this.m_Temp));
      else
         return Convert.ToByte(this.m_Temp);
   }

   public char ToChar(IFormatProvider provider)
   {
      throw new InvalidCastException("Temperature to Char conversion is not supported.");
   }

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

   public decimal ToDecimal(IFormatProvider provider)
   {
      return Convert.ToDecimal(this.m_Temp);
   }

   public double ToDouble(IFormatProvider provider)
   {
      return Convert.ToDouble(this.m_Temp);
   }

   public short ToInt16(IFormatProvider provider)
   {
      if (this.m_Temp < Int16.MinValue || this.m_Temp > Int16.MaxValue)
         throw new OverflowException(String.Format("{0} is out of range of the Int16 type.",
                                                   this.m_Temp));
      else
         return Convert.ToInt16(this.m_Temp);
   }

   public int ToInt32(IFormatProvider provider)
      {
      if (this.m_Temp < Int32.MinValue || this.m_Temp > Int32.MaxValue)
         throw new OverflowException(String.Format("{0} is out of range of the Int32 type.",
                                                   this.m_Temp));
      else
         return Convert.ToInt32(this.m_Temp);
   }

   public long ToInt64(IFormatProvider provider)
   {
      if (this.m_Temp < Int64.MinValue || this.m_Temp > Int64.MaxValue)
         throw new OverflowException(String.Format("{0} is out of range of the Int64 type.",
                                                   this.m_Temp));
      else
         return Convert.ToInt64(this.m_Temp);
   }

   public sbyte ToSByte(IFormatProvider provider)
   {
      if (this.m_Temp < SByte.MinValue || this.m_Temp > SByte.MaxValue)
         throw new OverflowException(String.Format("{0} is out of range of the SByte type.",
                                                   this.m_Temp));
      else
         return Convert.ToSByte(this.m_Temp);
   }

   public float ToSingle(IFormatProvider provider)
   {
      return this.m_Temp;
   }

   public string ToString(IFormatProvider provider)
   {
      return m_Temp.ToString("N2", provider) + " °C";
   }

   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(Temperature).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(provider);
         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 ushort ToUInt16(IFormatProvider provider)
   {
      if (this.m_Temp < UInt16.MinValue || this.m_Temp > UInt16.MaxValue)
         throw new OverflowException(String.Format("{0} is out of range of the UInt16 type.",
                                                   this.m_Temp));
      else
         return Convert.ToUInt16(this.m_Temp);
   }

   public uint ToUInt32(IFormatProvider provider)
   {
      if (this.m_Temp < UInt32.MinValue || this.m_Temp > UInt32.MaxValue)
         throw new OverflowException(String.Format("{0} is out of range of the UInt32 type.",
                                                   this.m_Temp));
      else
         return Convert.ToUInt32(this.m_Temp);
   }

   public ulong ToUInt64(IFormatProvider provider)
   {
      if (this.m_Temp < UInt64.MinValue || this.m_Temp > UInt64.MaxValue)
         throw new OverflowException(String.Format("{0} is out of range of the UInt64 type.",
                                                   this.m_Temp));
      else
         return Convert.ToUInt64(this.m_Temp);
   }
}

En el ejemplo siguiente se muestra cómo una llamada al Convert.ToSingle(Object, IFormatProvider) método, a su vez, llama a la IConvertible.ToSingle implementación de la Temperature clase .

C#

public class Example
{
   public static void Main()
   {
      Temperature cold = new Temperature(-40);
      Temperature freezing = new Temperature(0);
      Temperature boiling = new Temperature(100);

      Console.WriteLine(Convert.ToInt32(cold, null));
      Console.WriteLine(Convert.ToInt32(freezing, null));
      Console.WriteLine(Convert.ToDouble(boiling, null));
   }
}
// The example dosplays the following output:
//       -40
//       0
//       100

Comentarios

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

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

ToSingle(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 número de punto flotante de precisión sencilla equivalente.

C#

[System.CLSCompliant(false)]
public static float ToSingle (ulong value);

Parámetros

value

UInt64

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

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente a value.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de enteros largos sin signo en un Single valor .

C#

ulong[] numbers = { UInt64.MinValue, 121, 12345, UInt64.MaxValue };
float result;

foreach (ulong number in numbers)
{
   result = Convert.ToSingle(number);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     number.GetType().Name, number,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the UInt64 value '0' to the Single value 0.
//    Converted the UInt64 value '121' to the Single value 121.
//    Converted the UInt64 value '12345' to the Single value 12345.
//    Converted the UInt64 value '18446744073709551615' to the Single value 1.844674E+19.

ToSingle(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 número de punto flotante de precisión sencilla equivalente.

C#

[System.CLSCompliant(false)]
public static float ToSingle (uint value);

Parámetros

value

UInt32

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

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente a value.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de enteros sin signo en un Single valor .

C#

uint[] numbers = { UInt32.MinValue, 121, 12345, UInt32.MaxValue };
float result;

foreach (uint number in numbers)
{
   result = Convert.ToSingle(number);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     number.GetType().Name, number,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the UInt32 value '0' to the Single value 0.
//    Converted the UInt32 value '121' to the Single value 121.
//    Converted the UInt32 value '12345' to the Single value 12345.
//    Converted the UInt32 value '4294967295' to the Single value 4.294967E+09.

ToSingle(String)

Source:

Convert.cs

Convierte la representación de cadena especificada de un número en un número de punto flotante de precisión sencilla equivalente.

C#

public static float ToSingle (string? value);

Parámetros

value

String

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

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente al número de value, o 0 (cero) si value es null.

Excepciones

FormatException

value no es un número con un formato válido.

OverflowException

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

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de cadenas numéricas en un Single valor .

C#

string[] values= { "-1,035.77219", "1AFF", "1e-35", "1.63f",
                   "1,635,592,999,999,999,999,999,999", "-17.455",
                   "190.34001", "1.29e325"};
float result;

foreach (string value in values)
{
   try {
      result = Convert.ToSingle(value);
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                        value.GetType().Name, value,
                        result.GetType().Name, result);
   }
   catch (FormatException) {
      Console.WriteLine("Unable to convert '{0}' to a Single.", value);
   }
   catch (OverflowException) {
      Console.WriteLine("'{0}' is outside the range of a Single.", value);
   }
}
// The example displays the following output:
//    Converted the String value '-1,035.77219' to the Single value -1035.772.
//    Unable to convert '1AFF' to a Single.
//    Converted the String value '1e-35' to the Single value 1E-35.
//    Unable to convert '1.63f' to a Single.
//    Converted the String value '1,635,592,999,999,999,999,999,999' to the Single value 1.635593E+24.
//    Converted the String value '-17.455' to the Single value -17.455.
//    Converted the String value '190.34001' to the Single value 190.34.
//    1.29e325' is outside the range of a Single.

Comentarios

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

ToSingle(Single)

Source:

Convert.cs

Devuelve el número de punto flotante de precisión sencilla especificado; no se efectúa una conversión real.

C#

public static float ToSingle (float value);

Parámetros

value

Single

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

Devoluciones

Single

value se devuelve sin cambios.

Consulte también

• Single

ToSingle(Object)

Source:

Convert.cs

Convierte el valor del objeto especificado en un número de punto flotante de precisión sencilla.

C#

public static float ToSingle (object? value);

Parámetros

value

Object

Objeto que implementa la interfaz IConvertible o null.

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente a value, o cero si value es null.

Excepciones

FormatException

value no tiene un formato adecuado.

InvalidCastException

value no implementa la interfaz IConvertible.

O bien

No se admite la conversión.

OverflowException

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

Ejemplos

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

C#

object[] values = { true, 'a', 123, 1.764e32, "9.78", "1e-02",
                    1.67e03, "A100", "1,033.67", DateTime.Now,
                    Decimal.MaxValue };
float result;

foreach (object value in values)
{
   try {
      result = Convert.ToSingle(value);
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                        value.GetType().Name, value,
                        result.GetType().Name, result);
   }
   catch (FormatException) {
      Console.WriteLine("The {0} value {1} is not recognized as a valid Single value.",
                        value.GetType().Name, value);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the Single type.",
                        value.GetType().Name, value);
   }
   catch (InvalidCastException) {
      Console.WriteLine("Conversion of the {0} value {1} to a Single is not supported.",
                        value.GetType().Name, value);
   }
}
// The example displays the following output:
//    Converted the Boolean value 'True' to the Single value 1.
//    Conversion of the Char value a to a Single is not supported.
//    Converted the Int32 value '123' to the Single value 123.
//    Converted the Double value '1.764E+32' to the Single value 1.764E+32.
//    Converted the String value '9.78' to the Single value 9.78.
//    Converted the String value '1e-02' to the Single value 0.01.
//    Converted the Double value '1670' to the Single value 1670.
//    The String value A100 is not recognized as a valid Single value.
//    Converted the String value '1,033.67' to the Single value 1033.67.
//    Conversion of the DateTime value 11/7/2008 08:02:35 AM to a Single is not supported.
//    Converted the Decimal value '79228162514264337593543950335' to the Single value 7.922816E+28.

Comentarios

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

ToSingle(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 número de punto flotante de precisión sencilla equivalente.

C#

[System.CLSCompliant(false)]
public static float ToSingle (ushort value);

Parámetros

value

UInt16

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

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente a value.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de enteros de 16 bits sin signo en un Single valor .

C#

ushort[] numbers = { UInt16.MinValue, 121, 12345, UInt16.MaxValue };
float result;

foreach (ushort number in numbers)
{
   result = Convert.ToSingle(number);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     number.GetType().Name, number,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the UInt16 value '0' to the Single value 0.
//    Converted the UInt16 value '121' to the Single value 121.
//    Converted the UInt16 value '12345' to the Single value 12345.
//    Converted the UInt16 value '65535' to the Single value 65535.

ToSingle(Int32)

Source:

Convert.cs

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

C#

public static float ToSingle (int value);

Parámetros

value

Int32

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

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente a value.

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de enteros en un Single valor .

C#

int[] numbers = { Int32.MinValue, -1000, 0, 1000, Int32.MaxValue };
float result;

foreach (int number in numbers)
{
   result = Convert.ToSingle(number);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     number.GetType().Name, number,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the Int32 value '-2147483648' to the Single value -2.147484E+09.
//    Converted the Int32 value '-1000' to the Single value -1000.
//    Converted the Int32 value '0' to the Single value 0.
//    Converted the Int32 value '1000' to the Single value 1000.
//    Converted the Int32 value '2147483647' to the Single value 2.147484E+09.

ToSingle(Int16)

Source:

Convert.cs

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

C#

public static float ToSingle (short value);

Parámetros

value

Int16

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

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente a value.

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de enteros de 16 bits en un Single valor .

C#

short[] numbers = { Int16.MinValue, -1032, 0, 192, Int16.MaxValue };
float result;

foreach (short number in numbers)
{
   result = Convert.ToSingle(number);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     number.GetType().Name, number,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the Int16 value '-32768' to the Single value -32768.
//    Converted the Int16 value '-1032' to the Single value -1032.
//    Converted the Int16 value '0' to the Single value 0.
//    Converted the Int16 value '192' to the Single value 192.
//    Converted the Int16 value '32767' to the Single value 32767.

ToSingle(Double)

Source:

Convert.cs

Convierte el valor del número de punto flotante de precisión doble especificado en un número de punto flotante de precisión sencilla equivalente.

C#

public static float ToSingle (double value);

Parámetros

value

Double

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

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente a value.

value se redondea usando el sistema de redondeo al valor más próximo. Por ejemplo, cuando se redondea a dos decimales, el valor 2,345 se convierte en 2,34 y el valor 2,355 pasa a ser 2,36.

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de Double valores en un Single valor .

C#

double[] values = { Double.MinValue, -1.38e10, -1023.299, -12.98,
                    0, 9.113e-16, 103.919, 17834.191, Double.MaxValue };
float result;

foreach (double value in values)
{
   result = Convert.ToSingle(value);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     value.GetType().Name, value,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the Double value '-1.79769313486232E+308' to the Single value -Infinity.
//    Converted the Double value '-13800000000' to the Single value -1.38E+10.
//    Converted the Double value '-1023.299' to the Single value -1023.299.
//    Converted the Double value '-12.98' to the Single value -12.98.
//    Converted the Double value '0' to the Single value 0.
//   Converted the Double value '9.113E-16' to the Single value 9.113E-16.
//    Converted the Double value '103.919' to the Single value 103.919.
//    Converted the Double value '17834.191' to the Single value 17834.19.
//    Converted the Double value '1.79769313486232E+308' to the Single value Infinity.

Consulte también

• Double
• Round

ToSingle(Decimal)

Source:

Convert.cs

Convierte el valor del número decimal especificado en un número de punto flotante de precisión sencilla equivalente.

C#

public static float ToSingle (decimal value);

Parámetros

value

Decimal

Número decimal que se va a convertir.

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente a value.

value se redondea usando el sistema de redondeo al valor más próximo. Por ejemplo, cuando se redondea a dos decimales, el valor 2,345 se convierte en 2,34 y el valor 2,355 pasa a ser 2,36.

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de Decimal valores en un Single valor .

C#

decimal[] values = { Decimal.MinValue, -1034.23m, -12m, 0m, 147m,
                            199.55m, 9214.16m, Decimal.MaxValue };
float result;

foreach (var value in values)
{
   result = Convert.ToSingle(value);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     value.GetType().Name, value,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the Decimal value '-79228162514264337593543950335' to the Single value -7.9228163E+28.
//    Converted the Decimal value '-1034.23' to the Single value -1034.23.
//    Converted the Decimal value '-12' to the Single value -12.
//    Converted the Decimal value '0' to the Single value 0.
//    Converted the Decimal value '147' to the Single value 147.
//    Converted the Decimal value '199.55' to the Single value 199.55.
//    Converted the Decimal value '9214.16' to the Single value 9214.16.
//    Converted the Decimal value '79228162514264337593543950335' to the Single value 7.9228163E+28.

Consulte también

• Round

ToSingle(DateTime)

Source:

Convert.cs

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

C#

public static float ToSingle (DateTime value);

Parámetros

value

DateTime

Valor de fecha y hora que se va a convertir.

Devoluciones

Single

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

Excepciones

InvalidCastException

No se admite esta conversión.

ToSingle(Char)

Source:

Convert.cs

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

C#

public static float ToSingle (char value);

Parámetros

value

Char

Carácter Unicode que se va a convertir.

Devoluciones

Single

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

Excepciones

InvalidCastException

No se admite esta conversión.

Consulte también

• Char

ToSingle(Byte)

Source:

Convert.cs

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

C#

public static float ToSingle (byte value);

Parámetros

value

Byte

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

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente a value.

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de valores de bytes en un Single valor .

C#

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

foreach (byte number in numbers)
{
   result = Convert.ToSingle(number);
   Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
                     number.GetType().Name, number,
                     result.GetType().Name, result);
}
// The example displays the following output:
//       Converted the Byte value 0 to the Single value 0.
//       Converted the Byte value 10 to the Single value 10.
//       Converted the Byte value 100 to the Single value 100.
//       Converted the Byte value 255 to the Single value 255.

ToSingle(Boolean)

Source:

Convert.cs

Convierte el valor booleano especificado en un número de punto flotante de precisión sencilla equivalente.

C#

public static float ToSingle (bool value);

Parámetros

value

Boolean

Valor booleano que se va a convertir.

Devoluciones

Single

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

Ejemplos

En el ejemplo siguiente se convierten los valores true booleanos y false en Single los valores .

C#

bool[] flags = { true, false };
float result;

foreach (bool flag in flags)
{
   result = Convert.ToSingle(flag);
   Console.WriteLine("Converted {0} to {1}.", flag, result);
}
// The example displays the following output:
//       Converted True to 1.
//       Converted False to 0.

ToSingle(Int64)

Source:

Convert.cs

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

C#

public static float ToSingle (long value);

Parámetros

value

Int64

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

Devoluciones

Single

Un número de punto flotante de precisión sencilla equivalente a value.

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de enteros largos en un Single valor .

C#

long[] numbers = { Int64.MinValue, -903, 0, 172, Int64.MaxValue};
float result;

foreach (long number in numbers)
{
   result = Convert.ToSingle(number);
   Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                     number.GetType().Name, number,
                     result.GetType().Name, result);
}
// The example displays the following output:
//    Converted the Int64 value '-9223372036854775808' to the Single value -9.223372E+18.
//    Converted the Int64 value '-903' to the Single value -903.
//    Converted the Int64 value '0' to the Single value 0.
//    Converted the Int64 value '172' to the Single value 172.
//    Converted the Int64 value '9223372036854775807' to the Single value 9.223372E+18.