Double.TryParse Méthode

Définition

Espace de noms:: System

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assemblys:: mscorlib.dll, System.Runtime.dll

Assembly:: mscorlib.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 représentation sous forme de chaîne d’un nombre en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.

Surcharges

Nom	Description
TryParse(String, IFormatProvider, Double)	Tente d’analyser une chaîne en une valeur.
TryParse(ReadOnlySpan<Char>, Double)	Convertit la représentation d’étendue d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.
TryParse(String, Double)	Convertit la représentation sous forme de chaîne d’un nombre en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)	Tente d’analyser une étendue de caractères UTF-8 en une valeur.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)	Tente d’analyser une étendue de caractères en une valeur.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)	Tente d’analyser une étendue de caractères UTF-8 en une valeur.
TryParse(ReadOnlySpan<Byte>, Double)	Tente de convertir une étendue de caractères UTF-8 contenant la représentation sous forme de chaîne d’un nombre en nombre à virgule flottante double précision équivalent.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)	Convertit une étendue de caractères contenant la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.
TryParse(String, NumberStyles, IFormatProvider, Double)	Convertit la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.

Remarques

Dans .NET Core 3.0 et versions ultérieures, les valeurs trop volumineuses à représenter sont arrondies ou PositiveInfinity NegativeInfinity requises par la spécification IEEE 754. Dans les versions antérieures, y compris .NET Framework, l’analyse d’une valeur trop importante pour représenter a entraîné un échec.

TryParse(String, IFormatProvider, Double)

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Tente d’analyser une chaîne en une valeur.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = IParsable<double>::TryParse;

public static bool TryParse(string? s, IFormatProvider? provider, out double result);

static member TryParse : string * IFormatProvider * double -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Double) As Boolean

Paramètres

s: String

Chaîne à analyser.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s.

result: Double

Lorsque cette méthode est retournée, contient le résultat de l’analyse s réussie ou d’une valeur non définie en cas d’échec.

Retours

Boolean

true si s elle a été analysée avec succès ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Char>, Double)

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Convertit la représentation d’étendue d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] double % result);

public static bool TryParse(ReadOnlySpan<char> s, out double result);

static member TryParse : ReadOnlySpan<char> * double -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Double) As Boolean

Paramètres

s: ReadOnlySpan<Char>

Étendue de caractères qui contient la représentation sous forme de chaîne du nombre à convertir.

result: Double

Lorsque cette méthode est retournée, contient le nombre à virgule flottante double précision équivalent de la valeur numérique ou du symbole contenu dans s le paramètre, si la conversion a réussi ou zéro si la conversion a échoué. La conversion échoue si le s paramètre est null ou vide. S’il s s’agit d’un nombre valide inférieur à Double.MinValue, result est NegativeInfinity. S’il s s’agit d’un nombre valide supérieur à Double.MaxValue, result est PositiveInfinity. Ce paramètre est passé non initialisé ; toute valeur fournie result à l’origine sera remplacée.

Retours

Boolean

true si s elle a été convertie avec succès ; sinon, false.

Remarques

S’applique à

TryParse(String, Double)

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Convertit la représentation sous forme de chaîne d’un nombre en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] double % result);

public static bool TryParse(string s, out double result);

public static bool TryParse(string? s, out double result);

static member TryParse : string * double -> bool

Public Shared Function TryParse (s As String, ByRef result As Double) As Boolean

Paramètres

s: String

Chaîne contenant un nombre à convertir.

result: Double

Lorsque cette méthode est retournée, contient le nombre à virgule flottante double précision équivalent du s paramètre, si la conversion a réussi ou zéro si la conversion a échoué. La conversion échoue si le s paramètre est ou null n’est Empty pas un nombre dans un format valide. Elle échoue également sur .NET Framework si s représente un nombre inférieur à Double.MinValue ou supérieur à Double.MaxValue. Ce paramètre est passé non initialisé ; toute valeur fournie result à l’origine sera remplacée.

Retours

Boolean

true si s elle a été convertie avec succès ; sinon, false.

Exemples

