Int32.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 su representación de cadena equivalente.

Sobrecargas

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

ToString(IFormatProvider)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante 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 de cadena del valor de esta instancia, tal como se especifica en provider.

Implementaciones

ToString(IFormatProvider)

Ejemplos

En el ejemplo siguiente se muestra la representación de cadena de un valor de Int32 mediante CultureInfo objetos que representan varias referencias culturales diferentes.

using namespace System;
using namespace System::Globalization;

void main()
{
    int value = -16325;
    // 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")));
}
// The example displays the following output:
//       -16325
//       -16325
//       -16325

int value = -16325;
// 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
//       -16325
//       -16325

let value = -16325
// 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
//       -16325
//       -16325

Dim value As Integer = -16325
' 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
'       -16325
'       -16325

Comentarios

El método ToString(IFormatProvider) da formato a un valor Int32 en el formato predeterminado ("G" o general) mediante el objeto NumberFormatInfo de una referencia cultural especificada. Si desea especificar un formato diferente o la referencia cultural actual, use las demás sobrecargas del método ToString, 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 parámetro provider es un objeto que implementa la interfaz IFormatProvider. Su método GetFormat devuelve un objeto NumberFormatInfo que proporciona información específica de la referencia cultural sobre el formato de la cadena devuelta por este método. El objeto que implementa IFormatProvider puede ser cualquiera de los siguientes:

Objeto CultureInfo que representa la referencia cultural cuyas reglas de formato se van a usar.
Objeto NumberFormatInfo que contiene información de formato numérico específica para este valor.
Objeto personalizado que implementa IFormatProvider y cuyo método GetFormat devuelve un objeto NumberFormatInfo que proporciona información de formato.

Si provider es null o no se puede obtener un objeto NumberFormatInfo de provider, el valor devuelto se da formato mediante el objeto NumberFormatInfo para la referencia cultural actual del subproceso. Para obtener información sobre la referencia cultural actual del subproceso, vea Thread.CurrentCulture.

.NET proporciona compatibilidad amplia con 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()

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Convierte el valor numérico de esta instancia en su 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, que consta de un signo negativo si el valor es negativo y una secuencia de dígitos que van de 0 a 9 sin ceros iniciales.

Ejemplos

En el ejemplo siguiente se muestra un valor de Int32 mediante el método ToString() predeterminado. También muestra las representaciones de cadena del valor de Int32 que se derivan del uso de una serie de especificadores de formato estándar. Los ejemplos se muestran mediante las convenciones de formato de la referencia cultural de en-US.

using namespace System;

void main()
{
    int value = -16325;
    // Display value using default ToString method.
    Console::WriteLine(value.ToString());             
    // Display value using some standard format specifiers.
    Console::WriteLine(value.ToString("G"));         
    Console::WriteLine(value.ToString("C"));         
    Console::WriteLine(value.ToString("D"));         
    Console::WriteLine(value.ToString("F"));         
    Console::WriteLine(value.ToString("N"));         
    Console::WriteLine(value.ToString("X"));              
}
// The example displays the following output:
//     -16325
//     -16325
//     ($16,325.00)
//     -16325
//     -16325.00
//     -16,325.00
//     FFFFC03B

int value = -16325;
// Display value using default ToString method.
Console.WriteLine(value.ToString());            // Displays -16325
// Display value using some standard format specifiers.
Console.WriteLine(value.ToString("G"));         // Displays -16325
Console.WriteLine(value.ToString("C"));         // Displays ($16,325.00)
Console.WriteLine(value.ToString("D"));         // Displays -16325
Console.WriteLine(value.ToString("F"));         // Displays -16325.00
Console.WriteLine(value.ToString("N"));         // Displays -16,325.00
Console.WriteLine(value.ToString("X"));         // Displays FFFFC03B

let value = -16325
// Display value using default ToString method.
printfn $"{value.ToString()}"                            // Displays -16325
// Display value using some standard format specifiers.
printfn $"""{value.ToString "G"}"""         // Displays -16325
printfn $"""{value.ToString "C"}"""         // Displays ($16,325.00)
printfn $"""{value.ToString "D"}"""         // Displays -16325
printfn $"""{value.ToString "F"}"""         // Displays -16325.00
printfn $"""{value.ToString "N"}"""         // Displays -16,325.00
printfn $"""{value.ToString "X"}"""        // Displays FFFFC03B

Dim value As Integer = -16325
' Display value using default ToString method.
Console.WriteLine(value.ToString())            ' Displays -16325
' Display value using some standard format specifiers.
Console.WriteLine(value.ToString("G"))         ' Displays -16325
Console.WriteLine(value.ToString("C"))         ' Displays ($16,325.00)
Console.WriteLine(value.ToString("D"))         ' Displays -16325
Console.WriteLine(value.ToString("F"))         ' Displays -16325.00
Console.WriteLine(value.ToString("N"))         ' Displays -16,325.00
Console.WriteLine(value.ToString("X"))         ' Displays FFFFC03B

Comentarios

El método ToString() da formato a un valor Int32 en el formato predeterminado ("G" o general) mediante el objeto NumberFormatInfo de la referencia cultural actual. Si desea especificar otro formato o referencia cultural, use las demás sobrecargas del método ToString, 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)

.NET proporciona compatibilidad amplia con 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(String)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante 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 estándar o personalizado.

Devoluciones

String

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

Excepciones

FormatException

format no es válido o no se admite.

Ejemplos

En el ejemplo siguiente se muestra un valor de Int32 mediante cada uno de los especificadores de formato numérico estándar admitidos, junto con dos cadenas de formato numérico personalizado. Al convertir los valores numéricos en cadenas, en el ejemplo se usan las convenciones de formato de la referencia cultural de en-US.

using namespace System;

void main()
{
    int value = -16325;
    String^ specifier;
    
    // Use standard numeric format specifiers.
    specifier = "G";
    Console::WriteLine("{0}: {1}", specifier, value.ToString(specifier));

    specifier = "C";
    Console::WriteLine("{0}: {1}", specifier, value.ToString(specifier));

    specifier = "D8";
    Console::WriteLine("{0}: {1}", specifier, value.ToString(specifier));

    specifier = "E4";
    Console::WriteLine("{0}: {1}", specifier, value.ToString(specifier));

    specifier = "e3";
    Console::WriteLine("{0}: {1}", specifier, value.ToString(specifier));

    specifier = "F";
    Console::WriteLine("{0}: {1}", specifier, value.ToString(specifier));

    specifier = "N";
    Console::WriteLine("{0}: {1}", specifier, value.ToString(specifier));

    specifier = "P";
    Console::WriteLine("{0}: {1}", specifier, (value/100000).ToString(specifier));

    specifier = "X";
    Console::WriteLine("{0}: {1}", specifier, value.ToString(specifier));
    
    // Use custom numeric format specifiers.
    specifier = "0,0.000";
    Console::WriteLine("{0}: {1}", specifier, value.ToString(specifier));

    specifier = "#,#.00#;(#,#.00#)";
    Console::WriteLine("{0}: {1}", specifier, (value*-1).ToString(specifier));
}   
// The example displays the following output:
//     G: -16325
//     C: ($16,325.00)
//     D8: -00016325
//     E4: -1.6325E+004
//     e3: -1.633e+004
//     F: -16325.00
//     N: -16,325.00
//     P: 0.00 %
//     X: FFFFC03B
//     0,0.000: -16,325.000
//     #,#.00#;(#,#.00#): 16,325.00

int value = -16325;
string specifier;

// Use standard numeric format specifier.
specifier = "G";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    G: -16325
specifier = "C";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    C: ($16,325.00)
specifier = "D8";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    D8: -00016325
specifier = "E4";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    E4: -1.6325E+004
specifier = "e3";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    e3: -1.633e+004
specifier = "F";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    F: -16325.00
specifier = "N";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    N: -16,325.00
specifier = "P";
Console.WriteLine("{0}: {1}", specifier, (value/100000).ToString(specifier));
// Displays:    P: -16.33 %
specifier = "X";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    X: FFFFC03B

// Use custom numeric format specifiers.
specifier = "0,0.000";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    0,0.000: -16,325.000
specifier = "#,#.00#;(#,#.00#)";
Console.WriteLine("{0}: {1}", specifier, (value*-1).ToString(specifier));
// Displays:    #,#.00#;(#,#.00#): 16,325.00

let value = -16325

// Use standard numeric format specifier.
let specifier = "G"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    G: -16325
let specifier = "C"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    C: ($16,325.00)
let specifier = "D8"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    D8: -00016325
let specifier = "E4"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    E4: -1.6325E+004
let specifier = "e3"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    e3: -1.633e+004
let specifier = "F"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    F: -16325.00
let specifier = "N"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    N: -16,325.00
let specifier = "P"
printfn $"{specifier}: {(value / 100000).ToString specifier}"
// Displays:    P: -16.33 %
let specifier = "X"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    X: FFFFC03B

// Use custom numeric format specifiers.
let specifier = "0,0.000"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    0,0.000: -16,325.000
let specifier = "#,#.00#;(#,#.00#)"
printfn $"{specifier}: {(value * -1).ToString specifier}"
// Displays:    #,#.00#;(#,#.00#): 16,325.00

