Single.ToString Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Convierte el valor numérico de esta instancia en la representación de cadena equivalente.

Sobrecargas

ToString()	Convierte el valor numérico de esta instancia en la representación de cadena equivalente.
ToString(IFormatProvider)	Convierte el valor numérico de esta instancia en la representación de cadena equivalente usando la información de formato específica de la referencia cultural especificada.
ToString(String)	Convierte el valor numérico de esta instancia en la representación de cadena equivalente usando el formato especificado.
ToString(String, IFormatProvider)	Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato y la información de formato específica de la referencia cultural que se especificaran.

ToString()

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Convierte el valor numérico de esta instancia en la representación de cadena equivalente.

public:
 override System::String ^ ToString();

public override string ToString ();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Devoluciones

String

Representación de cadena del valor de esta instancia.

Ejemplos

En el ejemplo siguiente se usa el método predeterminado Single.ToString para mostrar las representaciones de cadena de un número de Single valores.

float number;

number = 1.6E20F;
// Displays 1.6E+20.
Console.WriteLine(number.ToString());

number = 1.6E2F;
// Displays 160.
Console.WriteLine(number.ToString());

number = -3.541F;
// Displays -3.541.
Console.WriteLine(number.ToString());

number = -1502345222199E-07F;
// Displays -150234.5222199.
Console.WriteLine(number.ToString());

number = -15023452221990199574E-09F;
// Displays -15023452221.9902.
Console.WriteLine(number.ToString());

number = .60344F;
// Displays 0.60344.
Console.WriteLine(number.ToString());

number = .000000001F;
// Displays 1E-09.
Console.WriteLine(number.ToString());

let number = 1.6E20F
// Displays 1.6E+20.
printfn $"{number.ToString()}"

let number = 1.6E2F
// Displays 160.
printfn $"{number.ToString()}"

let number = -3.541F
// Displays -3.541.
printfn $"{number.ToString()}"

let number = -1502345222199E-07F
// Displays -150234.5222199.
printfn $"{number.ToString()}"

let number = -15023452221990199574E-09F
// Displays -15023452221.9902.
printfn $"{number.ToString()}"

let number = 0.60344F
// Displays 0.60344.
printfn $"{number.ToString()}"

let number = 0.000000001F
// Displays 1E-09.
printfn $"{number.ToString()}"

Dim number As Single

number = 1.6E20
' Displays 1.6E+20.      
Console.WriteLine(number.ToString())

number = 1.6E2
' Displays 160.
Console.WriteLine(number.ToString())

number = -3.541
' Displays -3.541.
Console.WriteLine(number.ToString())

number = -1502345222199E-07
' Displays -150234.5222199.
Console.WriteLine(number.ToString())

number = -15023452221990199574E-09
' Displays -15023452221.9902.
Console.WriteLine(number.ToString())

number = .60344
' Displays 0.60344.
Console.WriteLine(number.ToString())

number = .000000001
' Displays 1E-09.
Console.WriteLine(number.ToString())

En el ejemplo de código siguiente se muestra el uso del Parse(String) método junto con el ToString() método .

bool done = false;
String^ inp;
do
{
   Console::Write( "Enter a real number: " );
   inp = Console::ReadLine();
   try
   {
      s = Single::Parse( inp );
      Console::WriteLine( "You entered {0}.", s );
      done = true;
   }
   catch ( FormatException^ ) 
   {
      Console::WriteLine( "You did not enter a number." );
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "An exception occurred while parsing your response: {0}", e );
   }
}
while (  !done );

bool done = false;
string inp;
do
{
    Console.Write("Enter a real number: ");
    inp = Console.ReadLine();
    try
    {
        s = Single.Parse(inp);
        Console.WriteLine("You entered {0}.", s.ToString());
        done = true;
    }
    catch (FormatException)
    {
        Console.WriteLine("You did not enter a number.");
    }
    catch (Exception e)
    {
        Console.WriteLine("An exception occurred while parsing your response: {0}", e.ToString());
    }
} while (!done);

let mutable finished = false
while not finished do
    printf "Enter a real number: "
    let inp = stdin.ReadLine()
    try
        let s = Single.Parse inp
        printfn $"You entered {s}."
        finished <- true
    with 
    | :? FormatException ->
        printfn "You did not enter a number."
    | e ->
        printfn "An exception occurred while parsing your response: {e}"

Dim Done As Boolean = False
Dim Inp As String
Do

    Console.Write("Enter a real number: ")
    Inp = Console.ReadLine()
    Try
        S = Single.Parse(Inp)
        Console.WriteLine("You entered " + S.ToString() + ".")
        Done = True
    Catch E As FormatException
        Console.WriteLine("You did not enter a number.")
    Catch E As Exception
        Console.WriteLine("An exception occurred while parsing your response: " + E.ToString())
    End Try
Loop While Not Done

Comentarios

El ToString() método da formato a un Single valor en el formato predeterminado ("G" o general) de la referencia cultural actual. Si desea especificar otro formato o referencia cultural, use las demás sobrecargas del ToString método , como se indica a continuación:

Para usar el formato	Para referencia cultural	Uso de la sobrecarga
Formato predeterminado ("G")	Una referencia cultural específica	ToString(IFormatProvider)
Un formato específico	Referencia cultural predeterminada (actual)	ToString(String)
Un formato específico	Una referencia cultural específica	ToString(String, IFormatProvider)

El valor devuelto puede ser PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolo una cadena del formulario:

[sign]integral-digits[.[ fractional-digits]][e[sign]exponential-digits]

Los elementos opcionales están enmarcados entre corchetes ([ y ]). Los elementos que contienen el término "dígitos" constan de una serie de caracteres numéricos comprendidos entre 0 y 9. En la tabla siguiente se muestra cada elemento:

Elemento	Descripción
sign	Un signo negativo o un símbolo de signo positivo.
dígitos enteros	Serie de dígitos que especifican la parte integral del número. Los dígitos enteros pueden estar ausentes si hay fracciones de dígitos.
'.'	Símbolo de separador decimal específico de la referencia cultural.
fracciones de dígitos	Serie de dígitos que especifican la parte fraccionarcional del número.
'e'	Carácter en minúscula "e", que indica la notación exponencial (científica).
dígitos exponenciales	Serie de dígitos que especifican un exponente.

Algunos ejemplos del valor devuelto son "100", "-123,456,789", "123.45e+6", "500", "3.1416", "600", "-0.123" y "-Infinity".

.NET proporciona una amplia compatibilidad con el formato, que se describe con más detalle en los temas de formato siguientes:

Para obtener más información sobre los especificadores de formato numérico, vea Cadenas de formato numérico estándar y Cadenas de formato numérico personalizado.
Para obtener más información sobre el formato, vea Tipos de formato.

Consulte también

Se aplica a

ToString(IFormatProvider)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Convierte el valor numérico de esta instancia en la representación de cadena equivalente usando la información de formato específica de la referencia cultural especificada.

public:
 virtual System::String ^ ToString(IFormatProvider ^ provider);

public:
 System::String ^ ToString(IFormatProvider ^ provider);

public string ToString (IFormatProvider provider);

public string ToString (IFormatProvider? provider);

override this.ToString : IFormatProvider -> string

Public Function ToString (provider As IFormatProvider) As String

Parámetros

provider: IFormatProvider

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

Devoluciones

String

Representación en forma de cadena del valor de esta instancia, tal y como especifica provider.

Implementaciones

ToString(IFormatProvider)

Ejemplos

En el ejemplo siguiente se muestra la representación de cadena de dos Single valores mediante CultureInfo objetos que representan varias referencias culturales diferentes.

float value;

value = -16325.62015F;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));

value = 16034.125E21F;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));
// This example displays the following output to the console:
//       -16325.62015
//       -16325.62015
//       -16325,62015
//       1.6034125E+25
//       1.6034125E+25
//       1,6034125E+25

let value = -16325.62015F
// Display value using the invariant culture.
printfn $"{value.ToString CultureInfo.InvariantCulture}"
// Display value using the en-GB culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "en-GB")}"""
// Display value using the de-DE culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "de-DE")}"""

let value = 16034.125E21F
// Display value using the invariant culture.
printfn $"{value.ToString CultureInfo.InvariantCulture}"
// Display value using the en-GB culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "en-GB")}"""
// Display value using the de-DE culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "de-DE")}"""
// This example displays the following output to the console:
//       -16325.62015
//       -16325.62015
//       -16325,62015
//       1.6034125E+25
//       1.6034125E+25
//       1,6034125E+25

Dim value As Single 

value = -16325.62015
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))

value = 16034.125E21
' Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture))
' Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")))
' Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")))
' This example displays the following output to the console:
'       -16325.62015
'       -16325.62015
'       -16325,62015
'       1.6034125E+25
'       1.6034125E+25
'       1,6034125E+25

Comentarios

El ToString(IFormatProvider) método da formato a un Single valor en el formato predeterminado ("G" o general) de una referencia cultural especificada. Si desea especificar un formato diferente o la referencia cultural actual, use las demás sobrecargas del ToString método , como se indica a continuación:

Para usar el formato	Para referencia cultural	Uso de la sobrecarga
Formato predeterminado ("G")	Referencia cultural predeterminada (actual)	ToString()
Un formato específico	Referencia cultural predeterminada (actual)	ToString(String)
Un formato específico	Una referencia cultural específica	ToString(String, IFormatProvider)

El valor devuelto puede ser PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolo una cadena del formulario:

[sign]integral-digits[.[ fractional-digits]][e[sign]exponential-digits]

Elemento	Descripción
sign	Un signo negativo o un símbolo de signo positivo.
dígitos enteros	Serie de dígitos que especifican la parte integral del número. Los dígitos enteros pueden estar ausentes si hay fracciones de dígitos.
'.'	Símbolo de separador decimal específico de la referencia cultural.
fracciones de dígitos	Serie de dígitos que especifican la parte fraccionarcional del número.
'e'	Carácter en minúscula "e", que indica la notación exponencial (científica).
dígitos exponenciales	Serie de dígitos que especifican un exponente.

Algunos ejemplos del valor devuelto son "100", "-123,456,789", "123.45e+6", "500", "3.1416", "600", "-0.123" y "-Infinity".

.NET proporciona una amplia compatibilidad con el formato, que se describe con más detalle en los temas de formato siguientes:

Para obtener más información sobre los especificadores de formato numérico, vea Cadenas de formato numérico estándar y Cadenas de formato numérico personalizado.
Para obtener más información sobre el formato, vea Tipos de formato.

El provider parámetro es una IFormatProvider implementación cuyo GetFormat método devuelve un NumberFormatInfo objeto . Normalmente, provider es un CultureInfo objeto o un NumberFormatInfo objeto . El provider parámetro proporciona información específica de la referencia cultural utilizada en el formato. Si provider es null, el valor devuelto se da formato mediante los NumberFormatInfo datos de la referencia cultural actual.

Para convertir un Single valor en su representación de cadena mediante una referencia cultural especificada y una cadena de formato específica, llame al Single.ToString(String, IFormatProvider) método .

Consulte también

Se aplica a

ToString(String)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Convierte el valor numérico de esta instancia en la representación de cadena equivalente usando el formato especificado.

public:
 System::String ^ ToString(System::String ^ format);

public string ToString (string format);

public string ToString (string? format);

override this.ToString : string -> string

Public Function ToString (format As String) As String

Parámetros

format: String

Cadena de formato numérico.

Devoluciones

String

Representación en forma de cadena del valor de esta instancia, tal y como especifica format.

Excepciones

FormatException

format no es válido.

Ejemplos

En el ejemplo siguiente se define un valor numérico y se le da formato como un valor de moneda mediante la cadena de formato numérico estándar "C" y como un valor numérico a tres posiciones decimales mediante la cadena de formato numérico estándar "N". Las cadenas de resultado tienen formato mediante las convenciones de la referencia cultural en-US. Para obtener más información sobre las cadenas de formato numérico, vea Cadenas de formato numérico estándar y Cadenas de formato numérico personalizado.

using System;

public class Example
{
   public static void Main()
   {
      Double number = 1764.3789;
      
      // Format as a currency value.
      Console.WriteLine(number.ToString("C"));
      
      // Format as a numeric value with 3 decimal places.
      Console.WriteLine(number.ToString("N3"));
   }
}
// The example displays the following output:
//       $1,764.38
//       1,764.379

let number = 1764.3789

// Format as a currency value.
printfn $"""{number.ToString "C"}"""

// Format as a numeric value with 3 decimal places.
printfn $"""{number.ToString "N3"}"""
// The example displays the following output:
//       $1,764.38
//       1,764.379

