Int32.Parse Méthode

Définition

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

Surcharges

Parse(String, NumberStyles, IFormatProvider)

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

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de plage d'un nombre dans un style et un format propre à une culture spécifiés en entier 32 bits signé équivalent.

Parse(String, NumberStyles)

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

Parse(String)

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

Parse(String, IFormatProvider)

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

Parse(String, NumberStyles, IFormatProvider)

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

public:
 static int Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
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 typique à spécifier est Integer.

provider
IFormatProvider

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

Retours

Int32

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

Exceptions

s a la valeur null.

style n’est pas une valeur NumberStyles.

s n’est pas dans un format compatible avec style.

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

  • ou - s inclut des chiffres fractionnaires différents de zéro.

Exemples

L’exemple suivant utilise une variété de style provider paramètres et pour analyser les représentations sous forme de chaîne de Int32 valeurs. Il illustre également les 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 style paramètre définit les éléments de style (tels qu’un espace blanc ou le signe positif) qui sont autorisés dans le s paramètre pour que l’opération d’analyse aboutisse. Il doit s’agir d’une combinaison de bits indicateurs de l' NumberStyles énumération. Selon la valeur de style , le s paramètre peut inclure les éléments suivants :

Web [$] expéditeur [digits,] digits [.fractional_digist] [e [sign] exponential_digits] [ws]

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

fractional_digits

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

Seul le chiffre 0 peut apparaître sous la forme d’un chiffre fractionnaire pour que l’opération d’analyse aboutisse. Si fractional_digits comprend un autre chiffre, une OverflowException exception est levée.
Envoyer 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 contient l' NumberStyles.AllowExponent indicateur.
hexdigits Séquence de chiffres hexadécimaux comprise entre 0 et f, ou 0 et F.

Notes

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

Une chaîne avec des chiffres décimaux uniquement (qui correspond au NumberStyles.None style) est toujours analysée correctement si elle se trouve dans la plage Int32 du type. La plupart des membres restants NumberStyles contrôlent les éléments qui peuvent être présents dans cette chaîne d’entrée, mais qui ne doivent pas l’être. Le tableau suivant indique comment les NumberStyles membres individuels affectent les éléments qui peuvent être présents dans s .

Valeurs NumberStyles non composites Éléments autorisés dans s en plus des chiffres
NumberStyles.None Chiffres décimaux uniquement.
NumberStyles.AllowDecimalPoint Virgule décimale ( . ) et de chiffres fractionnaires . Toutefois, les chiffres fractionnaires doivent être composés d’un ou plusieurs chiffres 0, sinon une OverflowException est levée.
NumberStyles.AllowExponent Le s paramètre 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 Int32 type de données sans un composant différent de zéro et fractionnaire.
NumberStyles.AllowLeadingWhite Élément WS au début de s .
NumberStyles.AllowTrailingWhite Élément WS à la fin de s .
NumberStyles.AllowLeadingSign Un signe positif peut apparaître avant les chiffres.
NumberStyles.AllowTrailingSign Un signe positif peut apparaître après des chiffres.
NumberStyles.AllowParentheses Élément de signe sous forme de parenthèses entourant la valeur numérique.
NumberStyles.AllowThousands Élément de séparateur des milliers ( , ).
NumberStyles.AllowCurrencySymbol $ Élément.

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

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

Voir aussi

S’applique à

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de plage d'un nombre dans un style et un format propre à une culture spécifiés en entier 32 bits signé équivalent.

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>

Plage 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 typique à spécifier est Integer.

provider
IFormatProvider

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

Retours

Int32

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

S’applique à

Parse(String, NumberStyles)

Convertit une représentation d'un nombre sous forme de chaîne dans un style spécifié en entier 32 bits signé é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 de bits des valeurs d'énumération qui indique les éléments de style qui peuvent être présents dans s. Une valeur typique à spécifier est Integer.

Retours

Int32

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

Exceptions

s a la valeur null.

style n’est pas une valeur NumberStyles.

s n’est pas dans un format compatible avec style.

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

  • ou - s inclut des chiffres fractionnaires différents de zéro.

Exemples

L’exemple suivant utilise la Int32.Parse(String, NumberStyles) méthode pour analyser les représentations sous forme de chaîne de plusieurs Int32 valeurs. 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 style paramètre définit les éléments de style (tels que les espaces blancs, le symbole de signe positif ou négatif ou le symbole de séparateur des milliers) qui sont autorisés dans le s paramètre pour que l’opération d’analyse aboutisse. Il doit s’agir d’une combinaison de bits indicateurs de l' NumberStyles énumération. Selon la valeur de style , le s paramètre peut inclure les éléments suivants :

Web [$] expéditeur [digits,] digits [.fractional_digits] [e [sign] exponential_digits] [ws]

