Partage via

Int32.Parse Méthode

  • Référence

Définition

Espace de noms:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Convertit la représentation sous forme de chaîne d’un nombre en son entier signé 32 bits équivalent.

Surcharges

Parse(String)

Convertit la représentation sous forme de chaîne d’un nombre en son entier signé 32 bits é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 entier signé 32 bits équivalent.
Parse(String, IFormatProvider)

Convertit la représentation sous forme de chaîne d’un nombre dans un format spécifique à la culture spécifié en entier signé 32 bits équivalent.
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 dans un style et un format spécifique à la culture spécifiés en son équivalent entier signé 32 bits.
Parse(String, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de chaîne d’un nombre dans un format spécifique à la culture et au style spécifié en entier signé 32 bits équivalent.

Parse(String)

Source:
Int32.cs
Source:
Int32.cs
Source:
Int32.cs

Convertit la représentation sous forme de chaîne d’un nombre en son entier signé 32 bits équivalent.

public:
 static int Parse(System::String ^ s);
public static int Parse (string s);
static member Parse : string -> int
Public Shared Function Parse (s As String) As Integer

Paramètres

s
String

Chaîne contenant un nombre à convertir.

Retours

Int32

Entier signé 32 bits équivalent au nombre contenu dans s.

Exceptions

ArgumentNullException

s est null.

FormatException

s n’est pas au format correct.

OverflowException

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

Exemples

L’exemple suivant montre comment convertir une valeur de chaîne en valeur entière signée 32 bits à l’aide de la méthode Int32.Parse(String). La valeur entière résultante est ensuite affichée dans la console.

using namespace System;

void main()
{
   array<String^>^ values = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                              "0xFA1B", "163042", "-10", "007", "2147483647", 
                              "2147483648", "16e07", "134985.0", "-12034",
                              "-2147483648", "-2147483649" };
   for each (String^ value in values)
   {
      try {
         Int32 number = Int32::Parse(value); 
         Console::WriteLine("{0} --> {1}", value, number);
      }
      catch (FormatException^ e) {
         Console::WriteLine("{0}: Bad Format", value);
      }   
      catch (OverflowException^ e) {
         Console::WriteLine("{0}: Overflow", value);   
      }  
   }
}
// The example displays the following output:
//       +13230 --> 13230
//       -0 --> 0
//       1,390,146: Bad Format
//       $190,235,421,127: Bad Format
//       0xFA1B: Bad Format
//       163042 --> 163042
//       -10 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                          "0xFA1B", "163042", "-10", "007", "2147483647",
                          "2147483648", "16e07", "134985.0", "-12034",
                          "-2147483648", "-2147483649" };
      foreach (string value in values)
      {
         try {
            int number = Int32.Parse(value);
            Console.WriteLine("{0} --> {1}", value, number);
         }
         catch (FormatException) {
            Console.WriteLine("{0}: Bad Format", value);
         }
         catch (OverflowException) {
            Console.WriteLine("{0}: Overflow", value);
         }
      }
   }
}
// The example displays the following output:
//       +13230 --> 13230
//       -0 --> 0
//       1,390,146: Bad Format
//       $190,235,421,127: Bad Format
//       0xFA1B: Bad Format
//       163042 --> 163042
//       -10 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow

open System

let values =
    [ "+13230"; "-0"; "1,390,146"; "$190,235,421,127"
      "0xFA1B"; "163042"; "-10"; "007"; "2147483647"
      "2147483648"; "16e07"; "134985.0"; "-12034"
      "-2147483648"; "-2147483649" ]

for value in values do
    try
        let number = Int32.Parse value
        printfn $"{value} --> {number}"
    with 
    | :? FormatException ->
        printfn $"{value}: Bad Format"
    | :? OverflowException ->
        printfn $"{value}: Overflow"
    