Dim value As Integer = -16325
Dim specifier As String

' Use standard numeric format specifier.
specifier = "G"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    G: -16325
specifier = "C"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    C: ($16,325.00)
specifier = "D8"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    D8: -00016325
specifier = "E4"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    E4: -1.6325E+004
specifier = "e3"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    e3: -1.633e+004
specifier = "F"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    F: -16325.00
specifier = "N"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    N: -16,325.00
specifier = "P"
Console.WriteLine("{0}: {1}", specifier, (value/100000).ToString(specifier))
' Displays:    P: -16.33 %
specifier = "X"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    X: FFFFC03B 

' Use custom numeric format specifiers.
specifier = "0,0.000"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    0,0.000: -16,325.000
specifier = "#,#.00#;(#,#.00#)"
Console.WriteLine("{0}: {1}", specifier, (value*-1).ToString(specifier))
' Displays:    #,#.00#;(#,#.00#): 16,325.00

Comentarios

El método ToString(String) da formato a un valor Int32 en un formato especificado mediante un objeto NumberFormatInfo que representa 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 método ToString, 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 parámetro format puede ser cualquier especificador de formato numérico estándar válido, excepto "R", así como cualquier combinación de especificadores de formato numérico personalizado. Si format es null o una cadena vacía (""), el valor devuelto de esta instancia tiene formato con el especificador de formato numérico general ("G").

.NET proporciona compatibilidad amplia con 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 valor devuelto de esta instancia tiene el formato NumberFormatInfo para la referencia cultural actual.

Consulte también

Se aplica a

ToString(String, IFormatProvider)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

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

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 estándar o personalizado.

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 como se especifica en format y provider.

Implementaciones

ToString(String, IFormatProvider)

Excepciones

FormatException

format no es válido o no se admite.

Ejemplos

En el ejemplo siguiente se muestra un valor positivo y negativo mediante cada uno de los especificadores de formato numérico estándar admitidos para tres referencias culturales diferentes.

using namespace System;
using namespace System::Globalization;

void main()
{
    // Define cultures whose formatting conventions are to be used.
    array<CultureInfo^>^ cultures = { CultureInfo::CreateSpecificCulture("en-US"), 
                                      CultureInfo::CreateSpecificCulture("fr-FR"), 
                                      CultureInfo::CreateSpecificCulture("es-ES") };
    int positiveNumber = 1679;
    int negativeNumber = -3045;
    array<String^>^ specifiers = {"G", "C", "D8", "E2", "F", "N", "P", "X8"}; 
    
    for each (String^ specifier in specifiers)
    {
       for each (CultureInfo^ culture in cultures)
       {
          // Display values with "G" format specifier.
          Console::WriteLine("{0} format using {1} culture: {2, 16} {3, 16}",  
                            specifier, culture->Name, 
                            positiveNumber.ToString(specifier, culture), 
                            negativeNumber.ToString(specifier, culture));
       }
       Console::WriteLine();
    }
}
// The example displays the following output:
//       G format using en-US culture:             1679            -3045
//       G format using fr-FR culture:             1679            -3045
//       G format using es-ES culture:             1679            -3045
//       
//       C format using en-US culture:        $1,679.00      ($3,045.00)
//       C format using fr-FR culture:       1 679,00 €      -3 045,00 €
//       C format using es-ES culture:       1.679,00 €      -3.045,00 €
//       
//       D8 format using en-US culture:         00001679        -00003045
//       D8 format using fr-FR culture:         00001679        -00003045
//       D8 format using es-ES culture:         00001679        -00003045
//       
//       E2 format using en-US culture:        1.68E+003       -3.05E+003
//       E2 format using fr-FR culture:        1,68E+003       -3,05E+003
//       E2 format using es-ES culture:        1,68E+003       -3,05E+003
//       
//       F format using en-US culture:          1679.00         -3045.00
//       F format using fr-FR culture:          1679,00         -3045,00
//       F format using es-ES culture:          1679,00         -3045,00
//       
//       N format using en-US culture:         1,679.00        -3,045.00
//       N format using fr-FR culture:         1 679,00        -3 045,00
//       N format using es-ES culture:         1.679,00        -3.045,00
//       
//       P format using en-US culture:     167,900.00 %    -304,500.00 %
//       P format using fr-FR culture:     167 900,00 %    -304 500,00 %
//       P format using es-ES culture:     167.900,00 %    -304.500,00 %
//       
//       X8 format using en-US culture:         0000068F         FFFFF41B
//       X8 format using fr-FR culture:         0000068F         FFFFF41B
//       X8 format using es-ES culture:         0000068F         FFFFF41B

