Decimal.Parse Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

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

Convertit la représentation sous forme de chaîne d'un nombre en sa représentation Decimal équivalente.

Surcharges

Parse(String)	Convertit la représentation sous forme de chaîne d'un nombre en sa représentation Decimal équivalente.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analyse une étendue de caractères UTF-8 dans une valeur.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analyse une étendue de caractères dans une valeur.
Parse(String, NumberStyles)	Convertit la représentation d'un nombre sous forme de chaîne dans un style spécifié en son équivalent Decimal.
Parse(String, IFormatProvider)	Convertit la représentation sous forme de chaîne d'un nombre en son Decimal équivalent à l'aide des informations de format propres à la culture spécifiée.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analyse une étendue de caractères UTF-8 dans une valeur.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convertit la représentation sous forme de plage d'un nombre en son Decimal équivalent à l'aide du style et du format spécifiques à la culture spécifiés.
Parse(String, NumberStyles, IFormatProvider)	Convertit la représentation sous forme de chaîne d'un nombre en son Decimal équivalent à l'aide du style et du format spécifiques à la culture spécifiés.

Parse(String)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Convertit la représentation sous forme de chaîne d'un nombre en sa représentation Decimal équivalente.

public:
 static System::Decimal Parse(System::String ^ s);

public static decimal Parse (string s);

static member Parse : string -> decimal

Public Shared Function Parse (s As String) As Decimal

Paramètres

s: String

Représentation sous forme de chaîne du nombre à convertir.

Retours

Decimal

Équivalent au nombre figurant dans s.

Exceptions

ArgumentNullException

s a la valeur null.

FormatException

Le format de s est incorrect.

OverflowException

s représente un nombre inférieur à Decimal.MinValue ou supérieur à Decimal.MaxValue.

Exemples

L’exemple de code suivant utilise la Parse(String) méthode pour analyser les représentations sous forme de chaîne de Decimal valeurs.

string value;
decimal number;
// Parse an integer with thousands separators.
value = "16,523,421";
number = Decimal.Parse(value);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
//    '16,523,421' converted to 16523421.

// Parse a floating point value with thousands separators
value = "25,162.1378";
number = Decimal.Parse(value);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
//    '25,162.1378' converted to 25162.1378.

