Single.ToString Méthode

Définition

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

Surcharges

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(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(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()

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

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.

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.

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

Exemples

L’exemple suivant affiche une Single valeur à l’aide de chacun des spécificateurs de format numériques standard pris en charge pour plusieurs cultures différentes.

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 %
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 %

Remarques

La ToString(String, IFormatProvider) méthode met en forme une Single valeur dans un format spécifié d’une culture spécifiée. Si vous souhaitez utiliser des 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)
Un format spécifique Culture par défaut (actuelle) ToString(String)

La valeur de retour peut être PositiveInfinitySymbol ,, NegativeInfinitySymbol NaNSymbol ou la représentation sous forme de chaîne de la valeur de l’instance actuelle, comme spécifié par format .

Le format paramètre peut être tout spécificateur de format numérique standard valide, à l’exception de D et X, ainsi que toute combinaison de spécificateurs de format numériques 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 offre une prise en charge complète de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Le provider paramètre est une IFormatProvider implémentation dont la GetFormat méthode retourne un NumberFormatInfo objet. En général, provider est un CultureInfo objet ou un NumberFormatInfo objet. Le provider paramètre fournit des informations spécifiques à la culture utilisées dans la mise en forme. Si provider est null , la valeur de retour est mise en forme avec l' NumberFormatInfo objet pour la culture actuelle.

Par défaut, la valeur de retour contient uniquement 7 chiffres de précision, bien qu’un maximum de 9 chiffres soit géré en interne. Si la valeur de cette instance est supérieure à 7 chiffres, ToString retourne PositiveInfinitySymbol ou à NegativeInfinitySymbol la place du nombre attendu. Si vous avez besoin de plus de précision, spécifiez format avec la spécification de format « G9 », qui retourne toujours 9 chiffres de précision, ou « R », qui retourne 7 chiffres si le nombre peut être représenté avec cette précision ou à 9 chiffres si le nombre ne peut être représenté qu’avec une précision maximale.

Voir aussi

S’applique à

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é.

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.

Retours

String

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

Exceptions

format n'est pas valide.

Exemples

L’exemple suivant définit une valeur numérique et la met en forme en tant que valeur monétaire en utilisant la chaîne de format numérique standard "C" et une valeur numérique à trois décimales à l’aide de la chaîne de format numérique standard "N". Les chaînes de résultat sont mises en forme à l’aide des conventions de la culture en-US. Pour plus d’informations sur les chaînes de format numériques, consultez chaînes de format numériques standard et chaînes de format numériques personnalisées.

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
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

L’exemple suivant affiche plusieurs Single valeurs qui utilisent chacun des spécificateurs de format numériques standard pris en charge, ainsi que deux chaînes de format numériques personnalisées. L’une de ces chaînes de format personnalisées illustre comment remplir une Single valeur avec des zéros non significatifs. Lors de la conversion des valeurs numériques en chaînes, l’exemple utilise les conventions de mise en forme de la culture 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
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

Remarques

La ToString(String) méthode met en forme une Single valeur dans un format spécifié à l’aide des 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)
Un format spécifique Une culture spécifique ToString(String, IFormatProvider)

La valeur de retour peut être PositiveInfinitySymbol ,, NegativeInfinitySymbol NaNSymbol ou la représentation sous forme de chaîne de la valeur de l’instance actuelle, comme spécifié par format .

Le format paramètre peut être tout spécificateur de format numérique standard valide, à l’exception de D et X, ainsi que toute combinaison de spécificateurs de format numériques personnalisés. Si le format est null ou une chaîne vide, la valeur de retour est mise en forme avec le spécificateur de format numérique général ("G").

.NET offre une prise en charge complète de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Par défaut, la valeur de retour contient uniquement 7 chiffres de précision, bien qu’un maximum de 9 chiffres soit géré en interne. Si la valeur de cette instance est supérieure à 7 chiffres, ToString(String) retourne PositiveInfinitySymbol ou à NegativeInfinitySymbol la place du nombre attendu. Si vous avez besoin de plus de précision, spécifiez format avec la spécification de format « G9 », qui retourne toujours 9 chiffres de précision, ou « R », qui retourne 7 chiffres si le nombre peut être représenté avec cette précision ou à 9 chiffres si le nombre ne peut être représenté qu’avec une précision maximale.