// The example displays the following output:
//       +13230 --> 13230
//       -0 --> 0
//       1,390,146: Bad Format
//       $190,235,421,127: Bad Format
//       0xFA1B: Bad Format
//       163042 --> 163042
//       -10 --> -10
//       007 --> 7
//       2147483647 --> 2147483647
//       2147483648: Overflow
//       16e07: Bad Format
//       134985.0: Bad Format
//       -12034 --> -12034
//       -2147483648 --> -2147483648
//       -2147483649: Overflow

Module Example
   Public Sub Main()
      Dim values() As String = { "+13230", "-0", "1,390,146", "$190,235,421,127",
                                 "0xFA1B", "163042", "-10", "007", "2147483647", 
                                 "2147483648", "16e07", "134985.0", "-12034",
                                 "-2147483648", "-2147483649"  }
      For Each value As String In values
         Try
            Dim number As Integer = Int32.Parse(value) 
            Console.WriteLine("{0} --> {1}", value, number)
         Catch e As FormatException
            Console.WriteLine("{0}: Bad Format", value)
         Catch e As OverflowException
            Console.WriteLine("{0}: Overflow", value)   
         End Try  
      Next
   End Sub
End Module
' The example displays the following output:
'       +13230 --> 13230
'       -0 --> 0
'       1,390,146: Bad Format
'       $190,235,421,127: Bad Format
'       0xFA1B: Bad Format
'       163042 --> 163042
'       -10 --> -10
'       007 --> 7
'       2147483647 --> 2147483647
'       2147483648: Overflow
'       16e07: Bad Format
'       134985.0: Bad Format
'       -12034 --> -12034
'       -2147483648 --> -2147483648
'       -2147483649: Overflow

Remarques

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

[ws] [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.
signe Signe facultatif.
Chiffres Séquence de chiffres allant de 0 à 9.

Le paramètre s est interprété à l’aide du style NumberStyles.Integer. En plus des chiffres décimaux, seuls les espaces de début et de fin avec un signe de début sont autorisés. Pour définir explicitement les éléments de style qui peuvent être présents dans s, utilisez l'Int32.Parse(String, NumberStyles) ou la méthode Int32.Parse(String, NumberStyles, IFormatProvider).

Le paramètre s est analysé à l’aide des informations de mise en forme dans un objet 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 méthode Int32.Parse(String, NumberStyles, IFormatProvider).

Voir aussi

S’applique à

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Source:
Int32.cs
Source:
Int32.cs

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

public:
 static int Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<int>::Parse;
public static int Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);
static member Parse : ReadOnlySpan<byte> * IFormatProvider -> int
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As Integer

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

Int32

Résultat de l’analyse utf8Text.

Implémente

Parse(ReadOnlySpan<Byte>, IFormatProvider)

S’applique à

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:
Int32.cs
Source:
Int32.cs
Source:
Int32.cs

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

public:
 static int Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<int>::Parse;
public static int Parse (ReadOnlySpan<char> s, IFormatProvider? provider);
static member Parse : ReadOnlySpan<char> * IFormatProvider -> int
Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As Integer

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

Int32

Résultat de l’analyse s.

Implémente

Parse(ReadOnlySpan<Char>, IFormatProvider)

S’applique à

Parse(String, NumberStyles)

Source:
Int32.cs
Source:
Int32.cs
Source:
Int32.cs

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

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style);
public static int Parse (string s, System.Globalization.NumberStyles style);
static member Parse : string * System.Globalization.NumberStyles -> int
Public Shared Function Parse (s As String, style As NumberStyles) As Integer

Paramètres

s
String

Chaîne contenant un nombre à convertir.

style
NumberStyles

Combinaison au niveau du bit des valeurs d’énumération qui indique les éléments de style qui peuvent être présents dans s. Une valeur classique à spécifier est Integer.

Retours

Int32

Entier signé 32 bits équivalent au nombre spécifié dans s.

Exceptions

ArgumentNullException

s est null.

ArgumentException

style n’est pas une valeur NumberStyles.

-ou-

style n’est pas une combinaison de valeurs de AllowHexSpecifier et de HexNumber.

FormatException

s n’est pas dans un format conforme à style.

OverflowException

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

-ou-