Ou, si style comprend 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. Un espace blanc peut apparaître au début de s si style comprend l' NumberStyles.AllowLeadingWhite indicateur, et il peut apparaître à la fin de s si style comprend l' NumberStyles.AllowTrailingWhite indicateur.
$ Symbole monétaire propre à la culture. Sa position dans la chaîne est définie par les NumberFormatInfo.CurrencyNegativePattern NumberFormatInfo.CurrencyPositivePattern Propriétés et de la culture actuelle. Le symbole monétaire de la culture actuelle peut apparaître dans s si style comprend l' NumberStyles.AllowCurrencySymbol indicateur.
sign Signe facultatif. Le signe peut apparaître au début de s si style comprend l' NumberStyles.AllowLeadingSign indicateur, et il peut apparaître à la fin de s si style contient l' NumberStyles.AllowTrailingSign indicateur. Les parenthèses peuvent être utilisées dans s pour indiquer une valeur négative si style comprend l' NumberStyles.AllowParentheses indicateur.
chiffres

fractional_digits

exponential_digits
Séquence de chiffres comprise entre 0 et 9. Pour fractional_digits, seul le chiffre 0 est valide.
, Symbole de séparateur des milliers spécifique à la culture. Le séparateur des milliers de la culture actuelle peut apparaître dans s si style comprend l' NumberStyles.AllowThousands indicateur.
. Symbole de virgule décimale propre à la culture. Le symbole de virgule décimale de la culture actuelle peut apparaître dans s si style comprend l' NumberStyles.AllowDecimalPoint indicateur. Seul le chiffre 0 peut apparaître sous la forme d’un chiffre fractionnaire pour que l’opération d’analyse aboutisse. Si fractional_digits comprend un autre chiffre, une OverflowException exception est levée.
Envoyer 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 contient l' NumberStyles.AllowExponent indicateur.
hexdigits Séquence de chiffres hexadécimaux comprise entre 0 et f, ou 0 et F.

Notes

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

Une chaîne avec des chiffres uniquement (qui correspond au NumberStyles.None style) est toujours analysée correctement si elle se trouve dans la plage Int32 du type. La plupart des membres restants NumberStyles contrôlent les éléments qui peuvent être présents dans la chaîne d’entrée, mais qui ne doivent pas l’être. Le tableau suivant indique comment les NumberStyles membres individuels 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 Virgule décimale ( . ) et de chiffres fractionnaires .
AllowExponent Le s paramètre peut également utiliser la notation exponentielle.
AllowLeadingWhite Élément WS au début de s .
AllowTrailingWhite Élément WS à la fin de s .
AllowLeadingSign Élément signe au début de s .
AllowTrailingSign Élément signe à la fin de s .
AllowParentheses Élément de signe sous forme de parenthèses entourant la valeur numérique.
AllowThousands Élément de séparateur des milliers ( , ).
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 , se connecte au début de s et la virgule décimale ( . symbole. Le s paramètre peut également utiliser la notation exponentielle.
Number ws, sign , Séparateur des milliers ( , ) et virgule décimale ( . html.
Any Tous les styles, à l’exception s de ne peuvent pas représenter un nombre hexadécimal.

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

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

Voir aussi

S’applique à

Parse(String)

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

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 32 bits signé équivalant au nombre contenu dans s.

Exceptions

s a la valeur null.

Le format de s est incorrect.

s représente un nombre inférieur à MinValue ou supérieur à 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 Int32.Parse(String) méthode. La valeur entière résultante est ensuite affichée sur 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 s paramètre contient un nombre au format suivant :

Web [signe] chiffres [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 allant de 0 à 9.

Le s paramètre est interprété à l’aide du NumberStyles.Integer style. En plus des chiffres décimaux, seuls les espaces de début et de fin, ainsi qu’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 Int32.Parse(String, NumberStyles) méthode ou Int32.Parse(String, NumberStyles, IFormatProvider) .

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

Voir aussi

S’applique à

Parse(String, IFormatProvider)

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

public:
 static int Parse(System::String ^ s, IFormatProvider ^ provider);
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 propres à la culture sur s.

Retours

Int32

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

Exceptions

s a la valeur null.

Le format de s est incorrect.

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

Exemples

L’exemple suivant est le gestionnaire d’événements de clic de bouton d’un formulaire Web. Elle 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' NumberFormatInfo objet qui appartient à cet CultureInfo objet est ensuite transmis à la Parse(String, IFormatProvider) méthode pour convertir l’entrée de l’utilisateur en Int32 valeur.

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

Le s paramètre contient un nombre au format suivant :

Web [signe] chiffres [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 allant de 0 à 9.

Le s paramètre est interprété à l’aide du NumberStyles.Integer style. En plus des chiffres décimaux, seuls les espaces de début et de fin, ainsi qu’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 Int32.Parse(String, NumberStyles, IFormatProvider) méthode.

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

Voir aussi

S’applique à