Module Example
   Public Sub Main()
      Dim number As Single = 1764.3789
      
      ' Format as a currency value.
      Console.WriteLine(number.ToString("C"))
      
      ' Format as a numeric value with 3 decimal places.
      Console.WriteLine(number.ToString("N3"))
   End Sub
End Module
' The example displays the following output:
'       $1,764.38
'       1,764.379

En el ejemplo siguiente se muestran varios Single valores que usan cada uno de los especificadores de formato numérico estándar admitidos junto con dos cadenas de formato numérico personalizado. Una de esas cadenas de formato personalizado ilustra cómo rellenar un Single valor con ceros a la izquierda. Al convertir los valores numéricos en cadenas, en el ejemplo se usan las convenciones de formato de la referencia cultural en-US.

float[] numbers= { 1054.32179F, -195489100.8377F, 1.0437E21F, 
                   -1.0573e-05F };
string[] specifiers = { "C", "E", "e", "F", "G", "N", "P", 
                        "R", "#,000.000", "0.###E-000",
                        "000,000,000,000.00###" };

foreach (float number in numbers)
{
   Console.WriteLine("Formatting of {0}:", number);
   foreach (string specifier in specifiers)
      Console.WriteLine("   {0,5}: {1}", 
                        specifier, number.ToString(specifier));

   Console.WriteLine();
}
// The example displays the following output to the console:
//       Formatting of 1054.32179:
//              C: $1,054.32
//              E: 1.054322E+003
//              e: 1.054322e+003
//              F: 1054.32
//              G: 1054.32179
//              N: 1,054.32
//              P: 105,432.18 %
//              R: 1054.32179
//          #,000.000: 1,054.322
//          0.###E-000: 1.054E003
//          000,000,000,000.00###: 000,000,001,054.322
//       
//       Formatting of -195489100.8377:
//              C: ($195,489,100.84)
//              E: -1.954891E+008
//              e: -1.954891e+008
//              F: -195489100.84
//              G: -195489100.8377
//              N: -195,489,100.84
//              P: -19,548,910,083.77 %
//              R: -195489100.8377
//          #,000.000: -195,489,100.838
//          0.###E-000: -1.955E008
//          000,000,000,000.00###: -000,195,489,100.00
//       
//       Formatting of 1.0437E+21:
//              C: $1,043,700,000,000,000,000,000.00
//              E: 1.043700E+021
//              e: 1.043700e+021
//              F: 1043700000000000000000.00
//              G: 1.0437E+21
//              N: 1,043,700,000,000,000,000,000.00
//              P: 104,370,000,000,000,000,000,000.00 %
//              R: 1.0437E+21
//          #,000.000: 1,043,700,000,000,000,000,000.000
//          0.###E-000: 1.044E021
//          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//       
//       Formatting of -1.0573E-05:
//              C: $0.00
//              E: -1.057300E-005
//              e: -1.057300e-005
//              F: 0.00
//              G: -1.0573E-05
//              N: 0.00
//              P: 0.00 %
//              R: -1.0573E-05
//          #,000.000: 000.000
//          0.###E-000: -1.057E-005
//          000,000,000,000.00###: -000,000,000,000.00001

let numbers = 
    [| 1054.32179F; -195489100.8377F; 1.0437E21F; -1.0573e-05F |]
let specifiers = 
    [| "C"; "E"; "e"; "F"; "G"; "N"; "P" 
       "R"; "#,000.000"; "0.###E-000"
       "000,000,000,000.00###" |]

for number in numbers do
    printfn $"Formatting of {number}:"
    for specifier in specifiers do
        printfn $"   {specifier,5}: {number.ToString specifier}" 
    printfn ""
// The example displays the following output to the console:
//       Formatting of 1054.32179:
//              C: $1,054.32
//              E: 1.054322E+003
//              e: 1.054322e+003
//              F: 1054.32
//              G: 1054.32179
//              N: 1,054.32
//              P: 105,432.18 %
//              R: 1054.32179
//          #,000.000: 1,054.322
//          0.###E-000: 1.054E003
//          000,000,000,000.00###: 000,000,001,054.322
//       
//       Formatting of -195489100.8377:
//              C: ($195,489,100.84)
//              E: -1.954891E+008
//              e: -1.954891e+008
//              F: -195489100.84
//              G: -195489100.8377
//              N: -195,489,100.84
//              P: -19,548,910,083.77 %
//              R: -195489100.8377
//          #,000.000: -195,489,100.838
//          0.###E-000: -1.955E008
//          000,000,000,000.00###: -000,195,489,100.00
//       
//       Formatting of 1.0437E+21:
//              C: $1,043,700,000,000,000,000,000.00
//              E: 1.043700E+021
//              e: 1.043700e+021
//              F: 1043700000000000000000.00
//              G: 1.0437E+21
//              N: 1,043,700,000,000,000,000,000.00
//              P: 104,370,000,000,000,000,000,000.00 %
//              R: 1.0437E+21
//          #,000.000: 1,043,700,000,000,000,000,000.000
//          0.###E-000: 1.044E021
//          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//       
//       Formatting of -1.0573E-05:
//              C: $0.00
//              E: -1.057300E-005
//              e: -1.057300e-005
//              F: 0.00
//              G: -1.0573E-05
//              N: 0.00
//              P: 0.00 %
//              R: -1.0573E-05
//          #,000.000: 000.000
//          0.###E-000: -1.057E-005
//          000,000,000,000.00###: -000,000,000,000.00001

Dim numbers() As Single = {1054.32179, -195489100.8377, 1.0437E21, _
                           -1.0573e-05}
Dim specifiers() As String = { "C", "E", "e", "F", "G", "N", "P", _
                               "R", "#,000.000", "0.###E-000", _
                               "000,000,000,000.00###"}
For Each number As Single In numbers
   Console.WriteLine("Formatting of {0}:", number)
   For Each specifier As String In specifiers
      Console.WriteLine("   {0,5}: {1}", _
                        specifier, number.ToString(specifier))
   Next
   Console.WriteLine()
Next
' The example displays the following output to the console:
'       Formatting of 1054.32179:
'              C: $1,054.32
'              E: 1.054322E+003
'              e: 1.054322e+003
'              F: 1054.32
'              G: 1054.32179
'              N: 1,054.32
'              P: 105,432.18 %
'              R: 1054.32179
'          #,000.000: 1,054.322
'          0.###E-000: 1.054E003
'          000,000,000,000.00###: 000,000,001,054.322      
'       
'       Formatting of -195489100.8377:
'              C: ($195,489,100.84)
'              E: -1.954891E+008
'              e: -1.954891e+008
'              F: -195489100.84
'              G: -195489100.8377
'              N: -195,489,100.84
'              P: -19,548,910,083.77 %
'              R: -195489100.8377
'          #,000.000: -195,489,100.838
'          0.###E-000: -1.955E008
'          000,000,000,000.00###: -000,195,489,100.00
'       
'       Formatting of 1.0437E+21:
'              C: $1,043,700,000,000,000,000,000.00
'              E: 1.043700E+021
'              e: 1.043700e+021
'              F: 1043700000000000000000.00
'              G: 1.0437E+21
'              N: 1,043,700,000,000,000,000,000.00
'              P: 104,370,000,000,000,000,000,000.00 %
'              R: 1.0437E+21
'          #,000.000: 1,043,700,000,000,000,000,000.000
'          0.###E-000: 1.044E021
'          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
'       
'       Formatting of -1.0573E-05:
'              C: $0.00
'              E: -1.057300E-005
'              e: -1.057300e-005
'              F: 0.00
'              G: -1.0573E-05
'              N: 0.00
'              P: 0.00 %
'              R: -1.0573E-05
'          #,000.000: 000.000
'          0.###E-000: -1.057E-005
'          000,000,000,000.00###: -000,000,000,000.00001

Comentarios

El ToString(String) método da formato a un Single valor en un formato especificado mediante las convenciones de la referencia cultural actual. Si desea usar el formato predeterminado ("G" o general) o especificar una referencia cultural diferente, use las demás sobrecargas del ToString método, como se indica a continuación:

Para usar el formato	Para referencia cultural	Uso de la sobrecarga
Formato predeterminado ("G")	Referencia cultural predeterminada (actual)	ToString()
Formato predeterminado ("G")	Una referencia cultural específica	ToString(IFormatProvider)
Un formato específico	Una referencia cultural específica	ToString(String, IFormatProvider)

El valor devuelto puede ser PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolo la representación de cadena del valor de la instancia actual, según lo especificado por format.