s inclut des chiffres non nuls, fractionnaires.

Exemples

L’exemple suivant utilise la méthode Int32.Parse(String, NumberStyles) pour analyser les représentations sous forme de chaîne de plusieurs valeurs Int32. La culture actuelle de l’exemple est en-US.

using namespace System;
using namespace System::Globalization;

public ref class ParseInt32
{
public:
   static void Main()
   {
      Convert("104.0", NumberStyles::AllowDecimalPoint);
      Convert("104.9", NumberStyles::AllowDecimalPoint);
      Convert(" $17,198,064.42", NumberStyles::AllowCurrencySymbol |
                                 NumberStyles::Number);
      Convert("103E06", NumberStyles::AllowExponent);
      Convert("-1,345,791", NumberStyles::AllowThousands);
      Convert("(1,345,791)", NumberStyles::AllowThousands |
                             NumberStyles::AllowParentheses);
   }

private:
   static void Convert(String^ value, NumberStyles style)
   {
      try
      {
         int number = Int32::Parse(value, style);
         Console::WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException^)
      {
         Console::WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException^)
      {
         Console::WriteLine("'{0}' is out of range of the Int32 type.", value);
      }
   }
};

int main()
{
    ParseInt32::Main();
}
// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.

using System;
using System.Globalization;

public class ParseInt32
{
   public static void Main()
   {
      Convert("104.0", NumberStyles.AllowDecimalPoint);
      Convert("104.9", NumberStyles.AllowDecimalPoint);
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol |
                                 NumberStyles.Number);
      Convert("103E06", NumberStyles.AllowExponent);
      Convert("-1,345,791", NumberStyles.AllowThousands);
      Convert("(1,345,791)", NumberStyles.AllowThousands |
                             NumberStyles.AllowParentheses);
   }

   private static void Convert(string value, NumberStyles style)
   {
      try
      {
         int number = Int32.Parse(value, style);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value);
      }
   }
}
// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.

open System
open System.Globalization

let convert value (style: NumberStyles) =
    try
        let number = Int32.Parse(value, style)
        printfn $"Converted '{value}' to {number}."
    with 
    | :? FormatException ->
        printfn $"Unable to convert '{value}'."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the Int32 type."

convert "104.0" NumberStyles.AllowDecimalPoint
convert "104.9" NumberStyles.AllowDecimalPoint
convert " $17,198,064.42" (NumberStyles.AllowCurrencySymbol ||| NumberStyles.Number)
convert "103E06" NumberStyles.AllowExponent
convert "-1,345,791" NumberStyles.AllowThousands
convert "(1,345,791)" (NumberStyles.AllowThousands ||| NumberStyles.AllowParentheses)


// The example displays the following output to the console:
//       Converted '104.0' to 104.
//       '104.9' is out of range of the Int32 type.
//       ' $17,198,064.42' is out of range of the Int32 type.
//       Converted '103E06' to 103000000.
//       Unable to convert '-1,345,791'.
//       Converted '(1,345,791)' to -1345791.

Imports System.Globalization

Module ParseInt32
   Public Sub Main()
      Convert("104.0", NumberStyles.AllowDecimalPoint)    
      Convert("104.9", NumberStyles.AllowDecimalPoint)
      Convert(" $17,198,064.42", NumberStyles.AllowCurrencySymbol Or _
                                 NumberStyles.Number)
      Convert("103E06", NumberStyles.AllowExponent)  
      Convert("-1,345,791", NumberStyles.AllowThousands)
      Convert("(1,345,791)", NumberStyles.AllowThousands Or _
                             NumberStyles.AllowParentheses)
   End Sub
   
   Private Sub Convert(value As String, style As NumberStyles)
      Try
         Dim number As Integer = Int32.Parse(value, style)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value)   
      End Try
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '104.0' to 104.
'       '104.9' is out of range of the Int32 type.
'       ' $17,198,064.42' is out of range of the Int32 type.
'       Converted '103E06' to 103000000.
'       Unable to convert '-1,345,791'.
'       Converted '(1,345,791)' to -1345791.

