Decimal.Parse Méthode

Définition

Espace de noms:: System

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

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

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 son Decimal équivalent.

Surcharges

Nom	Description
Parse(String)	Convertit la représentation sous forme de chaîne d’un nombre en son Decimal équivalent.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analyse une étendue de caractères UTF-8 en une valeur.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analyse une étendue de caractères en une valeur.
Parse(String, NumberStyles)	Convertit la représentation sous forme de chaîne d’un nombre dans un style spécifié en son Decimal équivalent.
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 spécifiques à la culture spécifiées.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analyse une étendue de caractères UTF-8 en une valeur.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convertit la représentation d’étendue d’un nombre en son Decimal équivalent à l’aide du style et du format spécifique à 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écifique à la culture spécifiés.

Parse(String)

Source:: Decimal.cs

Source:: Decimal.cs

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.

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 contenu dans s.

Exceptions

ArgumentNullException

s a la valeur null.

FormatException

s n’est pas au format correct.

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 certain nombre de formulaires :

[ws] [sign] [chiffres,]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.
signe	Signe facultatif.
Chiffres	Séquence de chiffres allant de 0 à 9.
,	Symbole de séparateur de milliers spécifique à la culture.
.	Symbole décimal spécifique à la culture.
fractionnaires-chiffres	Séquence de chiffres allant de 0 à 9.

Le paramètre s est interprété à l’aide du NumberStyles.Number style. 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 les symboles monétaires, les séparateurs de milliers et les espaces blancs) qui peuvent être présents dans s, utilisez la méthode ou la Decimal.Parse(String, NumberStyles)Decimal.Parse(String, NumberStyles, IFormatProvider) méthode.

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 ou Decimal.Parse(String, NumberStyles, IFormatProvider) la Decimal.Parse(String, IFormatProvider) méthode.

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

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

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

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Analyse une étendue de caractères UTF-8 en 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 spécifiques à la culture sur 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

Source:: Decimal.cs

Source:: Decimal.cs

Analyse une étendue de caractères en 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 de caractères à analyser.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme spécifiques à la culture sur 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

Source:: Decimal.cs

Source:: Decimal.cs

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

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 de valeurs au niveau du NumberStyles bit qui indique les éléments de style qui peuvent être présents dans s. Une valeur classique à spécifier est Number.

Retours

Decimal

Nombre Decimal équivalent au nombre contenu dans s tel que spécifié par style.

Exceptions

ArgumentNullException

s a la valeur null.

ArgumentException

style n’est pas une NumberStyles valeur.

-ou-

style est la AllowHexSpecifier valeur.

FormatException

s n’est pas au format correct.

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 des milliers de séparateurs, des espaces blancs et des symboles monétaires) autorisés dans le paramètre pour que l’opération s 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] [chiffres,]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 propre à la culture. Sa position dans la chaîne est définie par les propriétés et NumberFormatInfo.CurrencyNegativePattern les NumberFormatInfo.CurrencyPositivePattern propriétés de la culture actuelle. Le symbole monétaire de la culture actuelle peut apparaître s’il `sstyle` inclut l’indicateur NumberStyles.AllowCurrencySymbol .
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	Séquence de chiffres allant de 0 à 9.
,	Symbole de séparateur de milliers spécifique à la culture. Le 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équence de chiffres allant de 0 à 9. Les chiffres fractionnels peuvent apparaître `s` uniquement si `style` l’indicateur NumberStyles.AllowDecimalPoint est inclus.
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 s’il `style` inclut l’indicateur NumberStyles.AllowExponent .

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 None style) analyse toujours correctement si elle se trouve dans la plage du Decimal type. Les éléments de contrôle membres restants 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 membres 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 uniquement.
AllowDecimalPoint	Éléments . et fractionnaires .
AllowExponent	Le `s` paramètre peut également utiliser la notation exponentielle. Cet indicateur prend en charge les valeurs dans leschiffres E de formulaire ; 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 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’é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	Les éléments et les `ws`éléments `sign,.`.
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 inclut les valeurs et NumberStyles.AllowDecimalPoint les NumberStyles.AllowThousands valeurs et la devise ou les séparateurs de nombres et de groupes 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

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 spécifiques à la culture spécifiées.

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

