BigInteger.TryParse Méthode

Définition

Espace de noms:

System.Numerics

Assembly:

System.Runtime.Numerics.dll

Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent BigInteger et retourne une valeur indiquant si la conversion a réussi.

Surcharges

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, BigInteger)	Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent BigInteger et retourne une valeur indiquant si la conversion a réussi.
TryParse(String, IFormatProvider, BigInteger)	Tente d’analyser une chaîne dans une valeur.
TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)	Tente d’analyser une étendue de caractères dans une valeur.
TryParse(String, BigInteger)	Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent BigInteger et retourne une valeur indiquant si la conversion a réussi.
TryParse(ReadOnlySpan<Char>, BigInteger)	Tente de convertir la représentation d’un nombre contenu dans l’étendue en lecture seule de caractères spécifiée en son équivalent BigInteger et retourne une valeur qui indique si la conversion a réussi.
TryParse(String, NumberStyles, IFormatProvider, BigInteger)	Essaie de convertir la représentation sous forme de chaîne d'un nombre ayant un style et un format spécifique à la culture spécifiés en son équivalent BigInteger et retourne une valeur qui indique si la conversion a réussi.

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

Source:

BigInteger.cs

Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent BigInteger et retourne une valeur indiquant si la conversion a réussi.

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

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

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

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

Paramètres

value

ReadOnlySpan<Char>

Représentation d’un nombre sous la forme d’une étendue en lecture seule de caractères.

style

NumberStyles

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

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur value.

result

BigInteger

Lorsque cette méthode est retournée, contient la valeur BigInteger équivalente au nombre contenu dans value, ou Zero, en cas d'échec de la conversion. La conversion échoue si le paramètre value est une étendue de caractères vide ou n’est pas dans un format conforme à style. Ce paramètre est passé sans être initialisé.

Retours

Boolean

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

Exceptions

ArgumentException

style n’est pas une valeur NumberStyles.

- ou -

style inclut l'indicateur AllowHexSpecifier ou HexNumber avec une autre valeur.

Remarques

Cette surcharge est semblable à la Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) méthode , sauf qu’elle ne lève pas d’exception si la conversion échoue. Cette méthode élimine la nécessité d’utiliser la gestion des exceptions pour tester un FormatException si value n’est 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 value 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 value paramètre peut inclure les éléments suivants :

[ws] [$][sign][digits,]digits[.fractional_digits][E[sign]exponential_digits][ws]

Si le style paramètre inclut AllowHexSpecifier, le value paramètre peut inclure les éléments suivants :

[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 value si style inclut l’indicateur NumberStyles.AllowLeadingWhite , ou à la fin de value si style inclut l’indicateur NumberStyles.AllowTrailingWhite .
$	Symbole monétaire spécifique à la culture. Sa position dans value est définie par la CurrencyPositivePattern propriété de l’objet NumberFormatInfo retourné par la GetFormat méthode du provider paramètre . Le symbole monétaire peut apparaître dans value si style inclut l’indicateur NumberStyles.AllowCurrencySymbol .
sign	Signe facultatif. Le signe peut apparaître au début de value si style inclut l’indicateur NumberStyles.AllowLeadingSign , et il peut apparaître à la fin de value si style inclut l’indicateur NumberStyles.AllowTrailingSign . Vous pouvez utiliser des parenthèses dans value pour indiquer une valeur négative si style inclut l’indicateur NumberStyles.AllowParentheses .
chiffres	Séquence de chiffres de 0 à 9.
,	Séparateur de groupe spécifique à la culture. Le séparateur de groupe de la culture spécifiée par provider peut apparaître dans value 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 value si style inclut l’indicateur NumberStyles.AllowDecimalPoint .
fractional_digits	Une ou plusieurs occurrences du chiffre 0. Les chiffres fractionnaires peuvent apparaître dans value 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 (scientifique). Le value paramètre peut représenter un nombre en notation exponentielle si style inclut l’indicateur NumberStyles.AllowExponent .
exponential_digits	Séquence de chiffres de 0 à 9. Le value 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 .

Valeurs non composites NumberStyles	Éléments autorisés en valeur en plus des chiffres
None	Chiffres décimaux uniquement.
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.
AllowExponent	Caractère « e » ou « E », qui indique une notation exponentielle, ainsi que exponential_digits. Si value représente un nombre en notation exponentielle, il ne peut pas avoir un composant fractionnaire différent de zéro.
AllowLeadingWhite	Élément ws au début de value.
AllowTrailingWhite	Élément ws à la fin de value.
AllowLeadingSign	Élément sign avant les chiffres.
AllowTrailingSign	Élément sign après les chiffres.
AllowParentheses	Élément sign sous forme de parenthèses englobant la valeur numérique.
AllowThousands	Élément séparateur de groupe (,).
AllowCurrencySymbol	Élément currency ($).
Currency	Tous les éléments. Toutefois, value 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 value, signe au début de valueet le symbole décimal (.). Le value paramètre peut également utiliser la notation exponentielle.
Number	Éléments ws, signe, séparateur de groupe (,) et virgule décimale (.).
Any	Tous les éléments. Toutefois, value ne peut pas représenter un nombre hexadécimal.

Si l’indicateur NumberStyles.AllowHexSpecifier est utilisé, value doit être une valeur hexadécimale. 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, HexNumber, qui inclut les deux indicateurs d’espace blanc.)

Le provider paramètre est une IFormatProvider implémentation. Sa GetFormat méthode retourne un NumberFormatInfo objet qui fournit des informations spécifiques à la culture sur le format de value. Le provider paramètre peut être l’un des éléments suivants :

• Objet CultureInfo qui représente la culture qui fournit des informations de mise en forme. Sa GetFormat méthode retourne l’objet NumberFormatInfo qui fournit des informations de mise en forme numériques pour cette culture.

• Objet NumberFormatInfo qui fournit des informations de mise en forme numérique. (Son implémentation de GetFormat retourne simplement elle-même.)

• Objet personnalisé qui implémente IFormatProvider. Sa GetFormat méthode instancie et retourne l’objet NumberFormatInfo qui fournit des informations de mise en forme.

Si provider a la valeur null, l’objet NumberFormatInfo de la culture actuelle est utilisé.

Voir aussi

• Parse

TryParse(String, IFormatProvider, BigInteger)

Source:

BigInteger.cs

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

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

public static bool TryParse (string? s, IFormatProvider? provider, out System.Numerics.BigInteger result);

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

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As BigInteger) 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

BigInteger

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.

TryParse(ReadOnlySpan<Char>, IFormatProvider, BigInteger)

Source:

BigInteger.cs

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

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

public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out System.Numerics.BigInteger result);

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

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As BigInteger) 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

BigInteger

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.

TryParse(String, BigInteger)

Source:

BigInteger.cs

Essaie de convertir la représentation sous forme de chaîne d'un nombre en son équivalent BigInteger et retourne une valeur indiquant si la conversion a réussi.

public:
 static bool TryParse(System::String ^ value, [Runtime::InteropServices::Out] System::Numerics::BigInteger % result);

public static bool TryParse (string? value, out System.Numerics.BigInteger result);

static member TryParse : string * BigInteger -> bool

Public Shared Function TryParse (value As String, ByRef result As BigInteger) As Boolean

Paramètres

value

String

Représentation sous forme de chaîne d'un nombre.

result

BigInteger

Lorsque cette méthode est retournée, contient la valeur BigInteger équivalente au nombre contenu dans value, ou zéro (0), en cas d'échec de la conversion. La conversion échoue si le paramètre value est null ou s'il n'est pas au format approprié. Ce paramètre est passé sans être initialisé.

Retours

Boolean

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

Exceptions

ArgumentNullException

value a la valeur null.

Exemples

L’exemple suivant utilise la TryParse(String, BigInteger) méthode pour instancier deux BigInteger objets. Si les conversions réussissent, il multiplie chaque objet par un autre nombre, puis appelle la Compare méthode pour déterminer la relation entre les deux objets.

BigInteger number1, number2;
bool succeeded1 = BigInteger.TryParse("-12347534159895123", out number1);
bool succeeded2 = BigInteger.TryParse("987654321357159852", out number2);
if (succeeded1 && succeeded2)
{
   number1 *= 3;
   number2 *= 2;
   switch (BigInteger.Compare(number1, number2))
   {
      case -1:
         Console.WriteLine("{0} is greater than {1}.", number2, number1);
         break;
      case 0:
         Console.WriteLine("{0} is equal to {1}.", number1, number2);
         break;
      case 1:
         Console.WriteLine("{0} is greater than {1}.", number1, number2);
         break;
   }
}
else
{
   if (!succeeded1)
      Console.WriteLine("Unable to initialize the first BigInteger value.");

   if (!succeeded2)
      Console.WriteLine("Unable to initialize the second BigInteger value.");
}
// The example displays the following output:
//      1975308642714319704 is greater than -37042602479685369.

    let mutable number1 = BigInteger.Zero
    let mutable number2 = BigInteger.Zero

    let succeeded1 = BigInteger.TryParse("-12347534159895123", &number1)
    let succeeded2 = BigInteger.TryParse("987654321357159852", &number2)

    if succeeded1 && succeeded2 then
        number1 <- number1 * 3I
        number2 <- number2 * 2I

        match BigInteger.Compare(number1, number2) with
        | -1 -> printfn $"{number2} is greater than {number2}."
        | 0 -> printfn $"{number1} is equal to {number2}."
        | 1
        | _ -> printfn $"{number1} is greater than {number2}."
    else
        if not succeeded1 then
            printfn "Unable to initialize the first BigInteger value."

        if not succeeded2 then
            printfn "Unable to initialize the second BigInteger value."

// The example displays the following output:
//      1975308642714319704 is greater than -37042602479685369.

Dim number1 As BigInteger = BigInteger.Zero
Dim number2 As BigInteger = BigInteger.Zero
Dim succeeded1 As Boolean = BigInteger.TryParse("-12347534159895123", number1)
Dim succeeded2 As Boolean = BigInteger.TryParse("987654321357159852", number2)
If succeeded1 AndAlso succeeded2
   number1 *= 3
   number2 *= 2
   Select Case BigInteger.Compare(number1, number2)
      Case -1
         Console.WriteLine("{0} is greater than {1}.", number2, number1)
      Case 0
         Console.WriteLine("{0} is equal to {1}.", number1, number2)
      Case 1
         Console.WriteLine("{0} is greater than {1}.", number1, number2)
   End Select      
Else
   If Not succeeded1 Then 
      Console.WriteLine("Unable to initialize the first BigInteger value.")
   End If
   If Not succeeded2 Then
      Console.WriteLine("Unable to initialize the second BigInteger value.")
   
   End If
End If
' The example displays the following output:
'      1975308642714319704 is greater than -37042602479685369.

Remarques

La TryParse(String, BigInteger) méthode est semblable à la Parse(String) méthode , sauf qu’elle ne lève pas d’exception si la conversion échoue. Cette méthode élimine la nécessité d’utiliser la gestion des exceptions pour tester un FormatException si value n’est pas valide et ne peut pas être analysé avec succès.

Le value paramètre doit être la représentation sous forme de chaîne d’un nombre décimal sous la forme suivante :

[ws] [signe] 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. Les caractères de signe valides sont déterminés par les NumberFormatInfo.NegativeSign propriétés et NumberFormatInfo.PositiveSign de la culture actuelle.
chiffres	Séquence de chiffres décimaux compris entre 0 et 9.

Notes

La chaîne spécifiée par le value paramètre ne peut pas contenir de séparateurs de groupes ou de séparateur décimal, et elle ne peut pas avoir de partie décimale.

Le value 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 avec 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 value, appelez la TryParse(String, NumberStyles, IFormatProvider, BigInteger) méthode .

Le value paramètre est analysé à l’aide des informations de mise en forme dans un NumberFormatInfo objet pour la culture actuelle. Pour plus d'informations, consultez NumberFormatInfo.CurrentInfo.

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

Voir aussi

• ToString(String)
• Parse

TryParse(ReadOnlySpan<Char>, BigInteger)

Source:

BigInteger.cs

Tente de convertir la représentation d’un nombre contenu dans l’étendue en lecture seule de caractères spécifiée en son équivalent BigInteger et retourne une valeur qui indique si la conversion a réussi.