Remarques

Le paramètre style définit les éléments de style (tels que l’espace blanc, le symbole de signe positif ou négatif ou le symbole de séparateur de milliers) autorisés dans le paramètre s 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. Selon la valeur de style, le paramètre s peut inclure les éléments suivants :

[ws] [$] [sign] [chiffres,]chiffres[.fractional_digits][e[sign]exponential_digits][ws]

Ou, si style inclut AllowHexSpecifier:

[ws]hexdigits[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 de NumberStyles.AllowLeadingWhite, et il peut apparaître à la fin de s si style inclut l’indicateur de NumberStyles.AllowTrailingWhite.
$ Symbole monétaire propre à la culture. Sa position dans la chaîne est définie par les propriétés NumberFormatInfo.CurrencyNegativePattern 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 de NumberStyles.AllowCurrencySymbol.
signer Signe facultatif. Le signe peut apparaître au début de s si style inclut l’indicateur de NumberStyles.AllowLeadingSign et qu’il peut apparaître à la fin de s si style inclut l’indicateur de NumberStyles.AllowTrailingSign. Les parenthèses peuvent être utilisées dans s pour indiquer une valeur négative si style inclut l’indicateur de NumberStyles.AllowParentheses.
chiffres

fractional_digits

exponential_digits		 Séquence de chiffres comprises entre 0 et 9. Pour fractional_digits, seul le chiffre 0 est valide.
, Symbole de séparateur de milliers spécifique à la culture. Le séparateur de milliers de la culture actuelle peut apparaître dans s si style inclut l’indicateur de 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 de NumberStyles.AllowDecimalPoint. Seul le chiffre 0 peut apparaître sous la forme d’un chiffre fractionnel pour que l’opération d’analyse réussisse ; si fractional_digits inclut un autre chiffre, une OverflowException est levée.
e Caractère « e » ou « E », qui indique que la valeur est représentée en notation exponentielle. Le paramètre s peut représenter un nombre en notation exponentielle si style inclut l’indicateur de NumberStyles.AllowExponent.
hexdigits Séquence de chiffres hexadécimaux de 0 à f, ou de 0 à F.

Note

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 style NumberStyles.None) analyse toujours correctement s’il se trouve dans la plage du type Int32. La plupart des éléments de contrôle NumberStyles membres restants 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 de NumberStyles individuels affectent les éléments qui peuvent être présents dans s.

Valeur NumberStyles Éléments autorisés en plus des chiffres
None Les chiffres élément uniquement.
AllowDecimalPoint Point décimal ( . ) et chiffres fractionnels éléments.
AllowExponent Le paramètre s peut également utiliser la notation exponentielle.
AllowLeadingWhite L’élément ws au début de s.
AllowTrailingWhite L’élément ws à la fin de s.
AllowLeadingSign Signe élément au début de s.
AllowTrailingSign Signe élément à la fin de s.
AllowParentheses Signe élément sous la forme de parenthèses englobant la valeur numérique.
AllowThousands Élément séparateur de milliers ( , ).
AllowCurrencySymbol Élément $.
Currency Tout. Le paramètre s 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 décimal ( . ). Le paramètre s peut également utiliser la notation exponentielle.
Number Éléments ws, sign, séparateur de milliers ( , ) et décimale ( . ).
Any Tous les styles, sauf s ne peuvent pas représenter un nombre hexadécimal.

Si l’indicateur NumberStyles.AllowHexSpecifier est utilisé, s doit être une valeur hexadécimale sans préfixe. Par exemple, « C9AF3 » analyse correctement, mais « 0xC9AF3 » ne le fait pas. Les seuls autres indicateurs qui peuvent être combinés avec le paramètre s qu’il est NumberStyles.AllowLeadingWhite et NumberStyles.AllowTrailingWhite. (L’énumération NumberStyles comprend un style de nombre composite, NumberStyles.HexNumber, qui inclut les deux indicateurs d’espace blanc.)