Qui IFormatProvider fournit des informations d’analyse spécifiques à la culture sur s.

Retours

Decimal

Nombre Decimal équivalent au nombre contenu dans s tel que spécifié par provider.

Implémente

Parse(String, IFormatProvider)

Exceptions

ArgumentNullException

s a la valeur null.

FormatException

s n’est pas du format correct.

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 de bouton 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 Decimal valeur.

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 pouvant être mis en forme de différentes manières en valeur Decimal . Par exemple, il peut être utilisé pour convertir le texte entré par un utilisateur en zone de texte HTML en valeur numérique.

Le s paramètre contient un certain nombre du formulaire :

[ws] [sign] [chiffres,]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.
signe	Signe facultatif.
Chiffres	Séquence de chiffres allant de 0 à 9.
,	Symbole de séparateur de milliers spécifique à la culture.
.	Symbole décimal spécifique à la culture.
fractionnaires-chiffres	Séquence de chiffres allant de 0 à 9.

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

Le provider paramètre est une IFormatProvider implémentation, telle qu’un ou CultureInfo un NumberFormatInfo objet. Le provider paramètre fournit des informations spécifiques à la culture utilisées dans l’analyse. Si provider c’est nullle cas, 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 a une partie fractionnaire et se trouve dans la plage et MaxValue MinValue, le nombre est arrondi, non tronqué, à 29 chiffres à l’aide de l’arrondi le plus proche.

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 à

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Source:: Decimal.cs

Analyse une étendue de caractères UTF-8 en 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 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.

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

Source:: Decimal.cs

Source:: Decimal.cs

Convertit la représentation d’étendue d’un nombre en son Decimal équivalent à l’aide du style et du format spécifique à 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>

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

style: NumberStyles

Combinaison de valeurs au niveau du NumberStyles bit qui indique les éléments de style qui peuvent être présents dans s. Une valeur classique à spécifier est Number.

provider: IFormatProvider

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

Retours

Decimal

Nombre Decimal équivalent au nombre contenu dans s tel que 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

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écifique à 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 de valeurs au niveau du NumberStyles bit qui indique les éléments de style qui peuvent être présents dans s. Une valeur classique à spécifier est Number.

provider: IFormatProvider

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

Retours

Decimal

Nombre Decimal équivalent au nombre contenu dans s tel que spécifié par style et provider.

Implémente

Parse(String, NumberStyles, IFormatProvider)

Exceptions

FormatException

s n’est pas au format correct.

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 NumberStyles valeur.

-ou-

style est la AllowHexSpecifier valeur.

Exemples

L’exemple suivant utilise une variété de styleprovider paramètres 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 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] [chiffres,]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 propre à la culture. Sa position dans la chaîne est définie par les CurrencyNegativePattern propriétés de CurrencyPositivePattern l’objet NumberFormatInfo retourné par la GetFormat méthode du `provider` paramètre. Le symbole monétaire peut apparaître si `sstyle` l’indicateur NumberStyles.AllowCurrencySymbol est inclus.
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 .
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	Séquence de chiffres allant de 0 à 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 s’il `sstyle` inclut l’indicateur NumberStyles.AllowThousands .
.	Symbole décimal spécifique à la culture. Le symbole décimal de la culture définie par `provider` peut apparaître s’il `sstyle` inclut l’indicateur NumberStyles.AllowDecimalPoint .
fractionnaires-chiffres	Séquence de chiffres allant de 0 à 9. Les chiffres fractionnels peuvent apparaître `s` uniquement si `style` l’indicateur NumberStyles.AllowDecimalPoint est inclus.
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 s’il `style` inclut l’indicateur NumberStyles.AllowExponent .

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 .

Valeur NumberStyles	Éléments autorisés en plus des chiffres
None	Élément chiffres uniquement.
AllowDecimalPoint	Éléments . et fractionnaires .
AllowExponent	Le `s` paramètre peut également utiliser la notation exponentielle. Cet indicateur prend en charge les valeurs dans leschiffres E de formulaire ; 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 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`, et . .
Any	Tous les styles, sauf `s` ne peuvent pas représenter un nombre hexadécimal.

Voir aussi

S’applique à

Commentaires

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

Partager via

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