Int32.ToString Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne.

Surcharges

ToString()	Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne.
ToString(IFormatProvider)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide des informations de format spécifiques à la culture donnée.
ToString(String)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.
ToString(String, IFormatProvider)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide du format spécifié et des informations de format spécifiques à la culture.

ToString()

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne.

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

public override string ToString ();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Retours

String

Représentation sous forme de chaîne de la valeur de cette instance, avec un signe négatif si la valeur est négative et une séquence de chiffres allant de 0 à 9 sans zéros non significatifs.

Exemples

L’exemple suivant affiche une Int32 valeur à l’aide de la méthode par défaut ToString() . Il affiche également les représentations sous forme de chaîne de la valeur qui résulte de l’utilisation Int32 d’un certain nombre de spécificateurs de format standard. Les exemples sont affichés à l’aide des conventions de mise en forme de la culture 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

Remarques

La ToString() méthode met en forme une Int32 valeur au format par défaut (« G », ou général) à l’aide de l’objet NumberFormatInfo de la culture actuelle. Si vous souhaitez spécifier un autre format ou culture, utilisez les autres surcharges de la ToString méthode, comme suit :

Pour utiliser le format	Pour la culture	Utiliser la surcharge
Format par défaut (« G »)	Une culture spécifique	ToString(IFormatProvider)
Format spécifique	Culture par défaut (actuelle)	ToString(String)
Format spécifique	Une culture spécifique	ToString(String, IFormatProvider)

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Pour plus d’informations sur les spécificateurs de format numérique, consultez Chaînes de format numérique standard et Chaînes de format numérique personnalisées.
Pour plus d’informations sur la mise en forme, consultez Mise en forme des types.

Voir aussi

S’applique à

ToString(IFormatProvider)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide des informations de format spécifiques à la culture donnée.

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

Paramètres

provider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

Retours

String

Représentation sous forme de chaîne de la valeur de cette instance, comme indiqué par provider.

Implémente

ToString(IFormatProvider)

Exemples

L’exemple suivant affiche la représentation sous forme de chaîne d’une valeur à l’aide CultureInfo d’objets Int32 qui représentent plusieurs cultures différentes.

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

Remarques

La ToString(IFormatProvider) méthode met en forme une Int32 valeur au format par défaut (« G » ou général) à l’aide de l’objet NumberFormatInfo d’une culture spécifiée. Si vous souhaitez spécifier un autre format ou la culture actuelle, utilisez les autres surcharges de la ToString méthode, comme suit :

Pour utiliser le format	Pour la culture	Utiliser la surcharge
Format par défaut (« G »)	Culture par défaut (actuelle)	ToString()
Format spécifique	Culture par défaut (actuelle)	ToString(String)
Format spécifique	Une culture spécifique	ToString(String, IFormatProvider)

Le provider paramètre est un objet qui implémente l’interface IFormatProvider . Sa GetFormat méthode retourne un NumberFormatInfo objet qui fournit des informations spécifiques à la culture sur le format de la chaîne retournée par cette méthode. L’objet qui implémente IFormatProvider peut être l’un des suivants :

Objet CultureInfo qui représente la culture dont les règles de mise en forme doivent être utilisées.
Objet NumberFormatInfo qui contient des informations de mise en forme numérique spécifiques pour cette valeur.
Objet personnalisé qui implémente IFormatProvider et dont GetFormat la méthode retourne un NumberFormatInfo objet qui fournit des informations de mise en forme.

Si provider est null ou un NumberFormatInfo objet ne peut pas être obtenu à partir de provider, la valeur de retour est mise en forme à l’aide de l’objet NumberFormatInfo pour la culture actuelle du thread. Pour plus d’informations sur la culture actuelle du thread, consultez Thread.CurrentCulture.

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Pour plus d’informations sur les spécificateurs de format numérique, consultez Chaînes de format numérique standard et Chaînes de format numérique personnalisées.
Pour plus d’informations sur la mise en forme, consultez Mise en forme des types.

Voir aussi

S’applique à

ToString(String)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.

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

Paramètres

format: String

Chaîne de format numérique standard ou personnalisée.

Retours

String

Représentation sous forme de chaîne de la valeur de cette instance, comme indiqué par format.

Exceptions

FormatException

format n’est pas valide ou n’est pas pris en charge.

Exemples

L’exemple suivant affiche une Int32 valeur à l’aide de chacun des spécificateurs de format numérique standard pris en charge, ainsi que de deux chaînes de format numérique personnalisées. Pour convertir les valeurs numériques en chaînes, l’exemple utilise les conventions de mise en forme de la culture 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

