Partager via

BigInteger.Parse Méthode

Définition

Espace de noms:
System.Numerics
Assemblys:
System.Numerics.dll, System.Runtime.Numerics.dll
Assemblys:
netstandard.dll, System.Runtime.Numerics.dll
Assembly:
System.Runtime.Numerics.dll
Assembly:
System.Numerics.dll
Assembly:
netstandard.dll

Convertit la représentation sous forme de chaîne d’un nombre en son BigInteger équivalent.

Surcharges

Nom Description
Parse(String, NumberStyles, IFormatProvider)

Convertit la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en son BigInteger équivalent.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Convertit la représentation d’un nombre, contenue dans l’étendue de caractères en lecture seule spécifiée, dans un style spécifié en son BigInteger équivalent.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
Parse(String, IFormatProvider)

Convertit la représentation sous forme de chaîne d’un nombre dans un format spécifique à la culture spécifié en son BigInteger équivalent.
Parse(ReadOnlySpan<Byte>, IFormatProvider)
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analyse une étendue de caractères en une valeur.
Parse(String, NumberStyles)

Convertit la représentation sous forme de chaîne d’un nombre dans un style spécifié en son BigInteger équivalent.
Parse(String)

Convertit la représentation sous forme de chaîne d’un nombre en son BigInteger équivalent.

Parse(String, NumberStyles, IFormatProvider)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Convertit la représentation sous forme de chaîne d’un nombre dans un style et un format spécifique à la culture spécifiés en son BigInteger équivalent.

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

Paramètres

value
String

Chaîne qui contient un nombre à convertir.

style
NumberStyles

Combinaison au niveau du bit des valeurs d’énumération qui spécifient le format autorisé de value.

provider
IFormatProvider

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

Retours

BigInteger

Valeur équivalente au nombre spécifié dans le value paramètre.

Implémente

Parse(String, NumberStyles, IFormatProvider)

Exceptions

ArgumentException

style n’est pas une NumberStyles valeur.

- ou -

styleinclut le ou HexNumber l’indicateur AllowHexSpecifier avec une autre valeur.

ArgumentNullException

value a la valeur null.

FormatException

value ne respecte pas le modèle d’entrée spécifié par style.

Exemples

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

// Call parse with default values of style and provider
Console.WriteLine(BigInteger.Parse("  -300   ",
                  NumberStyles.Integer, CultureInfo.CurrentCulture));
// Call parse with default values of style and provider supporting tilde as negative sign
Console.WriteLine(BigInteger.Parse("   ~300  ",
                                   NumberStyles.Integer, new BigIntegerFormatProvider()));
// Call parse with only AllowLeadingWhite and AllowTrailingWhite
// Exception thrown because of presence of negative sign
try
{
   Console.WriteLine(BigInteger.Parse("    ~300   ",
                                NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite,
                                new BigIntegerFormatProvider()));
}
catch (FormatException e)
{
   Console.WriteLine("{0}: \n   {1}", e.GetType().Name, e.Message);
}
// Call parse with only AllowHexSpecifier
// Exception thrown because of presence of negative sign
try
{
   Console.WriteLine(BigInteger.Parse("-3af", NumberStyles.AllowHexSpecifier,
                                      new BigIntegerFormatProvider()));
}
catch (FormatException e)
{
   Console.WriteLine("{0}: \n   {1}", e.GetType().Name, e.Message);
}
// Call parse with only NumberStyles.None
// Exception thrown because of presence of white space and sign
try
{
   Console.WriteLine(BigInteger.Parse(" -300 ", NumberStyles.None,
                                      new BigIntegerFormatProvider()));
}
catch (FormatException e)
{
   Console.WriteLine("{0}: \n   {1}", e.GetType().Name, e.Message);
}
// The example displays the followingoutput:
//       -300
//       -300
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.

    // Call parse with default values of style and provider
    printfn $"""{BigInteger.Parse("  -300   ", NumberStyles.Integer, CultureInfo.CurrentCulture)}"""

    // Call parse with default values of style and provider supporting tilde as negative sign
    printfn $"""{BigInteger.Parse("   ~300  ", NumberStyles.Integer, new BigIntegerFormatProvider())}"""

    // Call parse with only AllowLeadingWhite and AllowTrailingWhite
    // Exception thrown because of presence of negative sign
    try
        printfn
            $"""{BigInteger.Parse(
                     "    ~300   ",
                     NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite,
                     new BigIntegerFormatProvider()
                 )}"""
    with :? FormatException as e ->
        printfn $"{e.GetType().Name}: \n   {e.Message}"

    // Call parse with only AllowHexSpecifier
    // Exception thrown because of presence of negative sign
    try
        printfn $"""{BigInteger.Parse("-3af", NumberStyles.AllowHexSpecifier, new BigIntegerFormatProvider())}"""
    with :? FormatException as e ->
        printfn $"{e.GetType().Name}: \n   {e.Message}"

    // Call parse with only NumberStyles.None
    // Exception thrown because of presence of white space and sign
    try
        printfn $"""{BigInteger.Parse(" -300 ", NumberStyles.None, new BigIntegerFormatProvider())}"""
    with :? FormatException as e ->
        printfn $"{e.GetType().Name}: \n   {e.Message}"