// Parse a floating point number with US currency symbol.
value = "$16,321,421.75";
try
{
   number = Decimal.Parse(value);
   Console.WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
//    Unable to parse '$16,321,421.75'.

// Parse a number in exponential notation
value = "1.62345e-02";
try
{
   number = Decimal.Parse(value);
   Console.WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
//    Unable to parse '1.62345e-02'.

// Parse an integer with thousands separators.
let value = "16,523,421"
let number = Decimal.Parse value
printfn $"'{value}' converted to {number}."
// Displays:
//    '16,523,421' converted to 16523421.

// Parse a floating point value with thousands separators
let value = "25,162.1378"
let number = Decimal.Parse value
printfn $"'{value}' converted to {number}."
// Displays:
//    '25,162.1378' converted to 25162.1378.

// Parse a floating point number with US currency symbol.
let value = "$16,321,421.75"
try
    let number = Decimal.Parse value
    printfn $"'{value}' converted to {number}."
with :? FormatException ->
    printfn $"Unable to parse '{value}'."
// Displays:
//    Unable to parse '$16,321,421.75'.

// Parse a number in exponential notation
let value = "1.62345e-02"
try
    let number = Decimal.Parse value
    printfn $"'{value}' converted to {number}."
with :? FormatException ->
    printfn $"Unable to parse '{value}'."
// Displays:
//    Unable to parse '1.62345e-02'.

Dim value As String
Dim number As Decimal

' Parse an integer with thousands separators. 
value = "16,523,421"
number = Decimal.Parse(value)
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays: 
'    '16,523,421' converted to 16523421.

' Parse a floating point value with thousands separators
value = "25,162.1378"
number = Decimal.Parse(value)
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays:
'    '25,162.1378' converted to 25162.1378.

' Parse a floating point number with US currency symbol.
value = "$16,321,421.75"
Try
   number = Decimal.Parse(value)
   Console.WriteLine("'{0}' converted to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)
End Try
' Displays:
'    Unable to parse '$16,321,421.75'.  

' Parse a number in exponential notation
value = "1.62345e-02"
Try
   number = Decimal.Parse(value)
   Console.WriteLine("'{0}' converted to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)
End Try
' Displays: 
'    Unable to parse '1.62345e-02'.

Remarques

Le paramètre s contient un numéro de la forme :

[ws] [sign] [digits,]digits[.fractional-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.
sign	Signe facultatif.
chiffres	Séquence de chiffres compris entre 0 et 9.
,	Symbole de séparateur de milliers propre à la culture.
.	Symbole décimal spécifique à la culture.
chiffres fractionnaires	Séquence de chiffres compris entre 0 et 9.

Le paramètre s est interprété à l’aide du NumberStyles.Number style . 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 Decimal.Parse(String, NumberStyles) méthode ou Decimal.Parse(String, NumberStyles, IFormatProvider) .

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

Si nécessaire, la valeur de s est arrondie à l’aide de l’arrondi au plus proche.

A Decimal 29 chiffres de précision. Si s représente un nombre qui a plus de 29 chiffres, mais qui a une partie fractionnaire et qui se trouve dans la plage de MaxValue et MinValue, le nombre est arrondi, non tronqué, à 29 chiffres à l’aide de l’arrondi au plus proche.

Si, au cours d’une opération d’analyse, un séparateur est rencontré dans le s paramètre 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 à

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:: Decimal.cs

Source:: Decimal.cs

Analyse une étendue de caractères UTF-8 dans une valeur.

public:
 static System::Decimal Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<System::Decimal>::Parse;

public static decimal Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);

static member Parse : ReadOnlySpan<byte> * IFormatProvider -> decimal

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Decimal

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.

Retours

Decimal

Résultat de l’analyse .utf8Text

Implémente

Parse(ReadOnlySpan<Byte>, IFormatProvider)

S’applique à

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Analyse une étendue de caractères dans une valeur.

public:
 static System::Decimal Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<System::Decimal>::Parse;

public static decimal Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> decimal

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Decimal

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.

Retours

Decimal

Résultat de l’analyse .s

Implémente

Parse(ReadOnlySpan<Char>, IFormatProvider)

S’applique à

Parse(String, NumberStyles)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Convertit la représentation d'un nombre sous forme de chaîne dans un style spécifié en son équivalent Decimal.

public:
 static System::Decimal Parse(System::String ^ s, System::Globalization::NumberStyles style);

public static decimal Parse (string s, System.Globalization.NumberStyles style);

static member Parse : string * System.Globalization.NumberStyles -> decimal

Public Shared Function Parse (s As String, style As NumberStyles) As Decimal

Paramètres

s: String

Représentation sous forme de chaîne du nombre à convertir.

style: NumberStyles

Combinaison d'opérations de bits de valeurs NumberStyles qui indique les éléments de style qui peuvent être présents dans s. Une valeur typique à spécifier est Number.

Retours

Decimal

Nombre Decimal équivalent au nombre figurant dans s, comme spécifié par style.

Exceptions

ArgumentNullException

s a la valeur null.

ArgumentException

style n’est pas une valeur NumberStyles.

-ou-

style est la valeur AllowHexSpecifier.

FormatException

Le format de s est incorrect.

OverflowException

s représente un nombre inférieur à Decimal.MinValue ou supérieur à Decimal.MaxValue

Exemples

L’exemple de code suivant utilise la Parse(String, NumberStyles) méthode pour analyser les représentations sous forme de chaîne de valeurs à l’aide de Decimal la culture en-US.

string value;
decimal number;
NumberStyles style;

// Parse string with a floating point value using NumberStyles.None.
value = "8694.12";
style = NumberStyles.None;
try
{
   number = Decimal.Parse(value, style);
   Console.WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
//    Unable to parse '8694.12'.

// Parse string with a floating point value and allow decimal point.
style = NumberStyles.AllowDecimalPoint;
number = Decimal.Parse(value, style);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
//    '8694.12' converted to 8694.12.

// Parse string with negative value in parentheses
value = "(1,789.34)";
style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands |
        NumberStyles.AllowParentheses;
number = Decimal.Parse(value, style);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
//    '(1,789.34)' converted to -1789.34.

// Parse string using Number style
value = " -17,623.49 ";
style = NumberStyles.Number;
number = Decimal.Parse(value, style);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
//    ' -17,623.49 ' converted to -17623.49.

// Parse string with a floating point value using NumberStyles.None.
let value = "8694.12"
let style = NumberStyles.None
try
    let number = Decimal.Parse(value, style)
    printfn $"'{value}' converted to {number}."
with :? FormatException ->
    printfn $"Unable to parse '{value}'."
// Displays:
//    Unable to parse '8694.12'.

// Parse string with a floating point value and allow decimal point.
let style = NumberStyles.AllowDecimalPoint
let number = Decimal.Parse(value, style)
printfn $"'{value}' converted to {number}."
// Displays:
//    '8694.12' converted to 8694.12.

// Parse string with negative value in parentheses
let value = "(1,789.34)"
let style = 
    NumberStyles.AllowDecimalPoint ||| 
    NumberStyles.AllowThousands ||| 
    NumberStyles.AllowParentheses
let number = Decimal.Parse(value, style)
printfn $"'{value}' converted to {number}."
// Displays:
//    '(1,789.34)' converted to -1789.34.

// Parse string using Number style
let value = " -17,623.49 "
let style = NumberStyles.Number
let number = Decimal.Parse(value, style)
printfn $"'{value}' converted to {number}."
// Displays:
//    ' -17,623.49 ' converted to -17623.49.

Dim value As String
Dim number As Decimal
Dim style As NumberStyles

' Parse string with a floating point value using NumberStyles.None. 
value = "8694.12"
style = NumberStyles.None
Try
   number = Decimal.Parse(value, style)  
   Console.WriteLine("'{0}' converted to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)
End Try
' Displays:
'    Unable to parse '8694.12'.

' Parse string with a floating point value and allow decimal point. 
style = NumberStyles.AllowDecimalPoint
number = Decimal.Parse(value, style)  
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays:
'    '8694.12' converted to 8694.12.

' Parse string with negative value in parentheses
value = "(1,789.34)"
style = NumberStyles.AllowDecimalPoint Or NumberStyles.AllowThousands Or _
        NumberStyles.AllowParentheses 
number = Decimal.Parse(value, style)  
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays:
'    '(1,789.34)' converted to -1789.34.

' Parse string using Number style
value = " -17,623.49 "
style = NumberStyles.Number
number = Decimal.Parse(value, style)  
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays:
'    ' -17,623.49 ' converted to -17623.49.

Remarques

Le style paramètre définit les éléments de style (tels que les séparateurs de milliers, les espaces blancs et les symboles monétaires) autorisés dans le 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 :

Selon la valeur de style, le s paramètre peut inclure les éléments suivants :

[ws] [$] [sign] [digits,]digits[.fractional-digits][e[sign]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` inclut l’indicateur NumberStyles.AllowLeadingWhite , et 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 et NumberFormatInfo.CurrencyPositivePattern de la culture actuelle. Le symbole monétaire de la culture actuelle 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 . Les parenthèses peuvent être utilisées dans `s` pour indiquer une valeur négative si `style` inclut l’indicateur NumberStyles.AllowParentheses .
chiffres	Séquence de chiffres compris entre 0 et 9.
,	Symbole de séparateur de milliers propre à la culture. Le séparateur de 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 .
chiffres fractionnaires	Séquence de chiffres compris entre 0 et 9. Les chiffres fractionnaires ne peuvent apparaître dans `s` que si `style` inclut l’indicateur NumberStyles.AllowDecimalPoint .
e	Caractère « e » ou « E », qui indique que la valeur est représentée en notation exponentielle. Le `s` paramètre peut représenter un nombre en notation exponentielle si `style` inclut l’indicateur NumberStyles.AllowExponent .

Notes

Tous les caractères NUL (U+0000) de fin 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 None style) analyse toujours correctement si elle se trouve dans la plage du Decimal type. Les membres restants 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 membres 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 digits uniquement.
AllowDecimalPoint	Éléments . et fractionnaire-digits .
AllowExponent	Le `s` paramètre peut également utiliser la notation exponentielle. Cet indicateur prend en charge les valeurs sous forme de chiffresE ; des indicateurs supplémentaires sont nécessaires pour analyser correctement les chaînes 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`, `sign`et `,.` .
Any	Tous les styles, sauf `s` ne peuvent pas représenter un nombre hexadécimal.

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

Si un séparateur est rencontré dans le s paramètre pendant une opération d’analyse, styles qu’il inclut les NumberStyles.AllowThousands valeurs et NumberStyles.AllowDecimalPoint 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 à

Parse(String, IFormatProvider)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Convertit la représentation sous forme de chaîne d'un nombre en son Decimal équivalent à l'aide des informations de format propres à la culture spécifiée.

public:
 static System::Decimal Parse(System::String ^ s, IFormatProvider ^ provider);

public:
 static System::Decimal Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<System::Decimal>::Parse;

public static decimal Parse (string s, IFormatProvider provider);

public static decimal Parse (string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> decimal

Public Shared Function Parse (s As String, provider As IFormatProvider) As Decimal

Paramètres

s: String

Représentation sous forme de chaîne du nombre à convertir.

provider: IFormatProvider

IFormatProvider qui fournit des informations d'analyse propres à la culture concernant s.

Retours

Decimal

Nombre Decimal équivalent au nombre figurant dans s, comme spécifié par provider.

Implémente

Parse(String, IFormatProvider)

Exceptions

ArgumentNullException

s a la valeur null.

FormatException

Le format de s est incorrect.

OverflowException

s représente un nombre inférieur à Decimal.MinValue ou supérieur à Decimal.MaxValue.

Exemples

L’exemple suivant est le gestionnaire d’événements click d’un formulaire Web. Il utilise le tableau retourné par la HttpRequest.UserLanguages propriété pour déterminer les paramètres régionaux de l’utilisateur. Il instancie ensuite un CultureInfo objet qui correspond à ces paramètres régionaux. L’objet NumberFormatInfo qui appartient à cet CultureInfo objet est ensuite passé à la Parse(String, IFormatProvider) méthode pour convertir l’entrée de l’utilisateur en valeur Decimal .

protected void OkToDecimal_Click(object sender, EventArgs e)
{
    string locale;
    decimal number;
    CultureInfo culture;

    // Return if string is empty
    if (String.IsNullOrEmpty(this.inputNumber.Text))
        return;

    // Get locale of web request to determine possible format of number
    if (Request.UserLanguages.Length == 0)
        return;
    locale = Request.UserLanguages[0];
    if (String.IsNullOrEmpty(locale))
        return;

    // Instantiate CultureInfo object for the user's locale
    culture = new CultureInfo(locale);

    // Convert user input from a string to a number
    try
    {
        number = Decimal.Parse(this.inputNumber.Text, culture.NumberFormat);
    }
    catch (FormatException)
    {
        return;
    }
    catch (Exception)
    {
        return;
    }
    // Output number to label on web form
    this.outputNumber.Text = "Number is " + number.ToString();
}

Protected Sub OkToDecimal_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToDecimal.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As Decimal

   ' Return if string is empty
   If String.IsNullOrEmpty(Me.inputNumber.Text) Then Exit Sub

   ' Get locale of web request to determine possible format of number
   If Request.UserLanguages.Length = 0 Then Exit Sub
   locale = Request.UserLanguages(0)
   If String.IsNullOrEmpty(locale) Then Exit Sub

   ' Instantiate CultureInfo object for the user's locale
   culture = New CultureInfo(locale)

   ' Convert user input from a string to a number
   Try
      number = Decimal.Parse(Me.inputNumber.Text, culture.NumberFormat)
   Catch ex As FormatException
      Exit Sub
   Catch ex As Exception
      Exit Sub
   End Try

   ' Output number to label on web form
   Me.outputNumber.Text = "Number is " & number.ToString()
End Sub

Remarques

Cette surcharge de la Parse(String, IFormatProvider) méthode est couramment utilisée pour convertir du texte qui peut être mis en forme de différentes manières en une Decimal valeur. Par exemple, il peut être utilisé pour convertir le texte entré par un utilisateur dans une zone de texte HTML en valeur numérique.

Le s paramètre contient un certain nombre de formes :

[ws] [sign] [digits,]digits[.fractional-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.
sign	Signe facultatif.
chiffres	Séquence de chiffres compris entre 0 et 9.
,	Symbole de séparateur de milliers propre à la culture.
.	Symbole décimal spécifique à la culture.
chiffres fractionnaires	Séquence de chiffres compris entre 0 et 9.

Le s paramètre est interprété à l’aide du NumberStyles.Number style . 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 Decimal.Parse(String, NumberStyles, IFormatProvider) méthode .

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 est null, la culture actuelle du thread est utilisée.

Un Decimal objet a 29 chiffres de précision. Si s représente un nombre qui a plus de 29 chiffres, mais qui a une partie fractionnaire et qui se trouve dans la plage de MaxValue et MinValue, le nombre est arrondi, non tronqué, à 29 chiffres à l’aide de l’arrondi au plus proche.

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 à

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:: Decimal.cs

Source:: Decimal.cs

Analyse une étendue de caractères UTF-8 dans une valeur.

public static decimal Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Number, IFormatProvider? provider = default);

static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> decimal

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Number, Optional provider As IFormatProvider = Nothing) As Decimal

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.

Retours

Decimal

Résultat de l’analyse .utf8Text

Implémente

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

S’applique à

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Convertit la représentation sous forme de plage d'un nombre en son Decimal équivalent à l'aide du style et du format spécifiques à la culture spécifiés.

public static decimal Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Number, IFormatProvider? provider = default);

public static decimal Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Number, IFormatProvider provider = default);

static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> decimal

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Number, Optional provider As IFormatProvider = Nothing) As Decimal

Paramètres

s: ReadOnlySpan<Char>

Plage contenant les caractères représentant le nombre à convertir.

style: NumberStyles

Combinaison d'opérations de bits de valeurs NumberStyles qui indique les éléments de style qui peuvent être présents dans s. Une valeur typique à spécifier est Number.

provider: IFormatProvider

Objet IFormatProvider qui fournit des informations spécifiques à la culture concernant le format de s.

Retours

Decimal

Nombre Decimal équivalent au nombre figurant dans s, comme spécifié par style et provider.

Implémente

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

S’applique à

Parse(String, NumberStyles, IFormatProvider)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Convertit la représentation sous forme de chaîne d'un nombre en son Decimal équivalent à l'aide du style et du format spécifiques à la culture spécifiés.

public:
 static System::Decimal Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);

public:
 static System::Decimal Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::Decimal>::Parse;

public static decimal Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);

public static decimal Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> decimal

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Decimal

Paramètres

s: String

Représentation sous forme de chaîne du nombre à convertir.

style: NumberStyles

Combinaison d'opérations de bits de valeurs NumberStyles qui indique les éléments de style qui peuvent être présents dans s. Une valeur typique à spécifier est Number.

provider: IFormatProvider

Objet IFormatProvider qui fournit des informations spécifiques à la culture concernant le format de s.

Retours

Decimal

Nombre Decimal équivalent au nombre figurant dans s, comme spécifié par style et provider.

Implémente

Parse(String, NumberStyles, IFormatProvider)

Exceptions

FormatException

Le format de s est incorrect.

OverflowException

s représente un nombre inférieur à Decimal.MinValue ou supérieur à Decimal.MaxValue.

ArgumentNullException

s a la valeur null.

ArgumentException

style n’est pas une valeur NumberStyles.

-ou-

style est la valeur AllowHexSpecifier.

Exemples

L’exemple suivant utilise divers style paramètres et provider pour analyser les représentations sous forme de chaîne de Decimal valeurs.

string value;
decimal number;
NumberStyles style;
CultureInfo provider;

// Parse string using " " as the thousands separator
// and "," as the decimal separator for fr-FR culture.
value = "892 694,12";
style = NumberStyles.AllowDecimalPoint | NumberStyles.AllowThousands;
provider = new CultureInfo("fr-FR");

number = Decimal.Parse(value, style, provider);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
//    '892 694,12' converted to 892694.12.

try
{
   number = Decimal.Parse(value, style, CultureInfo.InvariantCulture);
   Console.WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
//    Unable to parse '892 694,12'.

// Parse string using "$" as the currency symbol for en-GB and
// en-US cultures.
value = "$6,032.51";
style = NumberStyles.Number | NumberStyles.AllowCurrencySymbol;
provider = new CultureInfo("en-GB");

try
{
   number = Decimal.Parse(value, style, provider);
   Console.WriteLine("'{0}' converted to {1}.", value, number);
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse '{0}'.", value);
}
// Displays:
//    Unable to parse '$6,032.51'.

provider = new CultureInfo("en-US");
number = Decimal.Parse(value, style, provider);
Console.WriteLine("'{0}' converted to {1}.", value, number);
// Displays:
//    '$6,032.51' converted to 6032.51.

// Parse string using " " as the thousands separator
// and "," as the decimal separator for fr-FR culture.
let value = "892 694,12"
let style = NumberStyles.AllowDecimalPoint ||| NumberStyles.AllowThousands
let provider = CultureInfo "fr-FR"

let number = Decimal.Parse(value, style, provider)
printfn $"'{value}' converted to {number}."
// Displays:
//    '892 694,12' converted to 892694.12.

try
    let number = Decimal.Parse(value, style, CultureInfo.InvariantCulture)
    printfn $"'{value}' converted to {number}."
with :? FormatException ->
    printfn $"Unable to parse '{value}'."
// Displays:
//    Unable to parse '892 694,12'.

// Parse string using "$" as the currency symbol for en-GB and
// en-US cultures.
let value = "$6,032.51"
let style = NumberStyles.Number ||| NumberStyles.AllowCurrencySymbol
let provider = CultureInfo "en-GB"

try
    let number = Decimal.Parse(value, style, provider)
    printfn $"'{value}' converted to {number}."
with :? FormatException ->
    printfn $"Unable to parse '{value}'."
// Displays:
//    Unable to parse '$6,032.51'.

let provider = CultureInfo "en-US"
let number = Decimal.Parse(value, style, provider)
printfn $"'{value}' converted to {number}."
// Displays:
//    '$6,032.51' converted to 6032.51.

Dim value As String
Dim number As Decimal
Dim style As NumberStyles
Dim provider As CultureInfo

' Parse string using " " as the thousands separator 
' and "," as the decimal separator for fr-FR culture.
value = "892 694,12"
style = NumberStyles.AllowDecimalPoint Or NumberStyles.AllowThousands
provider = New CultureInfo("fr-FR")

number = Decimal.Parse(value, style, provider)  
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays: 
'    '892 694,12' converted to 892694.12.

Try
   number = Decimal.Parse(value, style, CultureInfo.InvariantCulture)  
   Console.WriteLine("'{0}' converted to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)
End Try
' Displays: 
'    Unable to parse '892 694,12'.  

' Parse string using "$" as the currency symbol for en-GB and
' en-US cultures.
value = "$6,032.51"
style = NumberStyles.Number Or NumberStyles.AllowCurrencySymbol
provider = New CultureInfo("en-GB")

Try
   number = Decimal.Parse(value, style, provider)  
   Console.WriteLine("'{0}' converted to {1}.", value, number)
Catch e As FormatException
   Console.WriteLine("Unable to parse '{0}'.", value)
End Try
' Displays: 
'    Unable to parse '$6,032.51'.

provider = New CultureInfo("en-US")
number = Decimal.Parse(value, style, provider)  
Console.WriteLine("'{0}' converted to {1}.", value, number)
' Displays: 
'    '$6,032.51' converted to 6032.51.

Remarques

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 :

Selon la valeur de style, le s paramètre peut inclure les éléments suivants :

[ws] [$] [signe] [digits,]digits[.fractional-digits][e[sign]digits][ws]

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

Élément	Description
$	Symbole monétaire spécifique à la culture. Sa position dans la chaîne est définie par les CurrencyNegativePattern propriétés et CurrencyPositivePattern de l’objet NumberFormatInfo retourné par la GetFormat méthode du `provider` paramètre . Le symbole monétaire peut apparaître dans `s` si `style` inclut l’indicateur NumberStyles.AllowCurrencySymbol .
ws	Espace blanc facultatif. L’espace blanc peut apparaître au début de `s` si `style` inclut l’indicateur NumberStyles.AllowLeadingWhite , et il peut apparaître à la fin de `s` si `style` inclut l’indicateur NumberStyles.AllowTrailingWhite .
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	Séquence de chiffres compris entre 0 et 9.
,	Symbole de séparateur de milliers spécifique à la culture. Le séparateur de milliers de la culture définie par `provider` peut apparaître dans `s` si `style` inclut l’indicateur NumberStyles.AllowThousands .
.	Symbole décimal spécifique à la culture. Le symbole de virgule décimale de la culture définie par `provider` peut apparaître dans `s` si `style` inclut l’indicateur NumberStyles.AllowDecimalPoint .
fractionnaires-chiffres	Séquence de chiffres compris entre 0 et 9. Les chiffres fractionnaires peuvent apparaître dans `s` uniquement si `style` inclut l’indicateur NumberStyles.AllowDecimalPoint .
e	Caractère « e » ou « E », qui indique que la valeur est représentée en notation exponentielle. Le `s` paramètre peut représenter un nombre en notation exponentielle si `style` inclut l’indicateur NumberStyles.AllowExponent .

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 None style) s’analyse toujours correctement si elle se trouve dans la plage du Decimal type. Les membres restants NumberStyles contrôlent les éléments qui peuvent être mais qui ne doivent pas être présents dans la chaîne d’entrée. Le tableau suivant indique comment les membres 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 digits uniquement.
AllowDecimalPoint	Éléments àchiffres fractionnaires et .
AllowExponent	Le `s` paramètre peut également utiliser la notation exponentielle. Cet indicateur prend en charge les valeurs sous forme de chiffresE; Des indicateurs supplémentaires sont nécessaires pour analyser correctement les chaînes 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 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`, `sign`, et .
Any	Tous les styles, sauf `s` ne peuvent pas représenter un nombre hexadécimal.

Un Decimal objet a 29 chiffres de précision. Si s représente un nombre qui a plus de 29 chiffres, mais qui a une partie fractionnaire et se trouve dans la plage de MaxValue et MinValue, le nombre est arrondi à 29 chiffres, et non tronqué, à l’aide de l’arrondi au plus proche.

Si un séparateur est rencontré dans le s paramètre au cours d’une opération d’analyse et que les séparateurs décimaux et de groupe de devises 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 à

Decimal.Parse Méthode

Définition

Surcharges

Parse(String)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Paramètres

Retours

Implémente

S’applique à

Parse(ReadOnlySpan<Char>, IFormatProvider)

Paramètres

Retours

Implémente

S’applique à

Parse(String, NumberStyles)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Parse(String, IFormatProvider)

Paramètres

Retours

Implémente

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Paramètres

Retours

Implémente

S’applique à

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Paramètres

Retours

Implémente

S’applique à

Parse(String, NumberStyles, IFormatProvider)

Paramètres

Retours

Implémente

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Commentaires

Ressources supplémentaires