public:
 static bool TryParse(ReadOnlySpan<char> value, [Runtime::InteropServices::Out] System::Numerics::BigInteger % result);

public static bool TryParse (ReadOnlySpan<char> value, out System.Numerics.BigInteger result);

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

Public Shared Function TryParse (value As ReadOnlySpan(Of Char), ByRef result As BigInteger) As Boolean

Paramètres

value

ReadOnlySpan<Char>

Représentation d’un nombre sous la forme d’une étendue en lecture seule de caractères.

result

BigInteger

Lorsque cette méthode est retournée, contient la valeur BigInteger équivalente au nombre contenu dans value, ou zéro (0), en cas d'échec de la conversion. La conversion échoue si le paramètre value est une étendue de caractères vide ou n’est pas au format approprié. Ce paramètre est passé sans être initialisé.

Retours

Boolean

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

Voir aussi

• Parse

TryParse(String, NumberStyles, IFormatProvider, BigInteger)

Source:

BigInteger.cs

Essaie de convertir la représentation sous forme de chaîne d'un nombre ayant un style et un format spécifique à la culture spécifiés en son équivalent BigInteger et retourne une valeur qui indique si la conversion a réussi.

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

public static bool TryParse (string? value, System.Globalization.NumberStyles style, IFormatProvider? provider, out System.Numerics.BigInteger result);

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

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

Paramètres

value

String

Représentation sous forme de chaîne d'un nombre. 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 value. Une valeur typique à spécifier est Integer.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture sur value.

result

BigInteger

Lorsque cette méthode est retournée, contient la valeur BigInteger équivalente au nombre contenu dans value, ou Zero, en cas d'échec de la conversion. La conversion échoue si le paramètre value est null ou s'il n'est pas dans un format compatible avec style. Ce paramètre est passé sans être initialisé.

Retours

Boolean

true si la conversion du paramètre value a réussi ; sinon, false.

Exceptions

ArgumentException

style n’est pas une valeur NumberStyles.

- ou -

style inclut l'indicateur AllowHexSpecifier ou HexNumber avec une autre valeur.

Exemples

L’exemple suivant effectue des appels à la méthode à l’aide TryParse(String, NumberStyles, IFormatProvider, BigInteger) de différentes combinaisons de valeurs pour les style paramètres et provider .

string numericString;
BigInteger number = BigInteger.Zero;