// Define cultures whose formatting conventions are to be used.
CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"),
                          CultureInfo.CreateSpecificCulture("fr-FR"),
                          CultureInfo.CreateSpecificCulture("es-ES") };
int positiveNumber = 1679;
int negativeNumber = -3045;
string[] specifiers = {"G", "C", "D8", "E2", "F", "N", "P", "X8"};

foreach (string specifier in specifiers)
{
   foreach (CultureInfo culture in cultures)
   {
      // Display values with "G" format specifier.
      Console.WriteLine("{0} format using {1} culture: {2, 16} {3, 16}",
                        specifier, culture.Name,
                        positiveNumber.ToString(specifier, culture),
                        negativeNumber.ToString(specifier, culture));
   }
   Console.WriteLine();
}
// The example displays the following output:
//       G format using en-US culture:             1679            -3045
//       G format using fr-FR culture:             1679            -3045
//       G format using es-ES culture:             1679            -3045
//
//       C format using en-US culture:        $1,679.00      ($3,045.00)
//       C format using fr-FR culture:       1 679,00 €      -3 045,00 €
//       C format using es-ES culture:       1.679,00 €      -3.045,00 €
//
//       D8 format using en-US culture:         00001679        -00003045
//       D8 format using fr-FR culture:         00001679        -00003045
//       D8 format using es-ES culture:         00001679        -00003045
//
//       E2 format using en-US culture:        1.68E+003       -3.05E+003
//       E2 format using fr-FR culture:        1,68E+003       -3,05E+003
//       E2 format using es-ES culture:        1,68E+003       -3,05E+003
//
//       F format using en-US culture:          1679.00         -3045.00
//       F format using fr-FR culture:          1679,00         -3045,00
//       F format using es-ES culture:          1679,00         -3045,00
//
//       N format using en-US culture:         1,679.00        -3,045.00
//       N format using fr-FR culture:         1 679,00        -3 045,00
//       N format using es-ES culture:         1.679,00        -3.045,00
//
//       P format using en-US culture:     167,900.00 %    -304,500.00 %
//       P format using fr-FR culture:     167 900,00 %    -304 500,00 %
//       P format using es-ES culture:     167.900,00 %    -304.500,00 %
//
//       X8 format using en-US culture:         0000068F         FFFFF41B
//       X8 format using fr-FR culture:         0000068F         FFFFF41B
//       X8 format using es-ES culture:         0000068F         FFFFF41B

// Define cultures whose formatting conventions are to be used.
let cultures = 
    [ CultureInfo.CreateSpecificCulture "en-US"
      CultureInfo.CreateSpecificCulture "fr-FR"
      CultureInfo.CreateSpecificCulture "es-ES" ]
let positiveNumber = 1679
let negativeNumber = -3045
let specifiers = [ "G"; "C"; "D8"; "E2"; "F"; "N"; "P"; "X8" ]

for specifier in specifiers do
    for culture in cultures do
        // Display values format specifiers.
        printfn $"{specifier} format using {culture.Name} culture: {positiveNumber.ToString(specifier, culture), 16} {negativeNumber.ToString(specifier, culture), 16}"
    printfn ""

// The example displays the following output:
//       G format using en-US culture:             1679            -3045
//       G format using fr-FR culture:             1679            -3045
//       G format using es-ES culture:             1679            -3045
//
//       C format using en-US culture:        $1,679.00      ($3,045.00)
//       C format using fr-FR culture:       1 679,00 €      -3 045,00 €
//       C format using es-ES culture:       1.679,00 €      -3.045,00 €
//
//       D8 format using en-US culture:         00001679        -00003045
//       D8 format using fr-FR culture:         00001679        -00003045
//       D8 format using es-ES culture:         00001679        -00003045
//
//       E2 format using en-US culture:        1.68E+003       -3.05E+003
//       E2 format using fr-FR culture:        1,68E+003       -3,05E+003
//       E2 format using es-ES culture:        1,68E+003       -3,05E+003
//
//       F format using en-US culture:          1679.00         -3045.00
//       F format using fr-FR culture:          1679,00         -3045,00
//       F format using es-ES culture:          1679,00         -3045,00
//
//       N format using en-US culture:         1,679.00        -3,045.00
//       N format using fr-FR culture:         1 679,00        -3 045,00
//       N format using es-ES culture:         1.679,00        -3.045,00
//
//       P format using en-US culture:     167,900.00 %    -304,500.00 %
//       P format using fr-FR culture:     167 900,00 %    -304 500,00 %
//       P format using es-ES culture:     167.900,00 %    -304.500,00 %
//
//       X8 format using en-US culture:         0000068F         FFFFF41B
//       X8 format using fr-FR culture:         0000068F         FFFFF41B
//       X8 format using es-ES culture:         0000068F         FFFFF41B