// The example displays the followingoutput:
//       -300
//       -300
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.
//       FormatException:
//          The value could not be parsed.

' Call parse with default values of style and provider
Console.WriteLine(BigInteger.Parse("  -300   ", _
                  NumberStyles.Integer, CultureInfo.CurrentCulture))
' Call parse with default values of style and provider supporting tilde as negative sign
Console.WriteLine(BigInteger.Parse("   ~300  ", _
                                   NumberStyles.Integer, New BigIntegerFormatProvider()))
' Call parse with only AllowLeadingWhite and AllowTrailingWhite
' Exception thrown because of presence of negative sign
Try
   Console.WriteLIne(BigInteger.Parse("    ~300   ", _
                                      NumberStyles.AllowLeadingWhite Or NumberStyles.AllowTrailingWhite, _
                                      New BigIntegerFormatProvider()))
Catch e As FormatException
   Console.WriteLine("{0}: {1}   {2}", e.GetType().Name, vbCrLf, e.Message)
End Try                                   
' Call parse with only AllowHexSpecifier
' Exception thrown because of presence of negative sign
Try
   Console.WriteLIne(BigInteger.Parse("-3af", NumberStyles.AllowHexSpecifier, _
                                      New BigIntegerFormatProvider()))
Catch e As FormatException
   Console.WriteLine("{0}: {1}   {2}", e.GetType().Name, vbCrLf, e.Message)
End Try                                 
' Call parse with only NumberStyles.None
' Exception thrown because of presence of white space and sign
Try
   Console.WriteLIne(BigInteger.Parse(" -300 ", NumberStyles.None, _
                                      New BigIntegerFormatProvider()))
Catch e As FormatException
   Console.WriteLine("{0}: {1}   {2}", e.GetType().Name, vbCrLf, e.Message)
End Try
' The example displays the following output:
'       -300
'       -300
'       FormatException:
'          The value could not be parsed.
'       FormatException:
'          The value could not be parsed.
'       FormatException:
'          The value could not be parsed.

Un certain nombre d’appels individuels à la Parse(String, NumberStyles, IFormatProvider) méthode passent une instance de la classe suivante BigIntegerFormatProvider , 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 = 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

Le style paramètre définit les éléments de style (tels que l’espace blanc, le symbole de signe positif ou négatif, le symbole de séparateur de groupe ou le symbole décimal) autorisés dans le paramètre pour que value l’opération d’analyse réussisse. styles doit être une combinaison d’indicateurs de bits de l’énumération NumberStyles . Le style paramètre rend cette surcharge de méthode utile lorsque value contient la représentation sous forme de chaîne d’une valeur hexadécimale, lorsque le système numérique (décimal ou hexadécimal) représenté par value est connu uniquement au moment de l’exécution, ou lorsque vous souhaitez interdire l’espace blanc ou un symbole valuede connexion.

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 style elle inclut NumberStyles.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 Descriptif
Ws Espace blanc facultatif. L’espace blanc peut apparaître au début de value si style inclut l’indicateur NumberStyles.AllowLeadingWhite , et il peut apparaître à la fin de value si style inclut l’indicateur NumberStyles.AllowTrailingWhite .
$ Symbole monétaire propre à la culture. Sa position dans la chaîne est définie par les NumberFormatInfo.CurrencyNegativePattern propriétés de NumberFormatInfo.CurrencyPositivePattern la culture indiquées par le provider paramètre. Le symbole monétaire de la culture actuelle peut apparaître s’il valuestyle inclut l’indicateur NumberStyles.AllowCurrencySymbol .
signe 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 . Les parenthèses peuvent être utilisées pour value indiquer une valeur négative si style l’indicateur NumberStyles.AllowParentheses est inclus.
Chiffres

fractional_digits

exponential_digits		 Séquence de chiffres comprises entre 0 et 9. Pour fractional_digits, seul le chiffre 0 est valide.
, Symbole de séparateur de groupe spécifique à la culture. Le symbole de séparation de groupe de la culture spécifiée peut provider apparaître si valuestyle l’indicateur NumberStyles.AllowThousands est inclus.
. Symbole décimal spécifique à la culture. Le symbole décimal de la culture désignée par provider peut apparaître s’il stylevalue inclut l’indicateurNumberStyles.AllowDecimalPoint. Seul le chiffre 0 peut apparaître sous la forme d’un chiffre fractionnel pour que l’opération d’analyse réussisse ; si fractional_digits inclut un autre chiffre, un FormatException est levée.
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 s’il style inclut l’indicateur NumberStyles.AllowExponent .
hexdigits Séquence de chiffres hexadécimaux de 0 à f, ou de 0 à F.

Note

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

Une chaîne avec des chiffres uniquement (qui correspond au NumberStyles.None style) analyse toujours correctement. La plupart des éléments de contrôle membres restants NumberStyles qui peuvent être présents, mais qui ne sont pas obligatoires pour être présents, dans la chaîne d’entrée. Le tableau suivant indique comment les membres individuels NumberStyles affectent les éléments qui peuvent être présents dans value.

Valeur NumberStyles Éléments autorisés en valeur en plus des chiffres
None Élément chiffres uniquement.
AllowDecimalPoint Éléments décimaux (.) et fractionnaires .
AllowExponent Caractère « e » ou « E », qui indique une notation exponentielle. avec exponential_digits.
AllowLeadingWhite Élément ws au début de value.
AllowTrailingWhite Élément ws à la fin de value.
AllowLeadingSign Élément de signe au début de value.
AllowTrailingSign Élément de signe à la fin de value.
AllowParentheses Élément de connexion sous la 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 value, et le symbole décimal (.). Le value paramètre peut également utiliser la notation exponentielle.
Number Éléments ws, signsé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 Parse méthode pour aller-retour sur la représentation sous forme de chaîne d’une BigInteger valeur qui a été générée 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 BigInteger chaîne des 50 chiffres les plus significatifs de la valeur d’origine et les données peuvent être perdues lorsque vous utilisez la Parse méthode pour restaurer la BigInteger valeur.

Contrairement aux autres NumberStyles valeurs, qui autorisent mais ne nécessitent pas la présence d’éléments de style particuliers, valuela valeur de NumberStyles.AllowHexSpecifier style signifie que les caractères numériques individuels dans value sont toujours interprétés comme des caractères hexadécimaux. Les caractères hexadécimaux valides sont 0-9, A-F et a-f. Les seuls autres indicateurs qui peuvent être combinés avec le style paramètre sont NumberStyles.AllowLeadingWhite et NumberStyles.AllowTrailingWhite. (L’énumération NumberStyles comprend un style de nombre composite, HexNumberqui inclut les deux indicateurs d’espace blanc.)

Note

S’il value s’agit de 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 la différencie comme un nombre hexadécimal. Cela provoque l’échec de la conversion.

Si value elle est une chaîne hexadécimale, la Parse(String, NumberStyles) méthode interprète value comme un nombre négatif stocké à l’aide de la représentation complète 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 de l’ordre le plus élevé du premier octet en value tant que bit de signe. Pour vous assurer qu’une chaîne hexadécimale est correctement interprétée comme un nombre positif, le premier chiffre value doit avoir la valeur zéro. Par exemple, la méthode interprète 0x80 comme une valeur négative, mais elle interprète soit soit 0x0800x0080 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" };
      foreach (string hexString in hexStrings)
      {
         BigInteger number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number);
      }
   }
}
// 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
    let number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
    printfn $"Converted 0x{hexString} to {number:N0}."
// 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" }
      For Each hexString As String In hexStrings
         Dim number As BigInteger = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number)
      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. En règle générale, provider il peut s’agir de l’une des options suivantes :

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

  • Objet NumberFormatInfo qui fournit des informations de mise en forme. (Son implémentation de GetFormat just returns lui-même.)

  • Objet personnalisé qui implémente IFormatProvider et utilise la GetFormat méthode pour instancier et renvoyer l’objet NumberFormatInfo qui fournit des informations de mise en forme.

Si provider c’est nullle cas, l’objet NumberFormatInfo de la culture actuelle est utilisé.

Voir aussi

S’applique à

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Convertit la représentation d’un nombre, contenue dans l’étendue de caractères en lecture seule spécifiée, dans un style spécifié en son BigInteger équivalent.

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

Paramètres

value
ReadOnlySpan<Char>

Étendue en lecture seule de caractères qui contient le nombre à convertir.

style
NumberStyles

Combinaison au niveau du bit des valeurs d’énumération qui spécifient le format autorisé de value.

provider
IFormatProvider

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

Retours

BigInteger

Valeur équivalente au nombre spécifié dans le value paramètre.

Implémente

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Exceptions

ArgumentException

style n’est pas une NumberStyles valeur.

- ou -

styleinclut le ou HexNumber l’indicateur AllowHexSpecifier avec une autre valeur.

ArgumentNullException

value a la valeur null.

FormatException

value ne respecte pas le modèle d’entrée spécifié par style.

Remarques

Le style paramètre définit les éléments de style (tels que l’espace blanc, le symbole de signe positif ou négatif, le symbole de séparateur de groupe ou le symbole décimal) autorisés dans le paramètre pour que value l’opération d’analyse réussisse. styles doit être une combinaison d’indicateurs de bits de l’énumération NumberStyles . Le style paramètre rend cette surcharge de méthode utile lorsque value contient la représentation d’une valeur hexadécimale, lorsque le système numérique (décimal ou hexadécimal) représenté par value est connu uniquement au moment de l’exécution, ou lorsque vous souhaitez interdire l’espace blanc ou un symbole de connexion .value

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 style elle inclut NumberStyles.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 Descriptif
Ws Espace blanc facultatif. L’espace blanc peut apparaître au début de value si style inclut l’indicateur NumberStyles.AllowLeadingWhite , et il peut apparaître à la fin de value si style inclut l’indicateur NumberStyles.AllowTrailingWhite .
$ Symbole monétaire propre à la culture. Sa position est value définie par les NumberFormatInfo.CurrencyNegativePattern propriétés de NumberFormatInfo.CurrencyPositivePattern la culture indiquées par le provider paramètre. Le symbole monétaire de la culture actuelle peut apparaître s’il valuestyle inclut l’indicateur NumberStyles.AllowCurrencySymbol .
signe 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 . Les parenthèses peuvent être utilisées pour value indiquer une valeur négative si style l’indicateur NumberStyles.AllowParentheses est inclus.
Chiffres

fractional_digits

exponential_digits		 Séquence de chiffres comprises entre 0 et 9. Pour fractional_digits, seul le chiffre 0 est valide.
, Symbole de séparateur de groupe spécifique à la culture. Le symbole de séparation de groupe de la culture spécifiée peut provider apparaître si valuestyle l’indicateur NumberStyles.AllowThousands est inclus.
. Symbole décimal spécifique à la culture. Le symbole décimal de la culture désignée par provider peut apparaître s’il stylevalue inclut l’indicateurNumberStyles.AllowDecimalPoint. Seul le chiffre 0 peut apparaître sous la forme d’un chiffre fractionnel pour que l’opération d’analyse réussisse ; si fractional_digits inclut un autre chiffre, un FormatException est levée.
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 s’il style inclut l’indicateur NumberStyles.AllowExponent .
hexdigits Séquence de chiffres hexadécimaux de 0 à f, ou de 0 à F.

Note

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

Un value chiffre avec des chiffres uniquement (qui correspond au NumberStyles.None style) analyse toujours avec succès. La plupart des éléments de contrôle des membres restants NumberStyles qui peuvent être présents, mais qui ne sont pas obligatoires pour être présents, dans value. Le tableau suivant indique comment les membres individuels NumberStyles affectent les éléments qui peuvent être présents dans value.

Valeur NumberStyles Éléments autorisés en valeur en plus des chiffres
None Élément chiffres uniquement.
AllowDecimalPoint Éléments décimaux (.) et fractionnaires .
AllowExponent Caractère « e » ou « E », qui indique une notation exponentielle. avec exponential_digits.
AllowLeadingWhite Élément ws au début de value.
AllowTrailingWhite Élément ws à la fin de value.
AllowLeadingSign Élément de signe au début de value.
AllowTrailingSign Élément de signe à la fin de value.
AllowParentheses Élément de connexion sous la 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 value, et le symbole décimal (.). Le value paramètre peut également utiliser la notation exponentielle.
Number Éléments ws, signséparateur de groupe (,) et virgule décimale (.).
Any Tous les éléments. Toutefois, value ne peut pas représenter un nombre hexadécimal.

Contrairement aux autres NumberStyles valeurs, qui autorisent mais ne nécessitent pas la présence d’éléments de style particuliers, valuela valeur de NumberStyles.AllowHexSpecifier style signifie que les caractères numériques individuels dans value sont toujours interprétés comme des caractères hexadécimaux. Les caractères hexadécimaux valides sont 0-9, A-F et a-f. Les seuls autres indicateurs qui peuvent être combinés avec le style paramètre sont NumberStyles.AllowLeadingWhite et NumberStyles.AllowTrailingWhite. (L’énumération NumberStyles comprend un style de nombre composite, HexNumberqui 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. En règle générale, provider il peut s’agir de l’une des options suivantes :

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

  • Objet NumberFormatInfo qui fournit des informations de mise en forme. (Son implémentation de GetFormat just returns lui-même.)

  • Objet personnalisé qui implémente IFormatProvider et utilise la GetFormat méthode pour instancier et renvoyer l’objet NumberFormatInfo qui fournit des informations de mise en forme.

Si provider c’est nullle cas, l’objet NumberFormatInfo de la culture actuelle est utilisé.

Voir aussi

S’applique à

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) 

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

Paramètres

utf8Text
ReadOnlySpan<Byte>
style
NumberStyles
provider
IFormatProvider

Retours

BigInteger

Implémente

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

S’applique à

Parse(String, IFormatProvider)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

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

public:
 static System::Numerics::BigInteger Parse(System::String ^ value, IFormatProvider ^ provider);
public:
 static System::Numerics::BigInteger Parse(System::String ^ value, IFormatProvider ^ provider) = IParsable<System::Numerics::BigInteger>::Parse;
public static System.Numerics.BigInteger Parse(string value, IFormatProvider provider);
public static System.Numerics.BigInteger Parse(string value, IFormatProvider? provider);
static member Parse : string * IFormatProvider -> System.Numerics.BigInteger
Public Shared Function Parse (value As String, provider As IFormatProvider) As BigInteger

Paramètres

value
String

Chaîne qui contient un nombre à convertir.

provider
IFormatProvider

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

Retours

BigInteger

Valeur équivalente au nombre spécifié dans le value paramètre.

Implémente

Parse(String, IFormatProvider)

Exceptions

ArgumentNullException

value a la valeur null.

FormatException

value n’est pas au format correct.

Exemples

Les exemples suivants montrent deux façons de définir le tilde (~) comme signe négatif pour la mise en forme des BigInteger valeurs. Notez que pour afficher les BigInteger valeurs au même format que les chaînes d’origine, votre code doit appeler la BigInteger.ToString(IFormatProvider) méthode et le transmettre à l’objet NumberFormatInfo qui fournit des informations de mise en forme.

Le premier exemple définit une classe qui implémente IFormatProvider et utilise la GetFormat méthode pour renvoyer l’objet NumberFormatInfo qui fournit des informations de mise en forme.

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 = 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

Un BigInteger objet peut ensuite être instancié avec le code suivant :

BigInteger number = BigInteger.Parse("~6354129876", new BigIntegerFormatProvider());
// Display value using same formatting information
Console.WriteLine(number.ToString(new BigIntegerFormatProvider()));
// Display value using formatting of current culture
Console.WriteLine(number);

let number = BigInteger.Parse("~6354129876", BigIntegerFormatProvider())
printfn $"{number.ToString(BigIntegerFormatProvider())}"
printfn $"{number}"

Dim number As BigInteger = BigInteger.Parse("~6354129876", New BigIntegerFormatProvider)
' Display value using same formatting information
Console.WriteLine(number.ToString(New BigIntegerFormatProvider))
' Display value using formatting of current culture
Console.WriteLine(number)

Le deuxième exemple est plus simple. Il transmet l’objet NumberFormatInfo qui fournit des informations de mise en forme au provider paramètre.

NumberFormatInfo fmt = new NumberFormatInfo();
fmt.NegativeSign = "~";

BigInteger number = BigInteger.Parse("~6354129876", fmt);
// Display value using same formatting information
Console.WriteLine(number.ToString(fmt));
// Display value using formatting of current culture
Console.WriteLine(number);

let fmt = NumberFormatInfo()
fmt.NegativeSign <- "~"

let number = BigInteger.Parse("~6354129876", fmt)
printfn $"{number.ToString fmt}"
printfn $"{number}"

Dim fmt As New NumberFormatInfo()
fmt.NegativeSign = "~"

Dim number As BigInteger = BigInteger.Parse("~6354129876", fmt)
' Display value using same formatting information
Console.WriteLine(number.ToString(fmt))
' Display value using formatting of current culture
Console.WriteLine(number)

Remarques

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

[ws][sign]chiffres[ws]

Les éléments entre crochets ([ et ]) sont facultatifs. Le tableau suivant décrit chaque élément.

Élément Descriptif
Ws Espace blanc facultatif.
signe Signe facultatif. Les caractères de signe valides sont déterminés par les NumberFormatInfo.NegativeSign propriétés de NumberFormatInfo.PositiveSign l’objet NumberFormatInfo retourné par la méthode de GetFormat l’objetprovider.
Chiffres Séquence de chiffres allant de 0 à 9. Tous les zéros non significatifs sont ignorés.

Note

La chaîne spécifiée par le value paramètre est interprétée à l’aide du NumberStyles.Integer style. Il ne peut pas contenir de séparateurs de groupes ou de séparateur décimal, et il ne peut pas avoir une partie décimale.

Important

Si vous utilisez la Parse méthode pour aller-retour sur la représentation sous forme de chaîne d’une BigInteger valeur qui a été générée 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 BigInteger chaîne des 50 chiffres les plus significatifs de la valeur d’origine et les données peuvent être perdues lorsque vous utilisez la Parse méthode pour restaurer la BigInteger valeur.

Le paramètre est une IFormatProvider implémentation dont GetFormat la provider méthode retourne un NumberFormatInfo objet qui fournit des informations de mise en forme spécifiques à la culture. Lorsque la Parse(String, IFormatProvider) méthode est appelée, elle appelle la provider méthode du GetFormat paramètre et la transmet à un Type objet qui représente le NumberFormatInfo type. La GetFormat méthode retourne ensuite l’objet NumberFormatInfo qui fournit des informations sur le format du value paramètre. Il existe trois façons d’utiliser le provider paramètre pour fournir des informations de mise en forme personnalisées à l’opération d’analyse :

  • Vous pouvez transmettre un CultureInfo objet 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.

  • Vous pouvez transmettre l’objet réel NumberFormatInfo qui fournit des informations de mise en forme numérique. (Son implémentation de GetFormat just returns lui-même.)

  • Vous pouvez passer un 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 c’est nullle cas, la mise en forme est value interprétée en fonction de l’objet NumberFormatInfo de la culture actuelle.

Voir aussi

S’applique à

Parse(ReadOnlySpan<Byte>, IFormatProvider) 

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

Paramètres

utf8Text
ReadOnlySpan<Byte>
provider
IFormatProvider

Retours

BigInteger

Implémente

Parse(ReadOnlySpan<Byte>, IFormatProvider)

S’applique à

Parse(ReadOnlySpan<Char>, IFormatProvider)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

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

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

Paramètres

s
ReadOnlySpan<Char>

Étendue de caractères à analyser.

provider
IFormatProvider

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

Retours

BigInteger

Résultat de l’analyse s.

Implémente

Parse(ReadOnlySpan<Char>, IFormatProvider)

S’applique à

Parse(String, NumberStyles)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

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

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

Paramètres

value
String

Chaîne qui contient un nombre à convertir.

style
NumberStyles

Combinaison au niveau du bit des valeurs d’énumération qui spécifient le format autorisé de value.

Retours

BigInteger

Valeur équivalente au nombre spécifié dans le value paramètre.

Exceptions

ArgumentException

style n’est pas une NumberStyles valeur.

- ou -

styleinclut le ou HexNumber l’indicateur AllowHexSpecifier avec une autre valeur.

ArgumentNullException

value a la valeur null.

FormatException

value ne respecte pas le modèle d’entrée spécifié par NumberStyles.

Exemples

L’exemple suivant illustre les appels à la Parse(String, NumberStyles) méthode avec plusieurs valeurs possibles pour le style paramètre. Il montre comment interpréter une chaîne en tant que valeur hexadécimale et comment interdire les espaces et les symboles de signe.

BigInteger number;
// Method should succeed (white space and sign allowed)
number = BigInteger.Parse("   -68054   ", NumberStyles.Integer);
Console.WriteLine(number);
// Method should succeed (string interpreted as hexadecimal)
number = BigInteger.Parse("68054", NumberStyles.AllowHexSpecifier);
Console.WriteLine(number);
// Method call should fail: sign not allowed
try
{
   number = BigInteger.Parse("   -68054  ", NumberStyles.AllowLeadingWhite
                                            | NumberStyles.AllowTrailingWhite);
   Console.WriteLine(number);
}
catch (FormatException e)
{
   Console.WriteLine(e.Message);
}
// Method call should fail: white space not allowed
try
{
   number = BigInteger.Parse("   68054  ", NumberStyles.AllowLeadingSign);
   Console.WriteLine(number);
}
catch (FormatException e)
{
   Console.WriteLine(e.Message);
}
//
// The method produces the following output:
//
//     -68054
//     426068
//     Input string was not in a correct format.
//     Input string was not in a correct format.

    let number = BigInteger.Parse("   -68054   ", NumberStyles.Integer)
    printfn $"{number}"
    let number = BigInteger.Parse("68054", NumberStyles.AllowHexSpecifier)
    printfn $"{number}"

    try
        let number =
            BigInteger.Parse("   -68054  ", NumberStyles.AllowLeadingWhite ||| NumberStyles.AllowTrailingWhite)

        printfn $"{number}"
    with :? FormatException as e ->
        printfn $"{e.Message}"

    try
        let number = BigInteger.Parse("   68054  ", NumberStyles.AllowLeadingSign)
        printfn $"{number}"
    with :? FormatException as e ->
        printfn $"{e.Message}"
// The method produces the following output:
//     -68054
//     426068
//     Input string was not in a correct format.
//     Input string was not in a correct format.

Dim number As BigInteger 
' Method should succeed (white space and sign allowed)
number = BigInteger.Parse("   -68054   ", NumberStyles.Integer)
Console.WriteLine(number)
' Method should succeed (string interpreted as hexadecimal)
number = BigInteger.Parse("68054", NumberStyles.AllowHexSpecifier)
Console.WriteLine(number)
' Method call should fail: sign not allowed
Try
   number = BigInteger.Parse("   -68054  ", NumberStyles.AllowLeadingWhite _
                                            Or NumberStyles.AllowTrailingWhite)
   Console.WriteLine(number)
Catch e As FormatException
   Console.WriteLine(e.Message)
End Try                                                     
' Method call should fail: white space not allowed
Try
   number = BigInteger.Parse("   68054  ", NumberStyles.AllowLeadingSign)
   Console.WriteLine(number)
Catch e As FormatException
   Console.WriteLine(e.Message)
End Try    
'
' The method produces the following output:
'
'     -68054
'     426068
'     Input string was not in a correct format.
'     Input string was not in a correct format.

Remarques

Le style paramètre définit les éléments de style (tels que l’espace blanc, le symbole de signe positif ou négatif, le symbole de séparateur de groupe ou le symbole décimal) autorisés dans le paramètre pour que value l’opération d’analyse réussisse. styles doit être une combinaison d’indicateurs de bits de l’énumération NumberStyles . Le style paramètre rend cette surcharge de méthode utile lorsque value contient la représentation sous forme de chaîne d’une valeur hexadécimale, lorsque le système numérique (décimal ou hexadécimal) représenté par value est connu uniquement au moment de l’exécution, ou lorsque vous souhaitez interdire l’espace blanc ou un symbole valuede connexion.

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 style elle inclut NumberStyles.AllowHexSpecifier, le value paramètre peut contenir 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 Descriptif
Ws Espace blanc facultatif. L’espace blanc peut apparaître au début de value si style inclut l’indicateur NumberStyles.AllowLeadingWhite , et il peut apparaître à la fin de value si style inclut l’indicateur NumberStyles.AllowTrailingWhite .
$ Symbole monétaire propre à la culture. Sa position dans la chaîne est définie par les propriétés et NumberFormatInfo.CurrencyPositivePattern les NumberFormatInfo.CurrencyNegativePattern propriétés de la culture actuelle. Le symbole monétaire de la culture actuelle peut apparaître s’il valuestyle inclut l’indicateur NumberStyles.AllowCurrencySymbol .
signe 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 . Les parenthèses peuvent être utilisées pour value indiquer une valeur négative si style l’indicateur NumberStyles.AllowParentheses est inclus.
Chiffres

fractional_digits

exponential_digits		 Séquence de chiffres comprises entre 0 et 9. Pour fractional_digits, seul le chiffre 0 est valide.
, Symbole de séparateur de groupe spécifique à la culture. Le séparateur de groupe de la culture actuelle peut apparaître s’il valuestyle inclut l’indicateur NumberStyles.AllowThousands .
. Symbole décimal spécifique à la culture. Le symbole décimal de la culture actuelle peut apparaître s’il valuestyle inclut l’indicateur NumberStyles.AllowDecimalPoint . Seul le chiffre 0 peut apparaître sous la forme d’un chiffre fractionnel pour que l’opération d’analyse réussisse ; si fractional_digits inclut un autre chiffre, un FormatException est levée.
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 s’il style inclut l’indicateur NumberStyles.AllowExponent .
hexdigits Séquence de chiffres hexadécimaux de 0 à f, ou de 0 à F.

Note

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

Une chaîne avec des chiffres uniquement (qui correspond au NumberStyles.None style) analyse toujours correctement. La plupart des éléments de contrôle membres restants NumberStyles qui peuvent être présents, mais qui ne sont pas obligatoires pour être présents, dans la chaîne d’entrée. Le tableau suivant indique comment les membres individuels NumberStyles affectent les éléments qui peuvent être présents dans value.

valeur NumberStyles Éléments autorisés en value plus des chiffres
None Élément chiffres uniquement.
AllowDecimalPoint Éléments décimaux (.) et fractionnaires .
AllowExponent Caractère « e » ou « E », qui indique une notation exponentielle, ainsi que exponential_digits.
AllowLeadingWhite Élément ws au début de value.
AllowTrailingWhite Élément ws à la fin de value.
AllowLeadingSign Élément de signe au début de value.
AllowTrailingSign Élément de signe à la fin de value.
AllowParentheses Élément de connexion sous la 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 value, et le symbole décimal (.). Le value paramètre peut également utiliser la notation exponentielle.
Number Éléments ws, signsé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 Parse méthode pour aller-retour sur la représentation sous forme de chaîne d’une BigInteger valeur qui a été générée 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 BigInteger chaîne des 50 chiffres les plus significatifs de la valeur d’origine et les données peuvent être perdues lorsque vous utilisez la Parse méthode pour restaurer la BigInteger valeur.

Contrairement aux autres NumberStyles valeurs, qui permettent, mais ne nécessitent pas, la présence d’éléments de style particuliers dans value, la NumberStyles.AllowHexSpecifier valeur de style signifie que les caractères numériques individuels dans value sont toujours interprétés comme des caractères hexadécimaux. Les caractères hexadécimaux valides sont 0-9, A-F et a-f. Les seuls autres indicateurs qui peuvent être combinés avec le style paramètre sont NumberStyles.AllowLeadingWhite et NumberStyles.AllowTrailingWhite. (L’énumération NumberStyles comprend un style de nombre composite, HexNumberqui inclut les deux indicateurs d’espace blanc.)

Note

S’il value s’agit de 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 la différencie comme un nombre hexadécimal. Cela provoque l’échec de la conversion.

Si value elle est une chaîne hexadécimale, la Parse(String, NumberStyles) méthode interprète value comme un nombre négatif stocké à l’aide de la représentation complète 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 de l’ordre le plus élevé du premier octet en value tant que bit de signe. Pour vous assurer qu’une chaîne hexadécimale est correctement interprétée comme un nombre positif, le premier chiffre value doit avoir la valeur zéro. Par exemple, la méthode interprète 0x80 comme une valeur négative, mais elle interprète soit soit 0x0800x0080 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" };
      foreach (string hexString in hexStrings)
      {
         BigInteger number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number);
      }
   }
}
// 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
    let number = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
    printfn $"Converted 0x{hexString} to {number:N0}."
// 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" }
      For Each hexString As String In hexStrings
         Dim number As BigInteger = BigInteger.Parse(hexString, NumberStyles.AllowHexSpecifier)
         Console.WriteLine("Converted 0x{0} to {1}.", hexString, number)
      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 value paramètre est analysé à l’aide des informations de mise en forme dans un NumberFormatInfo objet initialisé pour la culture système actuelle. Pour spécifier la culture dont les informations de mise en forme sont utilisées pour l’opération d’analyse, appelez la Parse(String, NumberStyles, IFormatProvider) surcharge.

Voir aussi

S’applique à

Parse(String)

Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs
Source:
BigInteger.cs

Convertit la représentation sous forme de chaîne d’un nombre en son BigInteger équivalent.

public:
 static System::Numerics::BigInteger Parse(System::String ^ value);
public static System.Numerics.BigInteger Parse(string value);
static member Parse : string -> System.Numerics.BigInteger
Public Shared Function Parse (value As String) As BigInteger

Paramètres

value
String

Chaîne qui contient le nombre à convertir.

Retours

BigInteger

Valeur équivalente au nombre spécifié dans le value paramètre.

Exceptions

ArgumentNullException

value a la valeur null.

FormatException

value n’est pas au format correct.

Exemples

L’exemple suivant utilise la Parse(String) méthode pour instancier deux BigInteger objets. Il multiplie chaque objet par un autre numéro, puis appelle la Compare méthode pour déterminer la relation entre les deux valeurs.

string stringToParse = String.Empty;
try
{
   // Parse two strings.
   string string1, string2;
   string1 = "12347534159895123";
   string2 = "987654321357159852";
   stringToParse = string1;
   BigInteger number1 = BigInteger.Parse(stringToParse);
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number1);
   stringToParse = string2;
   BigInteger number2 = BigInteger.Parse(stringToParse);
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number2);
   // Perform arithmetic operations on the two numbers.
   number1 *= 3;
   number2 *= 2;
   // Compare the numbers.
   int result = BigInteger.Compare(number1, number2);
   switch (result)
   {
      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;
   }
}
catch (FormatException)
{
   Console.WriteLine("Unable to parse {0}.", stringToParse);
}
// The example displays the following output:
//    Converted '12347534159895123' to 12,347,534,159,895,123.
//    Converted '987654321357159852' to 987,654,321,357,159,852.
//    1975308642714319704 is greater than 37042602479685369.

    let mutable stringToParse = ""

    try
        // Parse two strings.
        let string1 = "12347534159895123"
        let string2 = "987654321357159852"
        stringToParse <- string1
        let number1 = BigInteger.Parse stringToParse
        printfn $"Converted '{stringToParse}' to {number1:N0}."
        stringToParse <- string2
        let number2 = BigInteger.Parse stringToParse
        printfn $"Converted '{stringToParse}' to {number2:N0}."
        // Perform arithmetic operations on the two numbers.
        let number1 = number1 * bigint 3
        let number2 = number2 * bigint 2
        // Compare the numbers.
        let result = BigInteger.Compare(number1, number2)

        match result with
        | -1 -> printfn $"{number2:N0} is greater than {number1:N0}."
        | 0 -> printfn $"{number1:N0} is equal to {number2:N0}."
        | 1
        | _ -> printfn $"{number1:N0} is greater than {number2:N0}."
    with :? FormatException ->
        printfn $"Unable to parse {stringToParse}."

// The example displays the following output:
//    Converted '12347534159895123' to 12,347,534,159,895,123.
//    Converted '987654321357159852' to 987,654,321,357,159,852.
//    1975308642714319704 is greater than 37042602479685369.

Dim stringToParse As String = String.Empty
Try
   ' Parse two strings.
   Dim string1, string2 As String
   string1 = "12347534159895123"
   string2 = "987654321357159852"
   stringToParse = string1
   Dim number1 As BigInteger = BigInteger.Parse(stringToParse)
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number1)
   stringToParse = string2
   Dim number2 As BigInteger = BigInteger.Parse(stringToParse)
   Console.WriteLine("Converted '{0}' to {1:N0}.", stringToParse, number2)
   ' Perform arithmetic operations on the two numbers.
   number1 *= 3
   number2 *= 2
   ' Compare the numbers.
   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      
Catch e As FormatException
   Console.WriteLine("Unable to parse {0}.", stringToParse)
End Try
' The example displays the following output:
'    Converted '12347534159895123' to 12,347,534,159,895,123.
'    Converted '987654321357159852' to 987,654,321,357,159,852.
'    1975308642714319704 is greater than 37042602479685369.

Remarques

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

[ws][sign]chiffres[ws]

Les éléments entre crochets ([ et ]) sont facultatifs. Le tableau suivant décrit chaque élément.

Élément Descriptif
Ws Espace blanc facultatif.
signe Signe facultatif. Les caractères de signe valides sont déterminés par les propriétés et NumberFormatInfo.PositiveSign les NumberFormatInfo.NegativeSign propriétés de la culture actuelle.
Chiffres Séquence de chiffres allant de 0 à 9. Tous les zéros non significatifs sont ignorés.

Note

La chaîne spécifiée par le value paramètre est interprétée à l’aide du NumberStyles.Integer style. Il ne peut pas contenir de séparateurs de groupes ou de séparateur décimal, et il ne peut pas avoir une partie décimale.

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

Important

Si vous utilisez la Parse méthode pour aller-retour sur la représentation sous forme de chaîne d’une BigInteger valeur qui a été générée 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 BigInteger chaîne des 50 chiffres les plus significatifs de la valeur d’origine et les données peuvent être perdues lorsque vous utilisez la Parse méthode pour restaurer la BigInteger valeur.

Voir aussi

S’applique à