Remarques

La ToString(String) méthode met en forme une Int32 valeur dans un format spécifié à l’aide d’un NumberFormatInfo objet qui représente les conventions de la culture actuelle. Si vous souhaitez utiliser le format par défaut (« G », ou général) ou spécifier une autre culture, utilisez les autres surcharges de la ToString méthode, comme suit :

Pour utiliser le format	Pour la culture	Utiliser la surcharge
Format par défaut (« G »)	Culture par défaut (actuelle)	ToString()
Format par défaut (« G »)	Une culture spécifique	ToString(IFormatProvider)
Format spécifique	Une culture spécifique	ToString(String, IFormatProvider)

Le format paramètre peut être n’importe quel spécificateur de format numérique standard valide, à l’exception de « R », ainsi que toute combinaison de spécificateurs de format numérique personnalisés. Si format est null ou une chaîne vide (« »), la valeur de retour de cette instance est mise en forme avec le spécificateur de format numérique général (« G »).

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Pour plus d’informations sur les spécificateurs de format numérique, consultez Chaînes de format numérique standard et Chaînes de format numérique personnalisées.
Pour plus d’informations sur la mise en forme, consultez Mise en forme des types.

La valeur de retour de cette instance est mise en forme avec pour NumberFormatInfo la culture actuelle.

Voir aussi

S’applique à

ToString(String, IFormatProvider)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide du format spécifié et des informations de format spécifiques à la culture.

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

Paramètres

format: String

Chaîne de format numérique standard ou personnalisée.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

Retours

String

Représentation sous forme de chaîne de la valeur de cette instance, telle que spécifiée par format et provider.

Implémente

ToString(String, IFormatProvider)

Exceptions

FormatException

format n’est pas valide ou n’est pas pris en charge.

Exemples

L’exemple suivant affiche une valeur positive et une valeur négative à l’aide de chacun des spécificateurs de format numérique standard pris en charge pour trois cultures différentes.

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

Remarques

La ToString(String, IFormatProvider) méthode met en forme une Int32 valeur dans un format spécifié à l’aide de l’objet NumberFormatInfo d’une culture spécifiée. Si vous souhaitez utiliser les paramètres de format ou de culture par défaut, utilisez les autres surcharges de la ToString méthode, comme suit :

Pour utiliser le format	Pour la culture	Utiliser la surcharge
Format par défaut (« G »)	Culture par défaut (actuelle)	ToString()
Format par défaut (« G »)	Une culture spécifique	ToString(IFormatProvider)
Format spécifique	Culture par défaut (actuelle)	ToString(String)

Le format paramètre peut être une chaîne de format numérique standard ou personnalisée. Toutes les chaînes de format numérique standard autres que « R » (ou « r ») sont prises en charge, comme toutes les caractères de format numérique personnalisés. Si format est null ou une chaîne vide (« »), la valeur de retour de cette instance est mise en forme avec le spécificateur de format numérique général (« G »).

Le provider paramètre est un objet qui implémente l’interface IFormatProvider . Sa GetFormat méthode retourne un NumberFormatInfo objet qui fournit des informations de format spécifiques à la culture sur le format de la chaîne retournée par cette méthode. L’objet qui implémente IFormatProvider peut être l’un des suivants :

Objet CultureInfo qui représente la culture dont les règles de mise en forme doivent être utilisées.
Objet NumberFormatInfo qui contient des informations de mise en forme numérique spécifiques pour cette valeur.
Objet personnalisé qui implémente IFormatProvider et dont GetFormat la méthode retourne un NumberFormatInfo objet qui fournit des informations de mise en forme.

Si provider est null ou un NumberFormatInfo objet ne peut pas être obtenu à partir de provider, la valeur de retour de cette instance est mise en forme avec pour NumberFormatInfo la culture actuelle.

.NET fournit une prise en charge étendue de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Pour plus d’informations sur les spécificateurs de format numérique, consultez Chaînes de format numérique standard et Chaînes de format numérique personnalisées.
Pour plus d’informations sur la mise en forme, consultez Mise en forme des types.

Voir aussi

S’applique à

Int32.ToString Méthode

Définition

Surcharges

ToString()

Retours

Exemples

Remarques

Voir aussi

S’applique à

ToString(IFormatProvider)

Paramètres

Retours

Implémente

Exemples

Remarques

Voir aussi

S’applique à

ToString(String)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

ToString(String, IFormatProvider)

Paramètres

Retours

Implémente

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Commentaires

Ressources supplémentaires