' Define cultures whose formatting conventions are to be used.
Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                 CultureInfo.CreateSpecificCulture("fr-FR"), _
                                 CultureInfo.CreateSpecificCulture("es-ES") }
Dim positiveNumber As Integer = 1679
Dim negativeNumber As Integer = -3045
Dim specifiers() As String = {"G", "C", "D8", "E2", "F", "N", "P", "X8"} 

For Each specifier As String In specifiers
   For Each culture As CultureInfo In Cultures
      ' Display values with "G" format specifier.
      Console.WriteLine("{0} format using {1} culture: {2, 16} {3, 16}", _ 
                        specifier, culture.Name, _
                        positiveNumber.ToString(specifier, culture), _
                        negativeNumber.ToString(specifier, culture))

   Next
   Console.WriteLine()
Next
' The example displays the following output to the console:
'       G format using en-US culture:             1679            -3045
'       G format using fr-FR culture:             1679            -3045
'       G format using es-ES culture:             1679            -3045
'       
'       C format using en-US culture:        $1,679.00      ($3,045.00)
'       C format using fr-FR culture:       1 679,00 €      -3 045,00 €
'       C format using es-ES culture:       1.679,00 €      -3.045,00 €
'       
'       D8 format using en-US culture:         00001679        -00003045
'       D8 format using fr-FR culture:         00001679        -00003045
'       D8 format using es-ES culture:         00001679        -00003045
'       
'       E2 format using en-US culture:        1.68E+003       -3.05E+003
'       E2 format using fr-FR culture:        1,68E+003       -3,05E+003
'       E2 format using es-ES culture:        1,68E+003       -3,05E+003
'       
'       F format using en-US culture:          1679.00         -3045.00
'       F format using fr-FR culture:          1679,00         -3045,00
'       F format using es-ES culture:          1679,00         -3045,00
'       
'       N format using en-US culture:         1,679.00        -3,045.00
'       N format using fr-FR culture:         1 679,00        -3 045,00
'       N format using es-ES culture:         1.679,00        -3.045,00
'       
'       P format using en-US culture:     167,900.00 %    -304,500.00 %
'       P format using fr-FR culture:     167 900,00 %    -304 500,00 %
'       P format using es-ES culture:     167.900,00 %    -304.500,00 %
'       
'       X8 format using en-US culture:         0000068F         FFFFF41B
'       X8 format using fr-FR culture:         0000068F         FFFFF41B
'       X8 format using es-ES culture:         0000068F         FFFFF41B

Comentarios

El método ToString(String, IFormatProvider) da formato a un valor Int32 en un formato especificado mediante el objeto NumberFormatInfo de una referencia cultural especificada. Si desea usar la configuración predeterminada de formato o referencia cultural, use las demás sobrecargas del método ToString, 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 parámetro format puede ser una cadena de formato numérico estándar o personalizada. Se admiten todas las cadenas de formato numérico estándar que no sean "R" (o "r"), como todos los caracteres de formato numérico personalizado. Si format es null o una cadena vacía (""), el valor devuelto de esta instancia tiene el formato del especificador de formato numérico general ("G").

El parámetro provider es un objeto que implementa la interfaz IFormatProvider. Su método GetFormat devuelve un objeto NumberFormatInfo que proporciona información de formato específica de la referencia cultural sobre el formato de la cadena devuelta por este método. El objeto que implementa IFormatProvider puede ser cualquiera de los siguientes:

Objeto CultureInfo que representa la referencia cultural cuyas reglas de formato se van a usar.
Objeto NumberFormatInfo que contiene información de formato numérico específica para este valor.
Objeto personalizado que implementa IFormatProvider y cuyo método GetFormat devuelve un objeto NumberFormatInfo que proporciona información de formato.

Si provider es null o no se puede obtener un objeto NumberFormatInfo de provider, el valor devuelto de esta instancia tiene el formato NumberFormatInfo para la referencia cultural actual.

.NET proporciona compatibilidad amplia con 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

Compartir vía

Int32.ToString Método

Definición

Sobrecargas

ToString(IFormatProvider)

Parámetros

Devoluciones

Implementaciones

Ejemplos

Comentarios

Consulte también

Se aplica a

ToString()

Devoluciones

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

Excepciones

Ejemplos

Comentarios

Consulte también

Se aplica a

Recursos adicionales