Double.TryParse Méthode
Définition
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 a échoué.
Surcharges
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double) |
Tente d’analyser une étendue de caractères dans une valeur. |
TryParse(ReadOnlySpan<Char>, Double) |
Convertit la représentation sous forme d’étendue d'un nombre dans un style et un format propre à 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 a é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 a échoué. |
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double) |
Tente d’analyser une étendue de caractères UTF-8 en une valeur. |
TryParse(String, IFormatProvider, Double) |
Tente d’analyser une chaîne 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 propre à 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 a échoué. |
TryParse(String, NumberStyles, IFormatProvider, Double) |
Convertit la représentation sous forme de chaîne d'un nombre dans un style et un format propre à 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 a échoué. |
Remarques
Dans .NET Core 3.0 et versions ultérieures, les valeurs trop grandes pour être représentées sont arrondies à PositiveInfinity ou NegativeInfinity comme requis par la spécification IEEE 754. Dans les versions antérieures, y compris .NET Framework, l’analyse d’une valeur trop grande pour être représentée a entraîné un échec.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Double)
- Source:
- Double.cs
- Source:
- Double.cs
- Source:
- Double.cs
Tente d’analyser une étendue de caractères dans 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 des caractères à analyser.
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture concernant s
.
- result
- Double
Lorsque cette méthode retourne, contient le résultat de l’analyse s
réussie ou une valeur non définie en cas d’échec.
Retours
true
si s
a été correctement analysé ; sinon, false
.
S’applique à
TryParse(ReadOnlySpan<Char>, Double)
- Source:
- Double.cs
- Source:
- Double.cs
- Source:
- Double.cs
Convertit la représentation sous forme d’étendue d'un nombre dans un style et un format propre à 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 a é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 contenant la représentation d’une date et d’une heure à convertir.
- result
- Double
Quand cette méthode est retournée, contient le nombre à virgule flottante double précision équivalent à la valeur numérique ou au symbole contenu dans le paramètre s
si la conversion a réussi, ou zéro si elle a échoué. La conversion échoue si le paramètre s
est null
ou vide, ou s'il n'est pas dans un format compatible avec style
. La conversion échoue également si style
n’est pas une combinaison valide de constantes énumérées NumberStyles. Si s
est un nombre valide inférieur à Double.MinValue, result
est NegativeInfinity. Si s
est un nombre valide supérieur à Double.MaxValue, result
est PositiveInfinity. Ce paramètre est passé non initialisé ; toute valeur fournie initialement dans result
sera remplacée.
Retours
true
si la conversion de s
est réussie ; sinon, false
.
Remarques
Dans .NET Core 3.0 et versions ultérieures, les valeurs trop grandes pour être représentées sont arrondies à PositiveInfinity ou NegativeInfinity comme requis par la spécification IEEE 754. Dans les versions antérieures, y compris .NET Framework, l’analyse d’une valeur trop grande pour être représentée a entraîné un échec.
S’applique à
TryParse(String, Double)
- 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 a é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
Quand cette méthode est retournée, contient le nombre à virgule flottante double précision équivalent au paramètre s
si la conversion a réussi, ou zéro si elle a échoué. La conversion échoue si le paramètre s
a la valeur null
ou Empty, ou s'il n'est pas dans un format valide. Il échoue également sur .NET Framework et .NET Core 2.2 et versions antérieures 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 initialement dans result
sera remplacée.
Retours
true
si la conversion de s
est réussie ; 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
Dans .NET Core 3.0 et versions ultérieures, les valeurs trop grandes pour être représentées sont arrondies à PositiveInfinity ou NegativeInfinity comme requis par la spécification IEEE 754. Dans les versions antérieures, y compris .NET Framework, l’analyse d’une valeur trop grande pour être représentée a entraîné un échec.
Cette surcharge diffère de la Double.Parse(String) méthode en renvoyant une valeur booléenne qui indique si l’opération d’analyse a réussi au lieu de retourner la valeur numérique analysée. Il élimine la nécessité d’utiliser la gestion des exceptions pour tester un FormatException dans le cas où n’est pas valide et ne s
peut pas être analysé avec succès.
Le s
paramètre peut contenir le , NumberFormatInfo.NegativeInfinitySymbolNumberFormatInfo.NaNSymbol de la culture NumberFormatInfo.PositiveInfinitySymbolactuelle (la comparaison de chaîne respecte la casse) ou une chaîne de la forme :
[ws] [connexion] [chiffres intégraux,] chiffres intégraux [. [chiffres fractionnaires]] [e [signe] chiffres exponentiels] [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. |
sign | 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égrale du nombre. Les chiffres intégraux peuvent être absents s’il existe des chiffres fractionnaires. |
, | Symbole de séparateur de groupe spécifique à la culture. |
. | Symbole décimal spécifique à la culture. |
chiffres fractionnaires | 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 Mise en forme des types.
Le s
paramètre est interprété à l’aide NumberStyles.Float d’une combinaison des indicateurs et NumberStyles.AllowThousands . Cela signifie que les séparateurs d’espaces blancs et de milliers sont autorisés, mais pas les symboles monétaires. Pour définir explicitement les éléments (tels que les symboles monétaires, les séparateurs de milliers et les espaces blancs) qui peuvent être présents dans s
, utilisez la Double.TryParse(String, NumberStyles, IFormatProvider, Double) méthode surcharge.
Le s
paramètre est analysé à l’aide des informations de mise en forme d’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 surcharge de méthode Double.TryParse(String, NumberStyles, IFormatProvider, Double) .
En règle générale, si vous transmettez à 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’un ou Double.MinValueDouble.MaxValue ne parvient pas à aller-retour. Sur .NET Framework et .NET Core 2.2 et les versions précédentes, il lève un OverflowException. Sur .NET Core 3.0 et versions ultérieuresMinValue, il retourne Double.NegativeInfinity si vous tentez d’analyser ou Double.PositiveInfinity si vous tentez d’analyser MaxValue. L'exemple suivant illustre cette situation.
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 et .NET Core 2.2 et versions antérieures, si 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 quand s
est hors de la plage du type de Double 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 étant plus proches des valeurs maximales ou minimales de que 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 lors d’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
- Parse(String)
- ToString()
- Analyse des chaînes numériques dans .NET
- Exemple : utilitaire de mise en forme .NET Core WinForms (C#)
- Exemple : utilitaire de mise en forme .NET Core WinForms (Visual Basic)
S’applique à
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Double)
- Source:
- Double.cs
- Source:
- Double.cs
Tente d’analyser une étendue de caractères UTF-8 dans 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 propres à la culture concernant utf8Text
.
- result
- Double
Au retour, contient le résultat de l’analyse utf8Text
réussie ou une valeur non définie en cas d’échec.
Retours
true
si utf8Text
a été correctement analysé ; sinon, false
.
S’applique à
TryParse(String, IFormatProvider, Double)
- Source:
- Double.cs
- Source:
- Double.cs
- Source:
- Double.cs
Tente d’analyser une chaîne dans 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 propres à la culture concernant s
.
- result
- Double
Lorsque cette méthode est retournée, contient le résultat de l’analyse s
réussie ou une valeur non définie en cas d’échec.
Retours
true
si s
a été correctement analysé ; sinon, false
.
S’applique à
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Double)
- Source:
- Double.cs
- Source:
- Double.cs
Tente d’analyser une étendue de caractères UTF-8 dans 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 styles numériques au niveau du bit qui peut être présente dans utf8Text
.
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture concernant utf8Text
.
- result
- Double
Au retour, contient le résultat de l’analyse utf8Text
réussie ou une valeur non définie en cas d’échec.
Retours
true
si utf8Text
a été correctement analysé ; sinon, false
.
S’applique à
TryParse(ReadOnlySpan<Byte>, Double)
- 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 équivalente.
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 à la valeur numérique ou au symbole contenu dans utf8Text
si la conversion a réussi ou zéro si la conversion a échoué. La conversion échoue si le utf8Text
est ou n’est Empty pas dans un format valide. Ce paramètre est passé sous forme non initialisée. Toute valeur fournie initialement dans le résultat sera remplacée.
Retours
true
si la conversion de utf8Text
est réussie ; sinon, false
.
S’applique à
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Double)
- 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 propre à 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 a échoué.
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, [Runtime::InteropServices::Out] double % result) = System::Numerics::INumberBase<double>::TryParse;
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 d'opérations au niveau du bit de valeurs NumberStyles indiquant le format autorisé de s
. Une valeur typique à spécifier est Float combinée avec AllowThousands.
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture sur s
.
- result
- Double
Quand cette méthode est retournée et si la conversion a réussi, contient un nombre à virgule flottante double précision équivalent à la valeur numérique ou au symbole contenu dans s
. Contient zéro si la conversion a échoué. La conversion échoue si le paramètre s
est null
, une étendue de caractères vide ou n’est pas dans un format conforme à style
. Si s
est un nombre valide inférieur à Double.MinValue, result
est NegativeInfinity. Si s
est un nombre valide supérieur à Double.MaxValue, result
est PositiveInfinity. Ce paramètre est passé non initialisé ; toute valeur fournie initialement dans result
sera remplacée.
Retours
true
si la conversion de s
est réussie ; sinon, false
.
Remarques
Dans .NET Core 3.0 et versions ultérieures, les valeurs trop grandes pour être représentées sont arrondies à PositiveInfinity ou NegativeInfinity comme requis par la spécification IEEE 754. Dans les versions antérieures, y compris .NET Framework, l’analyse d’une valeur trop grande pour être représentée a entraîné un échec.
S’applique à
TryParse(String, NumberStyles, IFormatProvider, Double)
- 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 propre à 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 a é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 d'opérations au niveau du bit de valeurs NumberStyles indiquant le format autorisé de s
. Une valeur typique à spécifier est Float combinée avec AllowThousands.
- provider
- IFormatProvider
IFormatProvider qui fournit des informations de format propres à la culture concernant s
.
- result
- Double
Quand cette méthode est retournée, contient un nombre à virgule flottante double précision équivalent à la valeur numérique ou au symbole contenu dans s
si la conversion a réussi, ou zéro si elle a échoué. La conversion échoue si le paramètre s
a la valeur null
ou Empty, n'est pas dans un format compatible avec style
, ou si style
n'est pas une combinaison valide de constantes d’énumération NumberStyles. Elle échoue également sur .NET Framework ou .NET Core 2.2 et versions antérieures 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 initialement dans result
sera remplacée.
Retours
true
si la conversion de s
est réussie ; sinon, false
.
Exceptions
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 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
Dans .NET Core 3.0 et versions ultérieures, les valeurs trop grandes pour être représentées sont arrondies à PositiveInfinity ou NegativeInfinity comme requis par la spécification IEEE 754. Dans les versions antérieures, y compris .NET Framework, l’analyse d’une valeur trop grande pour être représentée a entraîné un échec.
La TryParse méthode est semblable à la Parse(String, NumberStyles, IFormatProvider) méthode , sauf que cette méthode ne lève pas d’exception en cas d’échec de la conversion. 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 un FormatException dans le cas où n’est s
pas valide et ne peut pas être analysé correctement.
Le style
paramètre définit le format autorisé du paramètre pour que s
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 pour la culture indiquée par provider
. En outre, selon la valeur de style
, le s
paramètre peut inclure les éléments suivants :
[ws] [$] [signe] [chiffres intégraux,]chiffres intégraux[.chiffres fractionnaires][e[signe]chiffres exponentiels][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 inclut l’indicateur NumberStyles.AllowLeadingWhite . Il peut apparaître à la fin de s si style inclut l’indicateur NumberStyles.AllowTrailingWhite . |
$ | Symbole monétaire spécifique à la culture. Sa position dans la chaîne est définie par les NumberFormatInfo.CurrencyNegativePattern propriétés ou NumberFormatInfo.CurrencyPositivePattern de l’objet NumberFormatInfo retourné par la IFormatProvider.GetFormat méthode du provider paramètre . Le symbole monétaire peut apparaître dans s si style inclut l’indicateur NumberStyles.AllowCurrencySymbol . |
sign | 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 . Vous pouvez utiliser des parenthèses dans s pour indiquer une valeur négative si style inclut l’indicateur NumberStyles.AllowParentheses . |
chiffres intégraux | Série de chiffres compris entre 0 et 9 qui spécifient la partie intégrale du nombre. Les chiffres intégraux peuvent être absents s’il existe des chiffres fractionnaires. |
, | Symbole de séparateur de milliers spécifique à la culture. Le symbole de séparation des milliers de la culture actuelle peut apparaître dans s si style inclut l’indicateur NumberStyles.AllowThousands . |
. | Symbole décimal spécifique à la culture. Le symbole décimal de la culture actuelle peut apparaître dans s si style 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 fractionnaires peuvent apparaître dans s si style inclut l’indicateur NumberStyles.AllowDecimalPoint . |
e | Caractère e ou E, qui indique que s peut représenter un nombre à l’aide de la 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. |
Notes
Tous les caractères NUL de fin (U+0000) dans s
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) s’analyse toujours correctement si elle se trouve dans la plage du Double type. Les membres restants System.Globalization.NumberStyles contrôlent les éléments qui peuvent être, mais qui ne sont pas obligatoirement 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 dans s en plus des chiffres |
---|---|
None | Élément de chiffres intégraux uniquement. |
AllowDecimalPoint | Éléments . et fractionnaire-digits . |
AllowExponent | Le s paramètre peut également utiliser la notation exponentielle. Cet indicateur prend lui-mêmeen charge les valeurs sous la forme de chiffresintégraux E exponentiels ; des indicateurs supplémentaires 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 sign au début de s . |
AllowTrailingSign | Élément sign à la fin de s . |
AllowParentheses | Élément sign sous la forme de parenthèses englobant la valeur numérique. |
AllowThousands | Élément , . |
AllowCurrencySymbol | Élément $. |
Currency | Tout le monde. Le s paramètre ne peut pas représenter un nombre hexadécimal ou un nombre en notation exponentielle. |
Float | L’é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 séparateur , sign , milliers (,) et 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 NumberFormatInfo objet ou CultureInfo . Le provider
paramètre fournit des informations spécifiques à la culture utilisées dans l’analyse. Si provider
is null
ou un NumberFormatInfo objet ne peut pas être obtenu, 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, si le provider
paramètre ne génère pas d’objet NumberFormatInfo ou si le style
paramètre n’est pas une combinaison d’indicateurs de bits de l’énumération NumberStyles .
En règle générale, si vous transmettez à 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’un ou Double.MinValueDouble.MaxValue ne parvient pas à aller-retour. Sur .NET Framework et .NET Core 2.2 et les versions précédentes, il lève un OverflowException. Sur .NET Core 3.0 et versions ultérieuresMinValue, il retourne Double.NegativeInfinity si vous tentez d’analyser ou Double.PositiveInfinity si vous tentez d’analyser MaxValue. L'exemple suivant illustre cette situation.
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 et .NET Core 2.2 et versions antérieures, si 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 quand s
est hors de la plage du type de Double 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 étant plus proches des valeurs maximales ou minimales de que 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 lors d’une opération d’analyse, et que les séparateurs décimaux de devise ou de nombre et de groupe 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
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour