Int32.TryParse Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.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 équivalent entier 32 bits signé. Une valeur de retour indique si l'opération a réussi.

Surcharges

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int32)	Tente d’analyser une étendue de caractères UTF-8 dans une valeur.
TryParse(ReadOnlySpan<Char>, Int32)	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. Une valeur de retour indique si la conversion a réussi.
TryParse(String, Int32)	Convertit la représentation sous forme de chaîne d'un nombre en son équivalent entier 32 bits signé. Une valeur de retour indique si la conversion a réussi.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)	Tente d’analyser une étendue de caractères dans une valeur.
TryParse(String, IFormatProvider, Int32)	Tente d’analyser une chaîne dans une valeur.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int32)	Tente d’analyser une étendue de caractères UTF-8 dans une valeur.
TryParse(ReadOnlySpan<Byte>, Int32)	Tente de convertir une étendue de caractères UTF-8 contenant la représentation sous forme de chaîne d’un nombre en entier signé 32 bits équivalent.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)	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. Une valeur de retour indique si la conversion a réussi.
TryParse(String, NumberStyles, IFormatProvider, Int32)	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. Une valeur de retour indique si la conversion a réussi.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int32)

Source:: Int32.cs

Source:: Int32.cs

Tente d’analyser une étendue de caractères UTF-8 dans une valeur.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = IUtf8SpanParsable<int>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out int result);

static member TryParse : ReadOnlySpan<byte> * IFormatProvider * int -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As Integer) As Boolean

Paramètres

utf8Text: ReadOnlySpan<Byte>

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

provider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant utf8Text.

result: Int32

Au retour, contient le résultat de l’analyse utf8Text réussie ou une valeur non définie en cas d’échec.

Retours

Boolean

true si utf8Text a été correctement analysé ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Char>, Int32)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

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. Une valeur de retour indique si la conversion a réussi.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] int % result);

public static bool TryParse (ReadOnlySpan<char> s, out int result);

static member TryParse : ReadOnlySpan<char> * int -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As Integer) As Boolean

Paramètres

s: ReadOnlySpan<Char>

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

result: Int32

Quand cette méthode est retournée, contient la valeur de l'entier signé 32 bits équivalente au nombre contenu dans s si la conversion a réussi, ou zéro si elle a échoué. La conversion échoue si le s paramètre est null ou Empty, n’est pas dans un format conforme à styleou représente un nombre inférieur à Int32.MinValue ou supérieur à Int32.MaxValue. Ce paramètre est passé non initialisé ; toute valeur fournie initialement dans result sera remplacée.

Retours

Boolean

true si la conversion de s est réussie ; sinon, false.

S’applique à

TryParse(String, Int32)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Convertit la représentation sous forme de chaîne d'un nombre en son équivalent entier 32 bits signé. Une valeur de retour indique si la conversion a réussi.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] int % result);

public static bool TryParse (string s, out int result);

public static bool TryParse (string? s, out int result);

static member TryParse : string * int -> bool

Public Shared Function TryParse (s As String, ByRef result As Integer) As Boolean

Paramètres

s: String

Chaîne contenant un nombre à convertir.

result: Int32

Quand cette méthode est retournée, contient la valeur de l'entier signé 32 bits équivalente au nombre contenu dans s si la conversion a réussi, ou zéro si elle a échoué. La conversion échoue si le s paramètre est null ou Empty, n’est pas au format correct, ou représente un nombre inférieur à Int32.MinValue ou supérieur à Int32.MaxValue. Ce paramètre est passé non initialisé ; toute valeur fournie initialement dans result sera remplacée.

Retours

Boolean

true si la conversion de s est réussie ; sinon, false.

Exemples

L’exemple suivant appelle la Int32.TryParse(String, Int32) méthode avec plusieurs valeurs de chaîne différentes.

using namespace System;


   void TryToParse(String^ value)
   {
      Int32 number;
      bool result = Int32::TryParse(value, number);
      if (result) {
         Console::WriteLine("Converted '{0}' to {1}.", value, number);
      }
      else {
         if (value == nullptr) value = "";
         Console::WriteLine("Attempted conversion of '{0}' failed.", value);
      }
   }


void main()
{
      TryToParse(nullptr);
      TryToParse("160519");
      TryToParse("9432.0");
      TryToParse("16,667");
      TryToParse("   -322   ");
      TryToParse("+4302");
      TryToParse("(100);");
      TryToParse("01FA");
}
// The example displays the following output:
//      Attempted conversion of '' failed.
//      Converted '160519' to 160519.
//      Attempted conversion of '9432.0' failed.
//      Attempted conversion of '16,667' failed.
//      Converted '   -322   ' to -322.
//      Converted '+4302' to 4302.
//      Attempted conversion of '(100);' failed.
//      Attempted conversion of '01FA' failed.

using System;

public class Example
{
   public static void Main()
   {
      string[] values = { null, "160519", "9432.0", "16,667",
                          "   -322   ", "+4302", "(100);", "01FA" };
      foreach (var value in values)
      {
         int number;

         bool success = int.TryParse(value, out number);
         if (success)
         {
            Console.WriteLine($"Converted '{value}' to {number}.");
         }
         else
         {
            Console.WriteLine($"Attempted conversion of '{value ?? "<null>"}' failed.");
         }
      }
   }
}
// The example displays the following output:
//       Attempted conversion of '<null>' failed.
//       Converted '160519' to 160519.
//       Attempted conversion of '9432.0' failed.
//       Attempted conversion of '16,667' failed.
//       Converted '   -322   ' to -322.
//       Converted '+4302' to 4302.
//       Attempted conversion of '(100);' failed.
//       Attempted conversion of '01FA' failed.

open System

let values = 
   [ null; "160519"; "9432.0"; "16,667"
     "   -322   "; "+4302"; "(100);"; "01FA" ]
for value in values do
    match Int32.TryParse value with
    | true, number -> 
        printfn $"Converted '{value}' to {number}."
    | _ -> 
        printfn $"""Attempted conversion of '{if isNull value then "<null>" else value}' failed."""
         
// The example displays the following output:
//       Attempted conversion of '<null>' failed.
//       Converted '160519' to 160519.
//       Attempted conversion of '9432.0' failed.
//       Attempted conversion of '16,667' failed.
//       Converted '   -322   ' to -322.
//       Converted '+4302' to 4302.
//       Attempted conversion of '(100);' failed.
//       Attempted conversion of '01FA' failed.

Module Example
   Public Sub Main()
      Dim values() As String = { Nothing, "160519", "9432.0", "16,667",
                                 "   -322   ", "+4302", "(100);", 
                                 "01FA" }

      For Each value In values
         Dim number As Integer
    
         Dim success As Boolean = Int32.TryParse(value, number)
         If success Then
            Console.WriteLine("Converted '{0}' to {1}.", value, number)
         Else
            Console.WriteLine("Attempted conversion of '{0}' failed.", 
                              If(value ,"<null>"))
         End If     
      Next
   End Sub
End Module
' The example displays the following output to the console:
'       Attempted conversion of '<null>' failed.
'       Converted '160519' to 160519.
'       Attempted conversion of '9432.0' failed.
'       Attempted conversion of '16,667' failed.
'       Converted '   -322   ' to -322.
'       Converted '+4302' to 4302.
'       Attempted conversion of '(100)' failed.
'       Attempted conversion of '01FA' failed.

Voici quelques-unes des chaînes que la TryParse(String, Int32) méthode ne peut pas convertir dans cet exemple :

"9432.0". La conversion échoue, car la chaîne ne peut pas contenir de séparateur décimal ; elle doit contenir uniquement des chiffres intégraux.
"16,667". La conversion échoue, car la chaîne ne peut pas contenir de séparateurs de groupes ; elle doit contenir uniquement des chiffres intégraux.
"(100)". La conversion échoue, car la chaîne ne peut pas contenir un signe négatif autre que celui défini par les propriétés et NumberFormatInfo.NumberNegativePattern de NumberFormatInfo.NegativeSign la culture actuelle.
« 01FA ». La conversion échoue, car la chaîne ne peut pas contenir de chiffres hexadécimaux ; elle doit contenir uniquement des chiffres décimaux.

Remarques

La TryParse méthode est semblable à la Parse méthode , sauf que la TryParse méthode ne lève pas d’exception en cas d’échec de la conversion. Il élimine la nécessité d’utiliser la gestion des exceptions pour tester un FormatException dans le cas où n’est pas valide et ne s peut pas être analysé avec succès.

Le s paramètre contient un certain nombre de la forme :

[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.
sign	Signe facultatif.
chiffres	Séquence de chiffres compris entre 0 et 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 avec les informations de mise en forme spécifiques à la culture qui peuvent être présentes dans s, utilisez la Int32.TryParse(String, NumberStyles, IFormatProvider, Int32) méthode .

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.

Cette surcharge de la TryParse méthode interprète tous les chiffres du s paramètre comme des chiffres décimaux. Pour analyser la représentation sous forme de chaîne d’un nombre hexadécimal, appelez la Int32.TryParse(String, NumberStyles, IFormatProvider, Int32) surcharge.

Voir aussi

S’applique à

TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Tente d’analyser une étendue de caractères dans une valeur.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = ISpanParsable<int>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out int result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * int -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As Integer) As Boolean

Paramètres

s: ReadOnlySpan<Char>

Étendue de caractères à analyser.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant s.

result: Int32

Lorsque cette méthode est retournée, contient le résultat de l’analyse sréussie ou d’une valeur non définie en cas d’échec.

Retours

Boolean

true si s a été correctement analysé ; sinon, false.

S’applique à

TryParse(String, IFormatProvider, Int32)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

Tente d’analyser une chaîne dans une valeur.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = IParsable<int>::TryParse;

public static bool TryParse (string? s, IFormatProvider? provider, out int result);

static member TryParse : string * IFormatProvider * int -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As Integer) As Boolean

Paramètres

s: String

Chaîne à analyser.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant s.

result: Int32

Lorsque cette méthode est retournée, contient le résultat de l’analyse s réussie ou une valeur non définie en cas d’échec.

Retours

Boolean

true si s a été correctement analysé ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int32)

Source:: Int32.cs

Source:: Int32.cs

Tente d’analyser une étendue de caractères UTF-8 dans une valeur.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = System::Numerics::INumberBase<int>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out int result);

static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * int -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As Integer) As Boolean

Paramètres

utf8Text: ReadOnlySpan<Byte>

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

style: NumberStyles

Combinaison de styles numériques au niveau du bit qui peut être présente dans utf8Text.

provider: IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant utf8Text.

result: Int32

Au retour, contient le résultat de l’analyse utf8Text réussie ou une valeur non définie en cas d’échec.

Retours

Boolean

true si utf8Text a été correctement analysé ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Byte>, Int32)

Source:: Int32.cs

Source:: Int32.cs

Tente de convertir une étendue de caractères UTF-8 contenant la représentation sous forme de chaîne d’un nombre en entier signé 32 bits équivalent.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] int % result);

public static bool TryParse (ReadOnlySpan<byte> utf8Text, out int result);

static member TryParse : ReadOnlySpan<byte> * int -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As Integer) As Boolean

Paramètres

utf8Text: ReadOnlySpan<Byte>

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

result: Int32

Lorsque cette méthode est retournée, contient la valeur entière signée 32 bits équivalente au nombre contenu dans utf8Text si la conversion a réussi, ou zéro si la conversion a échoué. Ce paramètre est passé sous forme non initialisée. Toute valeur fournie initialement dans le résultat sera remplacée.

Retours

Boolean

true si la conversion de utf8Text est réussie ; sinon, false.

S’applique à

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result);

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = System::Numerics::INumberBase<int>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out int result);

public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider provider, out int result);

static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * int -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As Integer) As Boolean

Paramètres

s: ReadOnlySpan<Char>

Plage contenant les caractères représentant le nombre à convertir. La plage est interprétée à l'aide du style spécifié par style.

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 de mise en forme propres à la culture sur s.

result: Int32

Retours

Boolean

true si la conversion de s est réussie ; sinon, false.

S’applique à

TryParse(String, NumberStyles, IFormatProvider, Int32)

Source:: Int32.cs

Source:: Int32.cs

Source:: Int32.cs

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. Une valeur de retour indique si la conversion a réussi.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result);

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] int % result) = System::Numerics::INumberBase<int>::TryParse;

public static bool TryParse (string s, System.Globalization.NumberStyles style, IFormatProvider provider, out int result);

public static bool TryParse (string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out int result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * int -> bool

Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As Integer) As Boolean

Paramètres

s: String

Chaîne contenant un nombre à convertir. La chaîne est interprétée à l'aide du style spécifié par style.

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 de mise en forme propres à la culture sur s.

result: Int32

Retours

Boolean

true si la conversion de s est réussie ; sinon, false.

Exceptions

ArgumentException

style n’est pas une valeur NumberStyles.

- ou -

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

Exemples

L’exemple suivant appelle la Int32.TryParse(String, NumberStyles, IFormatProvider, Int32) méthode avec un certain nombre de chaînes et NumberStyles de valeurs différentes.

using namespace System;
using namespace System::Globalization;

void CallTryParse(String^ stringToConvert, NumberStyles styles)
{
      Int32 number;
      CultureInfo^ provider;

      // If currency symbol is allowed, use en-US culture. 
      if (((Int32) (styles & NumberStyles::AllowCurrencySymbol)) > 0)
         provider = gcnew CultureInfo("en-US");
      else
         provider = CultureInfo::InvariantCulture;

      bool result = Int32::TryParse(stringToConvert, styles, 
                                   provider, number);
      if (result)
         Console::WriteLine("Converted '{0}' to {1}.", stringToConvert, number);
      else
         Console::WriteLine("Attempted conversion of '{0}' failed.", 
                           Convert::ToString(stringToConvert));
}

void main()
{
      String^ numericString;
      NumberStyles styles;

      numericString = "106779";
      styles = NumberStyles::Integer;
      CallTryParse(numericString, styles);

      numericString = "-30677";
      styles = NumberStyles::None;
      CallTryParse(numericString, styles);

      styles = NumberStyles::AllowLeadingSign;
      CallTryParse(numericString, styles);

      numericString = "301677-";
      CallTryParse(numericString, styles);

      styles = styles | NumberStyles::AllowTrailingSign;
      CallTryParse(numericString, styles);

      numericString = "$10634";
      styles = NumberStyles::Integer;
      CallTryParse(numericString, styles);

      styles = NumberStyles::Integer | NumberStyles::AllowCurrencySymbol;
      CallTryParse(numericString, styles);

      numericString = "10345.00";
      styles = NumberStyles::Integer | NumberStyles::AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "10345.72";
      styles = NumberStyles::Integer | NumberStyles::AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "22,593"; 
      styles = NumberStyles::Integer | NumberStyles::AllowThousands;
      CallTryParse(numericString, styles);

      numericString = "12E-01";
      styles = NumberStyles::Integer | NumberStyles::AllowExponent;
      CallTryParse(numericString, styles); 

      numericString = "12E03";
      CallTryParse(numericString, styles); 

      numericString = "80c1";
      CallTryParse(numericString, NumberStyles::HexNumber);

      numericString = "0x80C1";
      CallTryParse(numericString, NumberStyles::HexNumber);      
      Console::ReadLine();
}
// The example displays the following output:
//      Converted '106779' to 106779.
//      Attempted conversion of '-30677' failed.
//      Converted '-30677' to -30677.
//      Attempted conversion of '301677-' failed.
//      Converted '301677-' to -301677.
//      Attempted conversion of '$10634' failed.
//      Converted '$10634' to 10634.
//      Converted '10345.00' to 10345.
//      Attempted conversion of '10345.72' failed.
//      Converted '22,593' to 22593.
//      Attempted conversion of '12E-01' failed.
//      Converted '12E03' to 12000.
//      Converted '80c1' to 32961.
//      Attempted conversion of '0x80C1' failed.

using System;
using System.Globalization;

public class StringParsing
{
   public static void Main()
   {
      string numericString;
      NumberStyles styles;

      numericString = "106779";
      styles = NumberStyles.Integer;
      CallTryParse(numericString, styles);

      numericString = "-30677";
      styles = NumberStyles.None;
      CallTryParse(numericString, styles);

      styles = NumberStyles.AllowLeadingSign;
      CallTryParse(numericString, styles);

      numericString = "301677-";
      CallTryParse(numericString, styles);

      styles = styles | NumberStyles.AllowTrailingSign;
      CallTryParse(numericString, styles);

      numericString = "$10634";
      styles = NumberStyles.Integer;
      CallTryParse(numericString, styles);

      styles = NumberStyles.Integer | NumberStyles.AllowCurrencySymbol;
      CallTryParse(numericString, styles);

      numericString = "10345.00";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "10345.72";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "22,593";
      styles = NumberStyles.Integer | NumberStyles.AllowThousands;
      CallTryParse(numericString, styles);

      numericString = "12E-01";
      styles = NumberStyles.Integer | NumberStyles.AllowExponent;
      CallTryParse(numericString, styles);

      numericString = "12E03";
      CallTryParse(numericString, styles);

      numericString = "80c1";
      CallTryParse(numericString, NumberStyles.HexNumber);

      numericString = "0x80C1";
      CallTryParse(numericString, NumberStyles.HexNumber);
   }

   private static void CallTryParse(string stringToConvert, NumberStyles styles)
   {
      CultureInfo provider;

      // If currency symbol is allowed, use en-US culture.
      if ((styles & NumberStyles.AllowCurrencySymbol) > 0)
         provider = new CultureInfo("en-US");
      else
         provider = CultureInfo.InvariantCulture;

      bool success = int.TryParse(stringToConvert, styles,
                                   provider, out int number);
      if (success)
         Console.WriteLine($"Converted '{stringToConvert}' to {number}.");
      else
         Console.WriteLine($"Attempted conversion of '{stringToConvert}' failed.");
   }
}
// The example displays the following output to the console:
//       Converted '106779' to 106779.
//       Attempted conversion of '-30677' failed.
//       Converted '-30677' to -30677.
//       Attempted conversion of '301677-' failed.
//       Converted '301677-' to -301677.
//       Attempted conversion of '$10634' failed.
//       Converted '$10634' to 10634.
//       Converted '10345.00' to 10345.
//       Attempted conversion of '10345.72' failed.
//       Converted '22,593' to 22593.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E03' to 12000.
//       Converted '80c1' to 32961.
//       Attempted conversion of '0x80C1' failed.

open System
open System.Globalization

let callTryParse (stringToConvert: string) styles =
    let provider =
        // If currency symbol is allowed, use en-US culture.
        if int (styles &&& NumberStyles.AllowCurrencySymbol) > 0 then
            CultureInfo "en-US"
        else
            CultureInfo.InvariantCulture

    match Int32.TryParse(stringToConvert, styles, provider) with
    | true, number ->
        printfn $"Converted '{stringToConvert}' to {number}."
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."

[<EntryPoint>]
let main _ =
    let numericString = "106779"
    let styles = NumberStyles.Integer
    callTryParse numericString styles

    let numericString = "-30677"
    let styles = NumberStyles.None
    callTryParse numericString styles

    let styles = NumberStyles.AllowLeadingSign
    callTryParse numericString styles

    let numericString = "301677-"
    callTryParse numericString styles

    let styles = styles ||| NumberStyles.AllowTrailingSign
    callTryParse numericString styles

    let numericString = "$10634"
    let styles = NumberStyles.Integer
    callTryParse numericString styles

    let styles = NumberStyles.Integer ||| NumberStyles.AllowCurrencySymbol
    callTryParse numericString styles

    let numericString = "10345.00"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles

    let numericString = "10345.72"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles

    let numericString = "22,593"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowThousands
    callTryParse numericString styles

    let numericString = "12E-01"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowExponent
    callTryParse numericString styles

    let numericString = "12E03"
    callTryParse numericString styles

    let numericString = "80c1"
    callTryParse numericString NumberStyles.HexNumber

    let numericString = "0x80C1"
    callTryParse numericString NumberStyles.HexNumber

    0

// The example displays the following output to the console:
//       Converted '106779' to 106779.
//       Attempted conversion of '-30677' failed.
//       Converted '-30677' to -30677.
//       Attempted conversion of '301677-' failed.
//       Converted '301677-' to -301677.
//       Attempted conversion of '$10634' failed.
//       Converted '$10634' to 10634.
//       Converted '10345.00' to 10345.
//       Attempted conversion of '10345.72' failed.
//       Converted '22,593' to 22593.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E03' to 12000.
//       Converted '80c1' to 32961.
//       Attempted conversion of '0x80C1' failed.

Imports System.Globalization

Module StringParsing
   Public Sub Main()
      Dim numericString As String
      Dim styles As NumberStyles
      
      numericString = "106779"
      styles = NumberStyles.Integer
      CallTryParse(numericString, styles)
      
      numericString = "-30677"
      styles = NumberStyles.None
      CallTryParse(numericString, styles)
      
      styles = NumberStyles.AllowLeadingSign
      CallTryParse(numericString, styles)
      
      numericString = "301677-"
      CallTryParse(numericString, styles)
      
      styles = styles Or NumberStyles.AllowTrailingSign
      CallTryParse(numericString, styles)
      
      numericString = "$10634"
      styles = NumberStyles.Integer
      CallTryParse(numericString, styles)
      
      styles = NumberStyles.Integer Or NumberStyles.AllowCurrencySymbol
      CallTryParse(numericString, styles)

      numericString = "10345.00"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)
      
      numericString = "10345.72"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)

      numericString = "22,593" 
      styles = NumberStyles.Integer Or NumberStyles.AllowThousands
      CallTryParse(numericString, styles)
      
      numericString = "12E-01"
      styles = NumberStyles.Integer Or NumberStyles.AllowExponent
      CallTryParse(numericString, styles) 
          
      numericString = "12E03"
      CallTryParse(numericString, styles) 
      
      numericString = "80c1"
      CallTryParse(numericString, NumberStyles.HexNumber)
      
      numericString = "0x80C1"
      CallTryParse(numericString, NumberStyles.HexNumber)
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String, styles AS NumberStyles)
      Dim number As Integer
      Dim provider As CultureInfo
      
      ' If currency symbol is allowed, use en-US culture.
      If CBool(styles And NumberStyles.AllowCurrencySymbol) Then
         provider = CultureInfo.CurrentCulture
      Else
         provider = New CultureInfo("en-US")
      End If
      
      Dim result As Boolean = Int32.TryParse(stringToConvert, styles, _
                                             provider, number)
      If result Then
         Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
      Else
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           Convert.ToString(stringToConvert))
      End If                                                                           
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '106779' to 106779.
'       Attempted conversion of '-30677' failed.
'       Converted '-30677' to -30677.
'       Attempted conversion of '301677-' failed.
'       Converted '301677-' to -301677.
'       Attempted conversion of '$10634' failed.
'       Converted '$10634' to 10634.
'       Converted '10345.00' to 10345.
'       Attempted conversion of '10345.72' failed.
'       Converted '22,593' to 22593.
'       Attempted conversion of '12E-01' failed.
'       Converted '12E03' to 12000.
'       Converted '80c1' to 32961.
'       Attempted conversion of '0x80C1' failed.

Remarques

La TryParse méthode est semblable à la Parse méthode , sauf que la TryParse méthode ne lève pas d’exception en cas d’échec de la conversion. Il élimine la nécessité d’utiliser la gestion des exceptions pour tester un FormatException dans le cas où n’est s pas valide et ne peut pas être analysé correctement.

Le style paramètre définit les éléments de style (tels que l’espace blanc ou un signe positif ou négatif) autorisés dans le s paramètre pour que l’opération d’analyse réussisse. Il doit s’agir d’une combinaison d’indicateurs de bits de l’énumération NumberStyles . Selon la valeur de style, le s paramètre peut inclure les éléments suivants :