L’exemple suivant utilise la TryParse(String, Double) méthode pour convertir les représentations sous forme de chaîne de valeurs numériques en Double valeurs. Il part du principe que en-US est la culture actuelle.

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "1,643.57", "$1,643.57", "-1.643e6",
                          "-168934617882109132", "123AE6",
                          null, String.Empty, "ABCDEF" };
      double number;

      foreach (var value in values) {
         if (Double.TryParse(value, out number))
            Console.WriteLine("'{0}' --> {1}", value, number);
         else
            Console.WriteLine("Unable to parse '{0}'.", value);
      }
   }
}
// The example displays the following output:
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       Unable to parse ''.
//       Unable to parse 'ABCDEF'.

open System

let values =
    [| "1,643.57"; "$1,643.57"; "-1.643e6"
       "-168934617882109132"; "123AE6"
       null; String.Empty; "ABCDEF" |]

for value in values do
    match Double.TryParse value with
    | true, number ->
        printfn $"'{value}' --> {number}"
    | _ ->
        printfn $"Unable to parse '{value}'."
// The example displays the following output:
//       '1,643.57' --> 1643.57
//       Unable to parse '$1,643.57'.
//       '-1.643e6' --> -1643000
//       '-168934617882109132' --> -1.68934617882109E+17
//       Unable to parse '123AE6'.
//       Unable to parse ''.
//       Unable to parse ''.
//       Unable to parse 'ABCDEF'.

Module Example
   Public Sub Main()
      Dim values() As String = { "1,643.57", "$1,643.57", "-1.643e6", 
                                "-168934617882109132", "123AE6", 
                                Nothing, String.Empty, "ABCDEF" }
      Dim number As Double
      
      For Each value In values
         If Double.TryParse(value, number) Then
            Console.WriteLine("'{0}' --> {1}", value, number)
         Else
            Console.WriteLine("Unable to parse '{0}'.", value)      
         End If   
      Next   
   End Sub
End Module
' The example displays the following output:
'       '1,643.57' --> 1643.57
'       Unable to parse '$1,643.57'.
'       '-1.643e6' --> -1643000
'       '-168934617882109132' --> -1.68934617882109E+17
'       Unable to parse '123AE6'.
'       Unable to parse ''.
'       Unable to parse ''.
'       Unable to parse 'ABCDEF'.

Remarques

Cette surcharge diffère de la Double.Parse(String) méthode en retournant une valeur booléenne qui indique si l’opération d’analyse a réussi au lieu de renvoyer la valeur numérique analysée. Il élimine la nécessité d’utiliser la gestion des exceptions pour tester une FormatException exception dans le cas où elle s n’est pas valide et ne peut pas être analysée avec succès.

Le s paramètre peut contenir le symbole ou NumberFormatInfo.PositiveInfinitySymbol NumberFormatInfo.NegativeInfinitySymbol le symbole de NumberFormatInfo.NaNSymbolla culture actuelle. Cette comparaison de chaînes ne respecte pas la casse dans .NET Core 3.0 et versions ultérieures, mais respecte la casse dans les versions antérieures, notamment .NET Framework. Le s paramètre peut également être une chaîne du formulaire :

[ws] [sign] [chiffres intégraux,]chiffres intégraux[.[ fractionnaires]][e[sign]exponentiel-digits][ws]

Les éléments entre crochets sont facultatifs. Le tableau suivant décrit chaque élément.

Élément	Description
Ws	Série de caractères d’espace blanc.
signe	Signe négatif ou symbole de signe positif.
chiffres intégraux	Série de caractères numériques compris entre 0 et 9 qui spécifient la partie intégrante du nombre. Les chiffres intégraux peuvent être absents s’il existe des chiffres fractionnels.
,	Symbole de séparateur de groupe spécifique à la culture.
.	Symbole décimal spécifique à la culture.
fractionnaires-chiffres	Série de caractères numériques compris entre 0 et 9 qui spécifient la partie fractionnaire du nombre.
E	Caractère majuscule ou minuscule 'e', qui indique une notation exponentielle (scientifique).
chiffres exponentiels	Série de caractères numériques compris entre 0 et 9 qui spécifient un exposant.

Pour plus d’informations sur les formats numériques, consultez Types de mise en forme.

Le s paramètre est interprété à l’aide d’une combinaison des indicateurs et NumberStyles.Float des NumberStyles.AllowThousands indicateurs. Cela signifie que l’espace blanc et les milliers de séparateurs sont autorisés, mais les symboles monétaires ne sont pas. Pour définir explicitement les éléments (tels que des symboles monétaires, des milliers de séparateurs et des espaces blancs) qui peuvent être présents dans s, utilisez la Double.TryParse(String, NumberStyles, IFormatProvider, Double) surcharge de méthode.