Voir aussi

S’applique à

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.

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

Exemples

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

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
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

Remarques

La ToString(IFormatProvider) méthode met en forme une Single valeur dans le format par défaut (« G » ou général) 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()
Un format spécifique Culture par défaut (actuelle) ToString(String)
Un format spécifique Une culture spécifique ToString(String, IFormatProvider)

La valeur de retour peut être PositiveInfinitySymbol , NegativeInfinitySymbol , NaNSymbol ou une chaîne de la forme :

[signe] chiffres intégraux [. [chiffres fractionnaires]] [e [signe] chiffres exponentiels]

Les éléments facultatifs sont encadrés par des crochets ([et]). Les éléments contenant le terme « chiffres » se composent d’une série de caractères numériques compris entre 0 et 9. Le tableau suivant répertorie chaque élément.

Élément Description
sign Signe négatif ou symbole de signe positif.
chiffres intégraux Série de chiffres spécifiant la partie entière du nombre. Les chiffres intégraux peuvent être absents s’il existe des chiffres fractionnaires.
'.' Symbole de virgule décimale propre à la culture.
chiffres fractionnaires Série de chiffres spécifiant la partie fractionnaire du nombre.
'e' Caractère minuscule « e », indiquant une notation exponentielle (scientifique).
chiffres exponentiels Série de chiffres spécifiant un exposant.

Voici quelques exemples de la valeur de retour : « 100 », « -123 456 789 », « 123,45 e + 6 », « 500 », « 3,1416 », « 600 », « -0,123 » et « -Infinity ».

.NET offre une prise en charge complète de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Le provider paramètre est une IFormatProvider implémentation dont la GetFormat méthode retourne un NumberFormatInfo objet. En général, provider est un CultureInfo objet ou un NumberFormatInfo objet. Le provider paramètre fournit des informations spécifiques à la culture utilisées dans la mise en forme. Si provider est null , la valeur de retour est mise en forme à l’aide NumberFormatInfo des données de la culture actuelle.

Pour convertir une Single valeur en sa représentation sous forme de chaîne à l’aide d’une culture spécifiée et d’une chaîne de format spécifique, appelez la Single.ToString(String, IFormatProvider) méthode.

Voir aussi

S’applique à

ToString()

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.

Exemples

L’exemple suivant utilise la méthode par défaut Single.ToString pour afficher les représentations sous forme de chaîne d’un certain nombre de Single valeurs.

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());
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())

L’exemple de code suivant illustre l’utilisation de la Parse(String) méthode avec la ToString() méthode.

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);
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

Remarques

La ToString() méthode met en forme une Single valeur dans le format par défaut (« G » ou général) de la culture actuelle. Si vous souhaitez spécifier un autre format ou 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 ») Une culture spécifique ToString(IFormatProvider)
Un format spécifique Culture par défaut (actuelle) ToString(String)
Un format spécifique Une culture spécifique ToString(String, IFormatProvider)

La valeur de retour peut être PositiveInfinitySymbol , NegativeInfinitySymbol , NaNSymbol ou une chaîne de la forme :

[signe] chiffres intégraux [. [chiffres fractionnaires]] [e [signe] chiffres exponentiels]

Les éléments facultatifs sont encadrés par des crochets ([et]). Les éléments qui contiennent le terme « chiffres » se composent d’une série de caractères numériques compris entre 0 et 9. Le tableau suivant répertorie chaque élément :

Élément Description
sign Signe négatif ou symbole de signe positif.
chiffres intégraux Série de chiffres spécifiant la partie entière du nombre. Les chiffres intégraux peuvent être absents s’il existe des chiffres fractionnaires.
'.' Symbole de virgule décimale propre à la culture.
chiffres fractionnaires Série de chiffres spécifiant la partie fractionnaire du nombre.
'e' Caractère minuscule « e », indiquant une notation exponentielle (scientifique).
chiffres exponentiels Série de chiffres spécifiant un exposant.

Voici quelques exemples de la valeur de retour : « 100 », « -123 456 789 », « 123,45 e + 6 », « 500 », « 3,1416 », « 600 », « -0,123 » et « -Infinity ».

.NET offre une prise en charge complète de la mise en forme, qui est décrite plus en détail dans les rubriques de mise en forme suivantes :

Voir aussi

S’applique à