El format parámetro puede ser cualquier especificador de formato numérico estándar válido, excepto D y X, así como cualquier combinación de especificadores de formato numérico personalizado. Si el formato es null o una cadena vacía, el valor devuelto tiene el formato del especificador de formato numérico general ("G").

.NET proporciona una amplia compatibilidad con el formato, que se describe con más detalle en los temas de formato siguientes:

Para obtener más información sobre los especificadores de formato numérico, vea Cadenas de formato numérico estándar y Cadenas de formato numérico personalizado.
Para obtener más información sobre el formato, vea Tipos de formato.

De forma predeterminada, el valor devuelto solo contiene 7 dígitos de precisión, aunque se mantiene internamente un máximo de 9 dígitos. Si el valor de esta instancia tiene más de 7 dígitos, ToString(String) devuelve PositiveInfinitySymbol o NegativeInfinitySymbol en lugar del número esperado. Si necesita más precisión, especifique format con la especificación de formato "G9", que siempre devuelve 9 dígitos de precisión, o "R", que devuelve 7 dígitos si el número se puede representar con esa precisión o 9 dígitos si el número solo se puede representar con precisión máxima.

Consulte también

Se aplica a

ToString(String, IFormatProvider)

Source:: Single.cs

Source:: Single.cs

Source:: Single.cs

Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato y la información de formato específica de la referencia cultural que se especificaran.

public:
 virtual System::String ^ ToString(System::String ^ format, IFormatProvider ^ provider);

public string ToString (string format, IFormatProvider provider);

public string ToString (string? format, IFormatProvider? provider);

override this.ToString : string * IFormatProvider -> string

Public Function ToString (format As String, provider As IFormatProvider) As String

Parámetros

format: String

Cadena de formato numérico.

provider: IFormatProvider

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

Devoluciones

String

Representación de cadena del valor de esta instancia, tal y como especifican format y provider.

Implementaciones

ToString(String, IFormatProvider)

Ejemplos

En el ejemplo siguiente se muestra un Single valor que usa cada uno de los especificadores de formato numérico estándar admitidos para varias referencias culturales diferentes.

float value = 16325.62901F;
string specifier;
CultureInfo culture;

// Use standard numeric format specifiers.
specifier = "G";
culture = CultureInfo.CreateSpecificCulture("eu-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture));
// Displays:    16325.62901

specifier = "C";
culture = CultureInfo.CreateSpecificCulture("en-US");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    £16,325.63

specifier = "E04";
culture = CultureInfo.CreateSpecificCulture("sv-SE");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 1,6326E+004   
 culture = CultureInfo.CreateSpecificCulture("en-NZ");
 Console.WriteLine(value.ToString(specifier, culture));
// Displays:    1.6326E+004   

specifier = "F";
culture = CultureInfo.CreateSpecificCulture("fr-FR");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325.63

specifier = "N";
culture = CultureInfo.CreateSpecificCulture("es-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16 325,63

specifier = "P";
culture = CultureInfo.InvariantCulture;
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays:    163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG");
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays:    163.256 %

let value = 16325.62901F

// Use standard numeric format specifiers.
let specifier = "G"
let culture = CultureInfo.CreateSpecificCulture "eu-ES"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16325,62901
printfn $"{value.ToString(specifier, CultureInfo.InvariantCulture)}"
// Displays:    16325.62901

let specifier = "C"
let culture = CultureInfo.CreateSpecificCulture "en-US"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    $16,325.63
let culture = CultureInfo.CreateSpecificCulture "en-GB"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    £16,325.63

let specifier = "E04"
let culture = CultureInfo.CreateSpecificCulture "sv-SE"
printfn $"{value.ToString(specifier, culture)}"
// Displays: 1,6326E+004   
let culture = CultureInfo.CreateSpecificCulture "en-NZ"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    1.6326E+004   

let specifier = "F"
let culture = CultureInfo.CreateSpecificCulture "fr-FR"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16325,63
let culture = CultureInfo.CreateSpecificCulture "en-CA"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16325.63

let specifier = "N"
let culture = CultureInfo.CreateSpecificCulture "es-ES"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16.325,63
let culture = CultureInfo.CreateSpecificCulture "fr-CA"
printfn $"{value.ToString(specifier, culture)}"
// Displays:    16 325,63

let specifier = "P"
let culture = CultureInfo.InvariantCulture
printfn $"{(value / 10000f).ToString(specifier, culture)}"
// Displays:    163.26 %
let culture = CultureInfo.CreateSpecificCulture "ar-EG"
printfn $"{(value / 10000f).ToString(specifier, culture)}"
// Displays:    163.256 %

Dim value As Single = 16325.62901
Dim specifier As String
Dim culture As CultureInfo

' Use standard numeric format specifiers.
specifier = "G"
culture = CultureInfo.CreateSpecificCulture("eu-ES")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture))
' Displays:    16325.62901

specifier = "C"
culture = CultureInfo.CreateSpecificCulture("en-US")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    £16,325.63

specifier = "E04"
culture = CultureInfo.CreateSpecificCulture("sv-SE")
Console.WriteLine(value.ToString(specifier, culture))
' Displays: 1,6326E+004   
 culture = CultureInfo.CreateSpecificCulture("en-NZ")
 Console.WriteLine(value.ToString(specifier, culture))
' Displays:    1.6326E+004   

specifier = "F"
culture = CultureInfo.CreateSpecificCulture("fr-FR")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16325.63

specifier = "N"
culture = CultureInfo.CreateSpecificCulture("es-ES")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA")
Console.WriteLine(value.ToString(specifier, culture))
' Displays:    16 325,63

specifier = "P"
culture = CultureInfo.InvariantCulture
Console.WriteLine((value/10000).ToString(specifier, culture))
' Displays:    163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG")
Console.WriteLine((value/10000).ToString(specifier, culture))
' Displays:    163.256 %

Comentarios

El ToString(String, IFormatProvider) método da formato a un Single valor en un formato especificado de una referencia cultural especificada. Si desea usar la configuración predeterminada de formato o referencia cultural, use las demás sobrecargas del ToString método , como se indica a continuación:

Para usar el formato	Para referencia cultural	Uso de la sobrecarga
Formato predeterminado ("G")	Referencia cultural predeterminada (actual)	ToString()
Formato predeterminado ("G")	Una referencia cultural específica	ToString(IFormatProvider)
Un formato específico	Referencia cultural predeterminada (actual)	ToString(String)

El valor devuelto puede ser PositiveInfinitySymbol, NegativeInfinitySymbol, NaNSymbolo la representación de cadena del valor de la instancia actual, según lo especificado por format.

El format parámetro puede ser cualquier especificador de formato numérico estándar válido, excepto D y X, así como cualquier combinación de especificadores de formato numérico personalizado. Si format es null o una cadena vacía, se da formato al valor devuelto de esta instancia con el especificador de formato numérico general ("G").

.NET proporciona una amplia compatibilidad con el formato, que se describe con más detalle en los temas de formato siguientes:

Para obtener más información sobre los especificadores de formato numérico, vea Cadenas de formato numérico estándar y Cadenas de formato numérico personalizado.
Para obtener más información sobre el formato, vea Tipos de formato.

El provider parámetro es una IFormatProvider implementación cuyo GetFormat método devuelve un NumberFormatInfo objeto . Normalmente, provider es un CultureInfo objeto o un NumberFormatInfo objeto . El provider parámetro proporciona información específica de la referencia cultural utilizada en el formato. Si provider es null, el valor devuelto tiene el formato del NumberFormatInfo objeto para la referencia cultural actual.

De forma predeterminada, el valor devuelto solo contiene 7 dígitos de precisión, aunque se mantiene internamente un máximo de 9 dígitos. Si el valor de esta instancia tiene más de 7 dígitos, ToString devuelve PositiveInfinitySymbol o NegativeInfinitySymbol en lugar del número esperado. Si necesita más precisión, especifique format con la especificación de formato "G9", que siempre devuelve 9 dígitos de precisión, o "R", que devuelve 7 dígitos si el número se puede representar con esa precisión o 9 dígitos si el número solo se puede representar con precisión máxima.

Consulte también

Se aplica a

Compartir a través de

Single.ToString Método

Definición

Sobrecargas

ToString()

Devoluciones

Ejemplos

Comentarios

Consulte también

Se aplica a

ToString(IFormatProvider)

Parámetros

Devoluciones

Implementaciones

Ejemplos

Comentarios

Consulte también

Se aplica a

ToString(String)

Parámetros

Devoluciones

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

ToString(String, IFormatProvider)

Parámetros

Devoluciones

Implementaciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Recursos adicionales