Le s paramètre est analysé à l’aide des informations de mise en forme dans un NumberFormatInfo objet initialisé pour la culture système actuelle. Pour plus d’informations, consultez NumberFormatInfo.CurrentInfo. Pour analyser une chaîne à l’aide des informations de mise en forme d’une autre culture spécifiée, utilisez la Double.TryParse(String, NumberStyles, IFormatProvider, Double) surcharge de méthode.

En règle générale, si vous passez la Double.TryParse méthode une chaîne créée en appelant la Double.ToString méthode, la valeur d’origine Double est retournée. Toutefois, en raison d’une perte de précision, les valeurs peuvent ne pas être égales. En outre, la tentative d’analyse de la représentation sous forme de chaîne de l’une ou Double.MinValue l’autre Double.MaxValue des tentatives d’aller-retour échoue. Sur .NET Framework, il lève un OverflowException. Sur .NET Core 3.0 et versions ultérieuresMinValue, elle retourne Double.NegativeInfinity si vous tentez d’analyser, ou Double.PositiveInfinity si vous tentez d’analyser MaxValue. L’exemple suivant fournit une illustration.

using System;

public class Example
{
   public static void Main()
   {
      string value;
      double number;

      value = Double.MinValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);

      value = Double.MaxValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);
   }
}
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

open System

[<EntryPoint>]
let main _ = 
    let value = string Double.MinValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    let value = string Double.MaxValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    0
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

Module Example
   Public Sub Main()
      Dim value As String
      Dim number As Double
      
      value = Double.MinValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
      
      value = Double.MaxValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
   End Sub
End Module
' The example displays the following output:
'    -1.79769313486232E+308 is outside the range of the Double type.
'    1.79769313486232E+308 is outside the range of the Double type.

Sur .NET Framework, s’il s est hors de portée du Double type de données, la TryParse(String, Double) méthode lève un OverflowException.

Sur .NET Core 3.0 et versions ultérieures, aucune exception n’est levée lorsqu’elle s est hors de portée du Double type de données. Dans la plupart des cas, la TryParse(String, Double) méthode calcule un résultat de Double.PositiveInfinity ou Double.NegativeInfinity. Toutefois, il existe un petit ensemble de valeurs qui sont considérées comme proches des valeurs maximales ou minimales de Double l’infini positif ou négatif. Dans ces cas, la méthode calcule un résultat de Double.MaxValue ou Double.MinValue.

Si un séparateur est rencontré dans le s paramètre pendant une opération d’analyse et que les séparateurs décimaux et de groupe sont identiques, l’opération d’analyse suppose que le séparateur est un séparateur décimal plutôt qu’un séparateur de groupe. Pour plus d’informations sur les séparateurs, consultez CurrencyDecimalSeparator, , NumberDecimalSeparator CurrencyGroupSeparatoret NumberGroupSeparator.

Voir aussi

S’applique à

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Tente d’analyser une étendue de caractères UTF-8 en une valeur.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = IUtf8SpanParsable<double>::TryParse;

public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out double result);

static member TryParse : ReadOnlySpan<byte> * IFormatProvider * double -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Double) As Boolean

Paramètres

utf8Text: ReadOnlySpan<Byte>

Étendue de caractères UTF-8 à analyser.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur utf8Text.

result: Double

Lors du retour, contient le résultat de l’analyse utf8Text réussie ou d’une valeur non définie en cas d’échec.

Retours

Boolean

true si utf8Text elle a été analysée avec succès ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Tente d’analyser une étendue de caractères en une valeur.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = ISpanParsable<double>::TryParse;

public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, out double result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * double -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Double) As Boolean

Paramètres

s: ReadOnlySpan<Char>

Étendue de caractères à analyser.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s.

result: Double

Lorsque cette méthode est retournée, contient le résultat de l’analyse sréussie ou d’une valeur non définie en cas d’échec.

Retours

Boolean

true si s elle a été analysée avec succès ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Tente d’analyser une étendue de caractères UTF-8 en une valeur.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = System::Numerics::INumberBase<double>::TryParse;

public static bool TryParse(ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out double result);

static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * double -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Double) As Boolean

Paramètres

utf8Text: ReadOnlySpan<Byte>