Le paramètre s est analysé à l’aide des informations de mise en forme dans un objet NumberFormatInfo initialisé pour la culture système actuelle. Pour spécifier la culture dont les informations de mise en forme sont utilisées pour l’opération d’analyse, appelez la surcharge Int32.Parse(String, NumberStyles, IFormatProvider).

Voir aussi

S’applique à

Parse(String, IFormatProvider)

Source:
Int32.cs
Source:
Int32.cs
Source:
Int32.cs

Convertit la représentation sous forme de chaîne d’un nombre dans un format spécifique à la culture spécifié en entier signé 32 bits équivalent.

public:
 static int Parse(System::String ^ s, IFormatProvider ^ provider);
public:
 static int Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<int>::Parse;
public static int Parse (string s, IFormatProvider provider);
public static int Parse (string s, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> int
Public Shared Function Parse (s As String, provider As IFormatProvider) As Integer

Paramètres

s
String

Chaîne contenant un nombre à convertir.

provider
IFormatProvider

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

Retours

Int32

Entier signé 32 bits équivalent au nombre spécifié dans s.

Implémente

Parse(String, IFormatProvider)

Exceptions

ArgumentNullException

s est null.

FormatException

s n’est pas du format correct.

OverflowException

s représente un nombre inférieur à Int32.MinValue ou supérieur à Int32.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 propriété HttpRequest.UserLanguages pour déterminer les paramètres régionaux de l’utilisateur. Il instancie ensuite un objet CultureInfo qui correspond à ces paramètres régionaux. L’objet NumberFormatInfo qui appartient à cet objet CultureInfo est ensuite passé à la méthode Parse(String, IFormatProvider) pour convertir l’entrée de l’utilisateur en valeur Int32.

protected void OkToInteger_Click(object sender, EventArgs e)
{
    string locale;
    int 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 = Int32.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 OkToInteger_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles OkToInteger.Click
   Dim locale As String
   Dim culture As CultureInfo
   Dim number As Integer

   ' 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 = Int32.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 méthode Parse(String, IFormatProvider) est généralement utilisée pour convertir du texte pouvant être mis en forme de différentes manières en une valeur Int32. Par exemple, il peut être utilisé pour convertir le texte entré par un utilisateur en zone de texte HTML en valeur numérique.

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

[ws] [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.
signer Signe facultatif.
chiffres Séquence de chiffres allant de 0 à 9.

Le paramètre s est interprété à l’aide du style NumberStyles.Integer. En plus des chiffres décimaux, seuls les espaces de début et de fin avec un signe de début sont autorisés. Pour définir explicitement les éléments de style qui peuvent être présents dans s, utilisez la méthode Int32.Parse(String, NumberStyles, IFormatProvider).

Le paramètre provider est une implémentation IFormatProvider, telle qu’un objet NumberFormatInfo ou CultureInfo. Le paramètre provider fournit des informations spécifiques à la culture sur le format de s. Si provider est null, l’objet NumberFormatInfo de la culture actuelle est utilisé.

Voir aussi

S’applique à

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Source:
Int32.cs
Source:
Int32.cs

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

public static int Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
static member Parse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider -> int
Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Integer

Paramètres

utf8Text
ReadOnlySpan<Byte>

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

style
NumberStyles

Combinaison au niveau du bit des 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

Int32

Résultat de l’analyse utf8Text.

Implémente

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

S’applique à

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:
Int32.cs
Source:
Int32.cs
Source:
Int32.cs

Convertit la représentation d’étendue d’un nombre dans un style et un format spécifique à la culture spécifiés en son équivalent entier signé 32 bits.

public static int Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
public static int Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);
static member Parse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider -> int
Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As Integer

Paramètres

s
ReadOnlySpan<Char>

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

style
NumberStyles

Combinaison de bits de valeurs d’énumération qui indique les éléments de style qui peuvent être présents dans s. Une valeur classique à spécifier est Integer.

provider
IFormatProvider

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

Retours

Int32

Entier signé 32 bits équivalent au nombre spécifié dans s.

Implémente

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

S’applique à

Parse(String, NumberStyles, IFormatProvider)

Source:
Int32.cs
Source:
Int32.cs
Source:
Int32.cs

Convertit la représentation sous forme de chaîne d’un nombre dans un format spécifique à la culture et au style spécifié en entier signé 32 bits équivalent.

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<int>::Parse;
public static int Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static int Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> int
Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As Integer

Paramètres

s
String

Chaîne contenant un nombre à convertir.

style
NumberStyles

Combinaison de bits de valeurs d’énumération qui indique les éléments de style qui peuvent être présents dans s. Une valeur classique à spécifier est Integer.

provider
IFormatProvider

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

Retours

Int32

Entier signé 32 bits équivalent au nombre spécifié dans s.

Implémente

Parse(String, NumberStyles, IFormatProvider)

Exceptions

ArgumentNullException

s est null.

ArgumentException

style n’est pas une valeur NumberStyles.

-ou-

style n’est pas une combinaison de valeurs de AllowHexSpecifier et de HexNumber.

FormatException

s n’est pas dans un format conforme à style.

OverflowException

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

-ou-

s inclut des chiffres non nuls, fractionnaires.

Exemples

L’exemple suivant utilise une variété de paramètres style et provider pour analyser les représentations sous forme de chaînes de valeurs Int32. Il illustre également certaines des différentes façons dont la même chaîne peut être interprétée en fonction de la culture dont les informations de mise en forme sont utilisées pour l’opération d’analyse.

using namespace System;
using namespace System::Globalization;

public ref class ParseInt32
{
public:
   static void Main()
   {
      Convert("12,000", NumberStyles::Float | NumberStyles::AllowThousands, 
              gcnew CultureInfo("en-GB"));
      Convert("12,000", NumberStyles::Float | NumberStyles::AllowThousands,
              gcnew CultureInfo("fr-FR"));
      Convert("12,000", NumberStyles::Float, gcnew CultureInfo("en-US"));

      Convert("12 425,00", NumberStyles::Float | NumberStyles::AllowThousands,
              gcnew CultureInfo("sv-SE"));
      Convert("12,425.00", NumberStyles::Float | NumberStyles::AllowThousands,
              NumberFormatInfo::InvariantInfo);
      Convert("631,900", NumberStyles::Integer | NumberStyles::AllowDecimalPoint, 
              gcnew CultureInfo("fr-FR"));
      Convert("631,900", NumberStyles::Integer | NumberStyles::AllowDecimalPoint,
              gcnew CultureInfo("en-US"));
      Convert("631,900", NumberStyles::Integer | NumberStyles::AllowThousands,
              gcnew CultureInfo("en-US"));
   }

private:
   static void Convert(String^ value, NumberStyles style,
                               IFormatProvider^ provider)
   {
      try
      {
         int number = Int32::Parse(value, style, provider);
         Console::WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException^)
      {
         Console::WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException^)
      {
         Console::WriteLine("'{0}' is out of range of the Int32 type.", value);   
      }
   }                               
};

int main()
{
    ParseInt32::Main();
}
// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

using System;
using System.Globalization;

public class ParseInt32
{
   public static void Main()
   {
      Convert("12,000", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("en-GB"));
      Convert("12,000", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("fr-FR"));
      Convert("12,000", NumberStyles.Float, new CultureInfo("en-US"));

      Convert("12 425,00", NumberStyles.Float | NumberStyles.AllowThousands,
              new CultureInfo("sv-SE"));
      Convert("12,425.00", NumberStyles.Float | NumberStyles.AllowThousands,
              NumberFormatInfo.InvariantInfo);
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowDecimalPoint,
              new CultureInfo("fr-FR"));
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowDecimalPoint,
              new CultureInfo("en-US"));
      Convert("631,900", NumberStyles.Integer | NumberStyles.AllowThousands,
              new CultureInfo("en-US"));
   }

   private static void Convert(string value, NumberStyles style,
                               IFormatProvider provider)
   {
      try
      {
         int number = Int32.Parse(value, style, provider);
         Console.WriteLine("Converted '{0}' to {1}.", value, number);
      }
      catch (FormatException)
      {
         Console.WriteLine("Unable to convert '{0}'.", value);
      }
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value);
      }
   }
}
// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