[ws] [$] [signe] [digits,]digits[.fractional_digits][e[sign]digits][ws]

Ou, si le style paramètre 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 NumberStyles.AllowLeadingWhite , ou à la fin de `s` si `style` inclut l’indicateur NumberStyles.AllowTrailingWhite .
$	Symbole monétaire spécifique à la culture. Sa position dans la chaîne est définie par la CurrencyPositivePattern propriété de l’objet NumberFormatInfo retournée par la GetFormat méthode du `provider` paramètre . Le symbole monétaire peut apparaître dans `s` si `style` inclut l’indicateur NumberStyles.AllowCurrencySymbol .
sign	Signe facultatif. Un symbole de signe peut apparaître dans `s` si inclut les NumberStyles.AllowLeadingSign indicateurs ou NumberStyles.AllowTrailingSign`style` .
chiffres	Séquence de chiffres de 0 à 9.
,	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 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 NumberStyles.AllowDecimalPoint .
fractional_digits	Une ou plusieurs occurrences du chiffre 0. Les chiffres fractionnaires peuvent apparaître dans `s` uniquement si `style` inclut l’indicateur NumberStyles.AllowDecimalPoint .
e	Caractère « e » ou « E », qui indique que la valeur est représentée en notation exponentielle. Le `s` paramètre peut représenter un nombre en notation exponentielle si `style` inclut l’indicateur NumberStyles.AllowExponent .
hexdigits	Séquence de chiffres hexadécimaux de 0 à f ou de 0 à F.

Notes

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

Une chaîne avec des chiffres décimaux uniquement (qui correspond à l’indicateur NumberStyles.None ) s’analyse toujours correctement. La plupart des membres restants NumberStyles contrôlent les éléments qui peuvent être mais qui ne doivent pas être présents dans cette 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.

Valeurs NumberStyles non composites	Éléments autorisés dans s en plus des chiffres
NumberStyles.None	Chiffres décimaux uniquement.
NumberStyles.AllowDecimalPoint	Éléments décimaux (.) et fractional_digits . Toutefois, fractional_digits ne doit comporter qu’un ou plusieurs chiffres ou la méthode retourne `false`.
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 type de Int32 données sans composant fractionnaire non nul.
NumberStyles.AllowLeadingWhite	Élément ws au début de `s`.
NumberStyles.AllowTrailingWhite	Élément ws à la fin de `s`.
NumberStyles.AllowLeadingSign	Un signe peut apparaître avant les chiffres.
NumberStyles.AllowTrailingSign	Un signe peut apparaître après les chiffres.
NumberStyles.AllowParentheses	Élément sign sous forme de parenthèses englobant la valeur numérique.
NumberStyles.AllowThousands	Élément séparateur de milliers (,).
NumberStyles.AllowCurrencySymbol	Élément $.
NumberStyles.Currency	Tous les éléments. Le `s` paramètre ne peut pas représenter un nombre hexadécimal ou un nombre en notation exponentielle.
NumberStyles.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 `s` paramètre peut également utiliser la notation exponentielle.
NumberStyles.Number	Éléments ws, signe, séparateur de milliers (,) et virgule décimale (.).
NumberStyles.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 présents dans style sont NumberStyles.AllowLeadingWhite et NumberStyles.AllowTrailingWhite. (L’énumération NumberStyles a un style composite, NumberStyles.HexNumber, qui inclut les deux indicateurs d’espace blanc.)

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

Voir aussi

S’applique à

Int32.TryParse Méthode

Définition

Surcharges

TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int32)

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Char>, Int32)

Paramètres

Retours

S’applique à

TryParse(String, Int32)

Paramètres

Retours

Exemples

Remarques

Voir aussi

S’applique à

TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)

Paramètres

Retours

S’applique à

TryParse(String, IFormatProvider, Int32)

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int32)

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Byte>, Int32)

Paramètres

Retours

S’applique à

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)

Paramètres

Retours

S’applique à

TryParse(String, NumberStyles, IFormatProvider, Int32)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Commentaires

Ressources supplémentaires