Étendue de caractères UTF-8 à analyser.

style: NumberStyles

Combinaison de bits de styles numériques qui peuvent être présents dans utf8Text.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur utf8Text.

result: Double

Lors du retour, contient le résultat de l’analyse utf8Text réussie ou d’une valeur non définie en cas d’échec.

Retours

Boolean

true si utf8Text elle a été analysée avec succès ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Byte>, Double)

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Tente de convertir une étendue de caractères UTF-8 contenant la représentation sous forme de chaîne d’un nombre en nombre à virgule flottante double précision équivalent.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] double % result);

public static bool TryParse(ReadOnlySpan<byte> utf8Text, out double result);

static member TryParse : ReadOnlySpan<byte> * double -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Double) As Boolean

Paramètres

utf8Text: ReadOnlySpan<Byte>

Étendue de caractères UTF-8 en lecture seule qui contient le nombre à convertir.

result: Double

Lorsque cette méthode est retournée, contient un nombre à virgule flottante double précision équivalent de la valeur numérique ou du symbole contenu si utf8Text la conversion a réussi ou zéro si la conversion a échoué. La conversion échoue si l’objet utf8Text est ou n’est Empty pas dans un format valide. Ce paramètre est passé non initialisé ; toute valeur initialement fournie dans le résultat sera remplacée.

Retours

Boolean

true si utf8Text elle a été convertie avec succès ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Convertit une étendue de caractères contenant la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = System::Numerics::INumberBase<double>::TryParse;

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result);

public static bool TryParse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out double result);

public static bool TryParse(ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider provider, out double result);

static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * double -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Double) As Boolean

Paramètres

s: ReadOnlySpan<Char>

Étendue de caractères en lecture seule qui contient le nombre à convertir.

style: NumberStyles

Combinaison de valeurs au niveau du NumberStyles bit qui indique le format autorisé de s. Une valeur classique à spécifier est Float combinée à AllowThousands.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur s.

result: Double

Lorsque cette méthode retourne et si la conversion a réussi, contient un nombre à virgule flottante double précision équivalent de la valeur numérique ou du symbole contenu dans s. Contient zéro si la conversion a échoué. La conversion échoue si le s paramètre est null, une étendue de caractères vide ou pas un nombre dans un format conforme à style. S’il s s’agit d’un nombre valide inférieur à Double.MinValue, result est NegativeInfinity. S’il s s’agit d’un nombre valide supérieur à Double.MaxValue, result est PositiveInfinity. Ce paramètre est passé non initialisé ; toute valeur fournie result à l’origine sera remplacée.

Retours

Boolean

true si s elle a été convertie avec succès ; sinon, false.

Remarques

S’applique à

TryParse(String, NumberStyles, IFormatProvider, Double)

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Source:: Double.cs

Convertit la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en nombre à virgule flottante double précision équivalent. Une valeur de retour indique si la conversion a réussi ou échoué.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result);

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] double % result) = System::Numerics::INumberBase<double>::TryParse;

public static bool TryParse(string s, System.Globalization.NumberStyles style, IFormatProvider provider, out double result);

public static bool TryParse(string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out double result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * double -> bool

Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Double) As Boolean

Paramètres

s: String

Chaîne contenant un nombre à convertir.

style: NumberStyles

Combinaison de valeurs au niveau du NumberStyles bit qui indique le format autorisé de s. Une valeur classique à spécifier est Float combinée à AllowThousands.

provider: IFormatProvider

Qui IFormatProvider fournit des informations de mise en forme propres à la culture à propos sde .

result: Double

Lorsque cette méthode est retournée, contient un nombre à virgule flottante double précision équivalent de la valeur numérique ou du symbole contenu dans s, si la conversion a réussi ou zéro si la conversion a échoué. La conversion échoue si le s paramètre est ou null n’est Empty pas dans un format conforme à style, ou s’il style n’est pas une combinaison valide de NumberStyles constantes d’énumération. Elle échoue également sur .NET Framework si s représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.MaxValue. Ce paramètre est passé non initialisé ; toute valeur fournie result à l’origine sera remplacée.

Retours

Boolean

true si s elle a été convertie avec succès ; sinon, false.

Exceptions

ArgumentException

style n’est pas une NumberStyles valeur.

-ou-

style inclut la AllowHexSpecifier valeur.

Exemples