open System
open System.Globalization

let convert (value: string) (style: NumberStyles) (provider: IFormatProvider) =
    try
        let number = Int32.Parse(value, style, provider)
        printfn $"Converted '{value}' to {number}."
    with 
    | :? FormatException ->
        printfn $"Unable to convert '{value}'."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the Int32 type."

convert "12,000" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "en-GB")
convert "12,000" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "fr-FR")
convert "12,000" NumberStyles.Float (CultureInfo "en-US")
convert "12 425,00" (NumberStyles.Float ||| NumberStyles.AllowThousands) (CultureInfo "sv-SE")
convert "12,425.00" (NumberStyles.Float ||| NumberStyles.AllowThousands) NumberFormatInfo.InvariantInfo
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint) (CultureInfo "fr-FR")
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint) (CultureInfo "en-US")
convert "631,900" (NumberStyles.Integer ||| NumberStyles.AllowThousands) (CultureInfo "en-US")

// This example displays the following output to the console:
//       Converted '12,000' to 12000.
//       Converted '12,000' to 12.
//       Unable to convert '12,000'.
//       Converted '12 425,00' to 12425.
//       Converted '12,425.00' to 12425.
//       '631,900' is out of range of the Int32 type.
//       Unable to convert '631,900'.
//       Converted '631,900' to 631900.