// Call TryParse with default values of style and provider.
numericString = "  -300   ";
if (BigInteger.TryParse(numericString, NumberStyles.Integer,
                       null, out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with the default value of style and
// a provider supporting the tilde as negative sign.
numericString = "  -300   ";
if (BigInteger.TryParse(numericString, NumberStyles.Integer,
                       new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with only AllowLeadingWhite and AllowTrailingWhite.
// Method returns false because of presence of negative sign.
numericString = "  -500   ";
if (BigInteger.TryParse(numericString,
                        NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite,
                        new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with AllowHexSpecifier and a hex value.
numericString = "F14237FFAAC086455192";
if (BigInteger.TryParse(numericString,
                        NumberStyles.AllowHexSpecifier,
                        null, out number))
   Console.WriteLine("'{0}' was converted to {1} (0x{1:x}).",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with AllowHexSpecifier and a negative hex value.
// Conversion fails because of presence of negative sign.
numericString = "-3af";
if (BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier,
                       new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with only NumberStyles.None.
// Conversion fails because of presence of white space and sign.
numericString = " -300 ";
if (BigInteger.TryParse(numericString, NumberStyles.None,
                       new BigIntegerFormatProvider(), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
// Conversion fails because the string is formatted for the en-US culture.
numericString = "9,031,425,666,123,546.00";
if (BigInteger.TryParse(numericString, NumberStyles.Any,
                       new CultureInfo("fr-FR"), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);

// Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
// Conversion succeeds because the string is properly formatted
// For the fr-FR culture.
numericString = "9 031 425 666 123 546,00";
if (BigInteger.TryParse(numericString, NumberStyles.Any,
                       new CultureInfo("fr-FR"), out number))
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number);
else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString);
// The example displays the following output:
//    '  -300   ' was converted to -300.
//    Conversion of '  -300   ' to a BigInteger failed.
//    Conversion of '  -500   ' to a BigInteger failed.
//    'F14237FFAAC086455192' was converted to -69613977002644837412462 (0xf14237ffaac086455192).
//    Conversion of '-3af' to a BigInteger failed.
//    Conversion of ' -300 ' to a BigInteger failed.
//    Conversion of '9,031,425,666,123,546.00' to a BigInteger failed.
//    '9 031 425 666 123 546,00' was converted to 9031425666123546.

    // Call TryParse with default values of style and provider.
    let numericString = "  -300   "

    match BigInteger.TryParse(numericString, NumberStyles.Integer, null) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with the default value of style and
    // a provider supporting the tilde as negative sign.
    let numericString = "  -300   "

    match BigInteger.TryParse(numericString, NumberStyles.Integer, new BigIntegerFormatProvider()) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with only AllowLeadingWhite and AllowTrailingWhite.
    // Method returns false because of presence of negative sign.
    let numericString = "  -500   "

    match
        BigInteger.TryParse(
            numericString,
            NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite,
            new BigIntegerFormatProvider()
        )
    with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with AllowHexSpecifier and a hex value.
    let numericString = "F14237FFAAC086455192"

    match BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier, null) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}, or 0x{number:x}."
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with AllowHexSpecifier and a negative hex value.
    // Conversion fails because of presence of negative sign.
    let numericString = "-3af"

    match BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier, null) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}, or 0x{number:x}."
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with only NumberStyles.None.
    // Conversion fails because of presence of white space and sign.
    let numericString = " -300 "

    match BigInteger.TryParse(numericString, NumberStyles.None, new BigIntegerFormatProvider()) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
    // Conversion fails because the string is formatted for the en-US culture.
    let numericString = "9,031,425,666,123,546.00"

    match BigInteger.TryParse(numericString, NumberStyles.Any, new CultureInfo("fr-FR")) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

    // Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
    // Conversion succeeds because the string is properly formatted
    // For the fr-FR culture.
    let numericString = "9 031 425 666 123 546,00"

    match BigInteger.TryParse(numericString, NumberStyles.Any, new CultureInfo("fr-FR")) with
    | true, number -> printfn $"The string '{numericString}' parses to {number}"
    | _ -> printfn $"Conversion of {numericString} to a BigInteger failed."

// The example displays the following output:
//    '  -300   ' was converted to -300.
//    Conversion of '  -300   ' to a BigInteger failed.
//    Conversion of '  -500   ' to a BigInteger failed.
//    'F14237FFAAC086455192' was converted to -69613977002644837412462 (0xf14237ffaac086455192).
//    Conversion of '-3af' to a BigInteger failed.
//    Conversion of ' -300 ' to a BigInteger failed.
//    Conversion of '9,031,425,666,123,546.00' to a BigInteger failed.
//    '9 031 425 666 123 546,00' was converted to 9031425666123546.

Dim numericString As String
Dim number As BigInteger = BigInteger.Zero

' Call TryParse with default values of style and provider.
numericString = "  -300   "
If BigInteger.TryParse(numericString, NumberStyles.Integer,
                       Nothing, number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with the default value of style and 
' a provider supporting the tilde as negative sign.
numericString = "  -300   "
If BigInteger.TryParse(numericString, NumberStyles.Integer,
                       New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with only AllowLeadingWhite and AllowTrailingWhite.
' Method returns false because of presence of negative sign.
numericString = "  -500   "
If BigInteger.TryParse(numericString,
                    NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite,
                    New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with AllowHexSpecifier and a hex value.
numericString = "F14237FFAAC086455192"
If BigInteger.TryParse(numericString,
                    NumberStyles.AllowHexSpecifier,
                    Nothing, number) Then
   Console.WriteLine("'{0}' was converted to {1} (0x{1:x}).",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with AllowHexSpecifier and a negative hex value.
' Conversion fails because of presence of negative sign.
numericString = "-3af"
If BigInteger.TryParse(numericString, NumberStyles.AllowHexSpecifier,
                       New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If                                             

' Call TryParse with only NumberStyles.None.
' Conversion fails because of presence of white space and sign.
numericString = " -300 "
If BigInteger.TryParse(numericString, NumberStyles.None,
                       New BigIntegerFormatProvider(), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If 
                                            
' Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
' Conversion fails because the string is formatted for the en-US culture.
numericString = "9,031,425,666,123,546.00"
If BigInteger.TryParse(numericString, NumberStyles.Any,
                       New CultureInfo("fr-FR"), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If

' Call TryParse with NumberStyles.Any and a provider for the fr-FR culture.
' Conversion succeeds because the string is properly formatted 
' For the fr-FR culture.
numericString = "9 031 425 666 123 546,00"
If BigInteger.TryParse(numericString, NumberStyles.Any,
                       New CultureInfo("fr-FR"), number) Then
   Console.WriteLine("'{0}' was converted to {1}.",
                     numericString, number)                             
Else
   Console.WriteLine("Conversion of '{0}' to a BigInteger failed.",
                     numericString)
End If
' The example displays the following output:
'    '  -300   ' was converted to -300.
'    Conversion of '  -300   ' to a BigInteger failed.
'    Conversion of '  -500   ' to a BigInteger failed.
'    'F14237FFAAC086455192' was converted to -69613977002644837412462 (0xf14237ffaac086455192).
'    Conversion of '-3af' to a BigInteger failed.
'    Conversion of ' -300 ' to a BigInteger failed.
'    Conversion of '9,031,425,666,123,546.00' to a BigInteger failed.
'    '9 031 425 666 123 546,00' was converted to 9031425666123546.

Un certain nombre d’appels individuels à la TryParse(String, NumberStyles, IFormatProvider, BigInteger) méthode passent un instance de la classe suivanteBigIntegerFormatProvider, qui définit un tilde (~) comme signe négatif.

public class BigIntegerFormatProvider : IFormatProvider
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(NumberFormatInfo))
      {
         NumberFormatInfo numberFormat = new NumberFormatInfo();
         numberFormat.NegativeSign = "~";
         return numberFormat;
      }
      else
      {
         return null;
      }
   }
}

type BigIntegerFormatProvider() =
    interface IFormatProvider with
        member _.GetFormat(formatType: Type) =
            if formatType = typeof<NumberFormatInfo> then
                let numberFormat = new NumberFormatInfo()
                numberFormat.NegativeSign <- "~"
                numberFormat
            else
                null

Public Class BigIntegerFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                            Implements IFormatProvider.GetFormat
      If formatType Is GetType(NumberFormatInfo) Then
         Dim numberFormat As New NumberFormatInfo
         numberFormat.NegativeSign = "~"
         Return numberFormat
      Else
         Return Nothing
      End If      
   End Function
End Class

Remarques

La TryParse(String, NumberStyles, IFormatProvider, BigInteger) méthode est semblable à la Parse(String, NumberStyles, IFormatProvider) méthode , sauf qu’elle ne lève pas d’exception si la conversion échoue. Cette méthode élimine la nécessité d’utiliser la gestion des exceptions pour tester un FormatException si value n’est 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 value 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 value paramètre peut inclure les éléments suivants :

[ws] [$][sign][digits,]digits[.fractional_digits][E[sign]exponential_digits][ws]

Si le style paramètre inclut AllowHexSpecifier, le value paramètre peut inclure les éléments suivants :

[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 value si style inclut l’indicateur NumberStyles.AllowLeadingWhite , ou à la fin de value 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 value si style inclut l’indicateur NumberStyles.AllowCurrencySymbol .
sign	Signe facultatif. Le signe peut apparaître au début de value si style inclut l’indicateur NumberStyles.AllowLeadingSign , et il peut apparaître à la fin de value si style inclut l’indicateur NumberStyles.AllowTrailingSign . Vous pouvez utiliser des parenthèses dans value pour indiquer une valeur négative si style inclut l’indicateur NumberStyles.AllowParentheses .
chiffres	Séquence de chiffres de 0 à 9.
,	Séparateur de groupe spécifique à la culture. Le séparateur de groupe de la culture spécifiée par provider peut apparaître dans value 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 value si style inclut l’indicateur NumberStyles.AllowDecimalPoint .
fractional_digits	Une ou plusieurs occurrences du chiffre 0. Les chiffres fractionnaires peuvent apparaître dans value 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 (scientifique). Le value paramètre peut représenter un nombre en notation exponentielle si style inclut l’indicateur NumberStyles.AllowExponent .
exponential_digits	Séquence de chiffres de 0 à 9. Le value 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 présents, mais qui ne sont pas obligatoires, 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 value.

Valeurs non composites NumberStyles	Éléments autorisés en valeur en plus des chiffres
None	Chiffres décimaux uniquement.
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.
AllowExponent	Caractère « e » ou « E », qui indique une notation exponentielle, ainsi que exponential_digits. Si value représente un nombre en notation exponentielle, il ne peut pas avoir un composant fractionnaire différent de zéro.
AllowLeadingWhite	Élément ws au début de value.
AllowTrailingWhite	Élément ws à la fin de value.
AllowLeadingSign	Élément sign avant les chiffres.
AllowTrailingSign	Élément sign après les chiffres.
AllowParentheses	Élément sign sous forme de parenthèses englobant la valeur numérique.
AllowThousands	Élément séparateur de groupe (,).
AllowCurrencySymbol	Élément currency ($).
Currency	Tous les éléments. Toutefois, value 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 value, signe au début de valueet le symbole décimal (.). Le value paramètre peut également utiliser la notation exponentielle.
Number	Éléments ws, signe, séparateur de groupe (,) et virgule décimale (.).
Any	Tous les éléments. Toutefois, value ne peut pas représenter un nombre hexadécimal.

Important

Si vous utilisez la méthode pour effectuer un TryParse aller-retour de la représentation sous forme de chaîne d’une BigInteger valeur qui a été sortie par la ToString méthode, vous devez utiliser la BigInteger.ToString(String) méthode avec le spécificateur de format « R » pour générer la représentation sous forme de chaîne de la BigInteger valeur. Sinon, la représentation sous forme de chaîne du BigInteger conserve uniquement les 50 chiffres les plus significatifs de la valeur d’origine, et les données peuvent être perdues lorsque vous utilisez la TryParse méthode pour restaurer la BigInteger valeur.

Si l’indicateur NumberStyles.AllowHexSpecifier est utilisé, value doit être une valeur hexadécimale. 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, HexNumber, qui inclut les deux indicateurs d’espace blanc.)

Notes

Si value est la représentation sous forme de chaîne d’un nombre hexadécimal, elle ne peut pas être précédée d’une décoration (telle que 0x ou &h) qui le différencie en tant que nombre hexadécimal. Cela entraîne l’échec de la conversion.

Si value est une chaîne hexadécimale, la TryParse(String, NumberStyles, IFormatProvider, BigInteger) méthode interprète value comme un nombre négatif stocké à l’aide de la représentation complémentaire de deux si ses deux premiers chiffres hexadécimaux sont supérieurs ou égaux à 0x80. En d’autres termes, la méthode interprète le bit d’ordre le plus élevé du premier octet dans value comme le bit de signe. Pour vous assurer qu’une chaîne hexadécimale est correctement interprétée comme un nombre positif, le premier chiffre de value doit avoir la valeur zéro. Par exemple, la méthode interprète 0x80 comme une valeur négative, mais elle interprète 0x080 ou 0x0080 comme une valeur positive. L’exemple suivant illustre la différence entre les chaînes hexadécimales qui représentent des valeurs négatives et positives.

using System;
using System.Globalization;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      string[] hexStrings = { "80", "E293", "F9A2FF", "FFFFFFFF",
                              "080", "0E293", "0F9A2FF", "0FFFFFFFF",
                              "0080", "00E293", "00F9A2FF", "00FFFFFFFF" };
      BigInteger number = BigInteger.Zero;

      foreach (string hexString in hexStrings)
      {
         if (BigInteger.TryParse(hexString, NumberStyles.AllowHexSpecifier,
                                 null, out number))
            Console.WriteLine("Converted 0x{0} to {1}.", hexString, number);
         else
            Console.WriteLine("Cannot convert '{0}' to a BigInteger.", hexString);
      }
   }
}
// The example displays the following output:
//       Converted 0x80 to -128.
//       Converted 0xE293 to -7533.
//       Converted 0xF9A2FF to -417025.
//       Converted 0xFFFFFFFF to -1.
//       Converted 0x080 to 128.
//       Converted 0x0E293 to 58003.
//       Converted 0x0F9A2FF to 16360191.
//       Converted 0x0FFFFFFFF to 4294967295.
//       Converted 0x0080 to 128.
//       Converted 0x00E293 to 58003.
//       Converted 0x00F9A2FF to 16360191.
//       Converted 0x00FFFFFFFF to 4294967295.

open System.Globalization
open System.Numerics

let hexStrings =
    [| "80"
       "E293"
       "F9A2FF"
       "FFFFFFFF"
       "080"
       "0E293"
       "0F9A2FF"
       "0FFFFFFFF"
       "0080"
       "00E293"
       "00F9A2FF"
       "00FFFFFFFF" |]

for hexString in hexStrings do
    match BigInteger.TryParse(hexString, NumberStyles.AllowHexSpecifier, null) with
    | true, number -> printfn $"Converted 0x{hexString} to {number}."
    | _ -> printfn $"Cannot convert '{hexString}' to a BigInteger."

// The example displays the following output:
//       Converted 0x80 to -128.
//       Converted 0xE293 to -7533.
//       Converted 0xF9A2FF to -417025.
//       Converted 0xFFFFFFFF to -1.
//       Converted 0x080 to 128.
//       Converted 0x0E293 to 58003.
//       Converted 0x0F9A2FF to 16360191.
//       Converted 0x0FFFFFFFF to 4294967295.
//       Converted 0x0080 to 128.
//       Converted 0x00E293 to 58003.
//       Converted 0x00F9A2FF to 16360191.
//       Converted 0x00FFFFFFFF to 4294967295.

Imports System.Globalization
Imports System.Numerics

Module Example
   Public Sub Main()
      Dim hexStrings() As String = { "80", "E293", "F9A2FF", "FFFFFFFF", 
                                     "080", "0E293", "0F9A2FF", "0FFFFFFFF",  
                                     "0080", "00E293", "00F9A2FF", "00FFFFFFFF" }
      Dim number As BigInteger = BigInteger.Zero
      
      For Each hexString As String In hexStrings
         If BigInteger.TryParse(hexString, NumberStyles.AllowHexSpecifier, 
                                Nothing, number) Then
            Console.WriteLine("Converted 0x{0} to {1}.", hexString, number)
         Else
            Console.WriteLine("Cannot convert '{0}' to a BigInteger.", hexString)
         End If
      Next         
   End Sub
End Module
' The example displays the following output:
'       Converted 0x80 to -128.
'       Converted 0xE293 to -7533.
'       Converted 0xF9A2FF to -417025.
'       Converted 0xFFFFFFFF to -1.
'       Converted 0x080 to 128.
'       Converted 0x0E293 to 58003.
'       Converted 0x0F9A2FF to 16360191.
'       Converted 0x0FFFFFFFF to 4294967295.
'       Converted 0x0080 to 128.
'       Converted 0x00E293 to 58003.
'       Converted 0x00F9A2FF to 16360191.
'       Converted 0x00FFFFFFFF to 4294967295.

Le provider paramètre est une IFormatProvider implémentation. Sa GetFormat méthode retourne un NumberFormatInfo objet qui fournit des informations spécifiques à la culture sur le format de value. Le provider paramètre peut être l’un des éléments suivants :

• Objet CultureInfo qui représente la culture qui fournit des informations de mise en forme. Sa GetFormat méthode retourne l’objet NumberFormatInfo qui fournit des informations de mise en forme numériques pour cette culture.

• Objet NumberFormatInfo qui fournit des informations de mise en forme numérique. (Son implémentation de GetFormat retourne simplement elle-même.)

• Objet personnalisé qui implémente IFormatProvider. Sa GetFormat méthode instancie et retourne l’objet NumberFormatInfo qui fournit des informations de mise en forme.

Si provider a la valeur null, l’objet NumberFormatInfo de la culture actuelle est utilisé.

Voir aussi

• ToString
• Parse