L’exemple suivant illustre l’utilisation de la Double.TryParse(String, NumberStyles, IFormatProvider, Double) méthode pour analyser la représentation sous forme de chaîne de nombres qui ont un style particulier et qui sont mis en forme à l’aide des conventions d’une culture particulière.

string value;
NumberStyles style;
CultureInfo culture;
double number;

// Parse currency value using en-GB culture.
value = "£1,097.63";
style = NumberStyles.Number | NumberStyles.AllowCurrencySymbol;
culture = CultureInfo.CreateSpecificCulture("en-GB");
if (Double.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
//       Converted '£1,097.63' to 1097.63.

value = "1345,978";
style = NumberStyles.AllowDecimalPoint;
culture = CultureInfo.CreateSpecificCulture("fr-FR");
if (Double.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
//       Converted '1345,978' to 1345.978.

value = "1.345,978";
style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
culture = CultureInfo.CreateSpecificCulture("es-ES");
if (Double.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
//       Converted '1.345,978' to 1345.978.

value = "1 345,978";
if (Double.TryParse(value, style, culture, out number))
   Console.WriteLine("Converted '{0}' to {1}.", value, number);
else
   Console.WriteLine("Unable to convert '{0}'.", value);
// Displays:
//       Unable to convert '1 345,978'.

// Parse currency value using en-GB culture.
let value = "£1,097.63"
let style = NumberStyles.Number ||| NumberStyles.AllowCurrencySymbol
let culture = CultureInfo.CreateSpecificCulture "en-GB"
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Converted '£1,097.63' to 1097.63.

let value = "1345,978"
let style = NumberStyles.AllowDecimalPoint
let culture = CultureInfo.CreateSpecificCulture "fr-FR"
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Converted '1345,978' to 1345.978.

let value = "1.345,978"
let style = NumberStyles.AllowDecimalPoint ||| NumberStyles.AllowThousands
let culture = CultureInfo.CreateSpecificCulture("es-ES")
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Converted '1.345,978' to 1345.978.

let value = "1 345,978"
match Double.TryParse(value, style, culture) with
| true, number ->
    printfn $"Converted '{value}' to {number}."
| _ ->
    printfn $"Unable to convert '{value}'."
// Displays:
//       Unable to convert '1 345,978'.

Dim value As String
Dim style As NumberStyles
Dim culture As CultureInfo
Dim number As Double

' Parse currency value using en-GB culture.
value = "£1,097.63"
style = NumberStyles.Number Or NumberStyles.AllowCurrencySymbol
culture = CultureInfo.CreateSpecificCulture("en-GB")
If Double.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If    
' Displays: 
'       Converted '£1,097.63' to 1097.63.

value = "1345,978"
style = NumberStyles.AllowDecimalPoint
culture = CultureInfo.CreateSpecificCulture("fr-FR")
If Double.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If    
' Displays:
'       Converted '1345,978' to 1345.978.

value = "1.345,978"
style = NumberStyles.AllowDecimalPoint Or NumberStyles.AllowThousands
culture = CultureInfo.CreateSpecificCulture("es-ES")
If Double.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If    
' Displays: 
'       Converted '1.345,978' to 1345.978.

value = "1 345,978"
If Double.TryParse(value, style, culture, number) Then
   Console.WriteLine("Converted '{0}' to {1}.", value, number)
Else
   Console.WriteLine("Unable to convert '{0}'.", value)
End If    
' Displays:
'       Unable to convert '1 345,978'.

Remarques

La TryParse méthode est semblable à la Parse(String, NumberStyles, IFormatProvider) méthode, sauf que cette méthode ne lève pas d’exception si la conversion échoue. Si la conversion réussit, la valeur de retour est true et le result paramètre est défini sur le résultat de la conversion. Si la conversion échoue, la valeur de retour est false et le result paramètre est défini sur zéro. Cela élimine la nécessité d’utiliser la gestion des exceptions pour tester une FormatException exception dans le cas où elle s n’est pas valide et ne peut pas être analysée avec succès.

Le style paramètre définit le format autorisé du s paramètre pour que l’opération d’analyse réussisse. Il doit s’agir d’une combinaison d’indicateurs de bits de l’énumération NumberStyles . Les membres suivants NumberStyles ne sont pas pris en charge :

Le s paramètre peut contenir NumberFormatInfo.PositiveInfinitySymbol, NumberFormatInfo.NegativeInfinitySymbolou NumberFormatInfo.NaNSymbol symbole pour la culture indiquée par provider. Cette comparaison de chaînes ne respecte pas la casse dans .NET Core 3.0 et versions ultérieures, mais respecte la casse dans les versions antérieures, notamment .NET Framework. En outre, selon la valeur de style, le s paramètre peut inclure les éléments suivants :

[ws] [$] [sign] [intégral-digits,]integral-digits[.fractional-digits][e[sign]exponentiel-digits][ws]

Les éléments entre crochets ([ et ]) sont facultatifs. Le tableau suivant décrit chaque élément.

Élément	Description
Ws	Espace blanc facultatif. L’espace blanc peut apparaître au début de `s` si `style` l’indicateur NumberStyles.AllowLeadingWhite est inclus. Elle peut apparaître à la fin de `s` si `style` elle inclut l’indicateur NumberStyles.AllowTrailingWhite .
$	Symbole monétaire propre à la culture. Sa position dans la chaîne est définie par la NumberFormatInfo.CurrencyNegativePattern ou NumberFormatInfo.CurrencyPositivePattern les propriétés de l’objet NumberFormatInfo retourné par la IFormatProvider.GetFormat méthode du `provider` paramètre. Le symbole monétaire peut apparaître si `sstyle` l’indicateur NumberStyles.AllowCurrencySymbol est inclus.
signe	Signe facultatif. Le signe peut apparaître au début de `s` si `style` inclut l’indicateur NumberStyles.AllowLeadingSign , et il peut apparaître à la fin de `s` si `style` inclut l’indicateur NumberStyles.AllowTrailingSign . Les parenthèses peuvent être utilisées pour `s` indiquer une valeur négative si `style` l’indicateur NumberStyles.AllowParentheses est inclus.
chiffres intégraux	Une série de chiffres allant de 0 à 9 qui spécifient la partie intégrale du nombre. Les chiffres intégraux peuvent être absents s’il existe des chiffres fractionnels.
,	Symbole de séparateur de milliers spécifique à la culture. Le symbole de séparateur de milliers de la culture actuelle peut apparaître s’il `sstyle` inclut l’indicateur NumberStyles.AllowThousands .
.	Symbole décimal spécifique à la culture. Le symbole décimal de la culture actuelle peut apparaître s’il `sstyle` inclut l’indicateur NumberStyles.AllowDecimalPoint .
fractionnaires-chiffres	Série de chiffres compris entre 0 et 9 qui spécifient la partie fractionnaire du nombre. Les chiffres fractionnels peuvent apparaître si `sstyle` l’indicateur NumberStyles.AllowDecimalPoint est inclus.
e	Caractère e ou E, qui indique qu’il `s` peut représenter un nombre à l’aide d’une notation exponentielle. Le `s` paramètre peut représenter un nombre en notation exponentielle si le style inclut l’indicateur NumberStyles.AllowExponent .
chiffres exponentiels	Série de chiffres compris entre 0 et 9 qui spécifient un exposant.

Note

Les caractères s NUL (U+0000) de fin sont ignorés par l’opération d’analyse, quelle que soit la valeur de l’argument style .

Une chaîne avec des chiffres uniquement (qui correspond au NumberStyles.None style) analyse toujours correctement si elle se trouve dans la plage du Double type. Les éléments de contrôle membres restants System.Globalization.NumberStyles qui peuvent être, mais qui ne sont pas requis pour être présents dans la chaîne d’entrée. Le tableau suivant indique comment les indicateurs individuels NumberStyles affectent les éléments qui peuvent être présents dans s.

Valeur NumberStyles	Éléments autorisés en plus des chiffres
None	Élément à chiffres intégral uniquement.
AllowDecimalPoint	Éléments . et fractionnaires .
AllowExponent	Le `s` paramètre peut également utiliser la notation exponentielle. Cet indicateur prend en charge les valeurs sous forme dechiffres intégral E exponentiels ; d’autres indicateurs sont nécessaires pour analyser correctement les chaînes en notation exponentielle avec des éléments tels que des signes positifs ou négatifs et des symboles décimaux.
AllowLeadingWhite	Élément ws au début de `s`.
AllowTrailingWhite	Élément ws à la fin de `s`.
AllowLeadingSign	Élément de signe au début de `s`.
AllowTrailingSign	Élément de signe à la fin de `s`.
AllowParentheses	Élément de connexion sous la forme de parenthèses englobant la valeur numérique.
AllowThousands	Élément ,
AllowCurrencySymbol	Élément $ .
Currency	Tout. Le `s` paramètre ne peut pas représenter un nombre hexadécimal ou un nombre en notation exponentielle.
Float	Élément ws au début ou à la fin de `s`, signe au début de `s`, et le symbole . Le `s` paramètre peut également utiliser la notation exponentielle.
Number	Éléments `ws`, `sign`séparateur de milliers (,) et virgule décimale (.).
Any	Tous les styles, sauf `s` ne peuvent pas représenter un nombre hexadécimal.

Le provider paramètre est une IFormatProvider implémentation, telle qu’un ou NumberFormatInfo un CultureInfo objet. Le provider paramètre fournit des informations spécifiques à la culture utilisées dans l’analyse. S’il provider n’est null pas possible d’obtenir un NumberFormatInfo objet, les informations de format de la culture actuelle sont utilisées.

La conversion échoue si le s paramètre est null ou non une valeur numérique, que le provider paramètre ne génère pas d’objet NumberFormatInfo ou que le style paramètre n’est pas une combinaison d’indicateurs de bits de l’énumération NumberStyles .

using System;

public class Example
{
   public static void Main()
   {
      string value;
      double number;

      value = Double.MinValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);

      value = Double.MaxValue.ToString();
      if (Double.TryParse(value, out number))
         Console.WriteLine(number);
      else
         Console.WriteLine("{0} is outside the range of a Double.",
                           value);
   }
}
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

open System

[<EntryPoint>]
let main _ = 
    let value = string Double.MinValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    let value = string Double.MaxValue
    match Double.TryParse value with
    | true, number ->
        printfn $"{number}"
    | _ ->
        printfn $"{value} is outside the range of a Double."

    0
// The example displays the following output:
//    -1.79769313486232E+308 is outside the range of the Double type.
//    1.79769313486232E+308 is outside the range of the Double type.

Module Example
   Public Sub Main()
      Dim value As String
      Dim number As Double
      
      value = Double.MinValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
      
      value = Double.MaxValue.ToString()
      If Double.TryParse(value, number) Then
         Console.WriteLine(number)
      Else
         Console.WriteLine("{0} is outside the range of a Double.", _
                           value)
      End If
   End Sub
End Module
' The example displays the following output:
'    -1.79769313486232E+308 is outside the range of the Double type.
'    1.79769313486232E+308 is outside the range of the Double type.

Sur .NET Framework, s’il s est hors de portée du Double type de données, la Double.TryParse(String, NumberStyles, IFormatProvider, Double) méthode lève un OverflowException.

Sur .NET Core 3.0 et versions ultérieures, aucune exception n’est levée lorsqu’elle s est hors de portée du Double type de données. Dans la plupart des cas, la Double.TryParse(String, NumberStyles, IFormatProvider, Double) méthode calcule un résultat de Double.PositiveInfinity ou Double.NegativeInfinity. Toutefois, il existe un petit ensemble de valeurs qui sont considérées comme proches des valeurs maximales ou minimales de Double l’infini positif ou négatif. Dans ces cas, la méthode calcule un résultat de Double.MaxValue ou Double.MinValue.

Si un séparateur est rencontré dans le s paramètre pendant une opération d’analyse, et que les séparateurs de valeurs décimales ou de nombres applicables sont identiques, l’opération d’analyse suppose que le séparateur est un séparateur décimal plutôt qu’un séparateur de groupe. Pour plus d’informations sur les séparateurs, consultez CurrencyDecimalSeparator, , NumberDecimalSeparator CurrencyGroupSeparatoret NumberGroupSeparator.

Voir aussi

S’applique à

Commentaires

Cette page a-t-elle été utile ?

Partager via

Double.TryParse Méthode

Définition

Surcharges

Remarques

TryParse(String, IFormatProvider, Double)

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Char>, Double)

Paramètres

Retours

Remarques

S’applique à

TryParse(String, Double)

Paramètres

Retours

Exemples

Remarques

Voir aussi

S’applique à

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Byte>, Double)

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)

Paramètres

Retours

Remarques

S’applique à

TryParse(String, NumberStyles, IFormatProvider, Double)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Commentaires