Imports System.Globalization

Module ParseInt32
   Public Sub Main()
      Convert("12,000", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("en-GB"))      
      Convert("12,000", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("fr-FR"))
      Convert("12,000", NumberStyles.Float, New CultureInfo("en-US"))
      
      Convert("12 425,00", NumberStyles.Float Or NumberStyles.AllowThousands, _
              New CultureInfo("sv-SE")) 
      Convert("12,425.00", NumberStyles.Float Or NumberStyles.AllowThousands, _
              NumberFormatInfo.InvariantInfo) 
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowDecimalPoint, _ 
              New CultureInfo("fr-FR"))
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowDecimalPoint, _
              New CultureInfo("en-US"))
      Convert("631,900", NumberStyles.Integer Or NumberStyles.AllowThousands, _
              New CultureInfo("en-US"))
   End Sub

   Private Sub Convert(value As String, style As NumberStyles, _
                       provider As IFormatProvider)
      Try
         Dim number As Integer = Int32.Parse(value, style, provider)
         Console.WriteLine("Converted '{0}' to {1}.", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to convert '{0}'.", value)
      Catch e As OverflowException
         Console.WriteLine("'{0}' is out of range of the Int32 type.", value)   
      End Try
   End Sub                       
End Module
' This example displays the following output to the console:
'       Converted '12,000' to 12000.
'       Converted '12,000' to 12.
'       Unable to convert '12,000'.
'       Converted '12 425,00' to 12425.
'       Converted '12,425.00' to 12425.
'       '631,900' is out of range of the Int32 type.
'       Unable to convert '631,900'.
'       Converted '631,900' to 631900.

Remarques

Le paramètre style définit les éléments de style (tels que l’espace blanc ou le signe positif) autorisés dans le paramètre s 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. Selon la valeur de style, le paramètre s peut inclure les éléments suivants :

[ws] [$] [sign] [chiffres,]chiffres[.fractional_digist][e[sign]exponential_digits][ws]

Ou, si style inclut AllowHexSpecifier:

[ws]hexdigits[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 de NumberStyles.AllowLeadingWhite, et il peut apparaître à la fin de s si style inclut l’indicateur de NumberStyles.AllowTrailingWhite.
$ Symbole monétaire propre à la culture. Sa position dans la chaîne est définie par la propriété NumberFormatInfo.CurrencyPositivePattern de l’objet NumberFormatInfo retourné par la méthode GetFormat du paramètre provider. Le symbole monétaire peut apparaître dans s si style inclut l’indicateur de NumberStyles.AllowCurrencySymbol.
signer Signe facultatif. Le signe peut apparaître au début de s si style inclut l’indicateur de NumberStyles.AllowLeadingSign ou à la fin de s si style inclut l’indicateur de NumberStyles.AllowTrailingSign. Les parenthèses peuvent être utilisées dans s pour indiquer une valeur négative si style inclut l’indicateur de NumberStyles.AllowParentheses.
chiffres

fractional_digits

exponential_digits		 Séquence de chiffres comprises entre 0 et 9. Pour fractional_digits, seul le chiffre 0 est valide.
, Symbole de séparateur de milliers spécifique à la culture. Le séparateur de milliers de la culture spécifiée par provider peut apparaître dans s si style inclut l’indicateur de NumberStyles.AllowThousands.
. Symbole décimal spécifique à la culture. Le symbole décimal de la culture spécifiée par provider peut apparaître dans s si style inclut l’indicateur de NumberStyles.AllowDecimalPoint.

Seul le chiffre 0 peut apparaître sous la forme d’un chiffre fractionnel pour que l’opération d’analyse réussisse ; si fractional_digits inclut un autre chiffre, une OverflowException est levée.
e Caractère « e » ou « E », qui indique que la valeur est représentée en notation exponentielle. Le paramètre s peut représenter un nombre en notation exponentielle si style inclut l’indicateur de NumberStyles.AllowExponent.
hexdigits Séquence de chiffres hexadécimaux de 0 à f, ou de 0 à F.

Note

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 décimaux uniquement (qui correspond au style NumberStyles.None) analyse toujours correctement si elle se trouve dans la plage du type Int32. La plupart des éléments de contrôle NumberStyles membres restants qui peuvent être, mais qui ne sont pas obligatoires pour être présents dans cette chaîne d’entrée. Le tableau suivant indique comment les membres de NumberStyles individuels affectent les éléments qui peuvent être présents dans s.

Valeurs NumberStyles non composites Éléments autorisés en plus des chiffres
NumberStyles.None Chiffres décimaux uniquement.
NumberStyles.AllowDecimalPoint Point décimal ( . ) et chiffres fractionnels éléments. Toutefois, fractionnaires doivent comporter un ou plusieurs chiffres ou un OverflowException est levée.
NumberStyles.AllowExponent Le paramètre s peut également utiliser la notation exponentielle. Si s représente un nombre en notation exponentielle, il doit représenter un entier dans la plage du type de données Int32 sans composant fractionnaire non nul.
NumberStyles.AllowLeadingWhite L’élément ws au début de s.
NumberStyles.AllowTrailingWhite L’élément ws à la fin de s.
NumberStyles.AllowLeadingSign Un signe positif peut apparaître avant chiffres.
NumberStyles.AllowTrailingSign Un signe positif peut apparaître après chiffres.
NumberStyles.AllowParentheses Signe élément sous la forme de parenthèses englobant la valeur numérique.
NumberStyles.AllowThousands Élément séparateur de milliers ( , ).
NumberStyles.AllowCurrencySymbol Élément $.

Si l’indicateur NumberStyles.AllowHexSpecifier est utilisé, s doit être une valeur hexadécimale sans préfixe. Par exemple, « C9AF3 » analyse correctement, mais « 0xC9AF3 » ne le fait pas. Les seuls autres indicateurs qui peuvent être présents dans style sont NumberStyles.AllowLeadingWhite et NumberStyles.AllowTrailingWhite. (L’énumération NumberStyles a un style de nombre composite, NumberStyles.HexNumber, qui inclut les deux indicateurs d’espace blanc.)

Le paramètre provider est une implémentation IFormatProvider, telle qu’un objet NumberFormatInfo ou CultureInfo. Le paramètre provider fournit des informations spécifiques à la culture utilisées dans l’analyse. Si provider est null, l’objet NumberFormatInfo de la culture actuelle est utilisé.

Voir aussi

S’applique à