BigInteger.Parse Méthode

  • Référence

Définition

Espace de noms:
System.Numerics
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 sa représentation BigInteger équivalente.

Surcharges

Parse(String)

Convertit la représentation sous forme de chaîne d'un nombre en sa représentation BigInteger équivalente.
Parse(ReadOnlySpan<Char>, IFormatProvider)

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

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

Convertit la représentation sous forme de chaîne d'un nombre, ayant un format spécifique à la culture spécifié, en sa représentation BigInteger équivalente.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

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

Convertit la représentation sous forme de chaîne d'un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation BigInteger équivalente.

Parse(String)

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

Convertit la représentation sous forme de chaîne d'un nombre en sa représentation BigInteger équivalente.

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 contenant le nombre à convertir.

Retours

BigInteger

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

Exceptions

ArgumentNullException

value a la valeur null.

FormatException

Le format de value est incorrect.

Exemples

L’exemple suivant utilise la Parse(String) méthode pour instancier deux BigInteger objets. Il multiplie chaque objet par un autre nombre, 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.

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] 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 compris entre 0 et 9. Tous les zéros de début sont ignorés.

Notes

La chaîne spécifiée par le paramètre est interprétée à l’aide value du NumberStyles.Integer style . Il ne peut pas contenir de séparateurs de groupe ou de séparateur décimal, et il ne peut pas avoir de 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 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 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 Parse méthode pour restaurer la BigInteger valeur.

Voir aussi

S’applique à

Parse(ReadOnlySpan<Char>, IFormatProvider)

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

Analyse une étendue de caractères dans 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 des caractères à analyser.

provider
IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture concernant 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

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

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 contenant un nombre à convertir.

style
NumberStyles

Combinaison de bits de valeurs d'énumération qui spécifie le format autorisé de value.

Retours

BigInteger

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

Exceptions

ArgumentException

style n’est pas une valeur NumberStyles.

- ou -

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

ArgumentNullException

value a la valeur null.

FormatException

value ne se conforme pas avec 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.

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 séparateur de groupe ou le symbole décimal) autorisés dans le value paramètre pour que 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 de nombres (décimal ou hexadécimal) représenté par value n’est connu qu’au moment de l’exécution, ou lorsque vous souhaitez interdire les espaces blancs ou un symbole de connexion dans 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 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 Description
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 spécifique à la culture. Sa position dans la chaîne est définie par les NumberFormatInfo.CurrencyNegativePattern propriétés et NumberFormatInfo.CurrencyPositivePattern de la culture actuelle. Le symbole monétaire de la culture actuelle 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 . Les parenthèses peuvent être utilisées dans value pour indiquer une valeur négative si style inclut l’indicateur NumberStyles.AllowParentheses .
chiffres

fractional_digits

exponential_digits		 Séquence de chiffres comprises entre 0 et 9. Pour fractional_digits, seul le chiffre 0 est valide.
, Symbole de séparateur de groupe spécifique à la culture. Le séparateur de groupe de la culture actuelle 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 actuelle peut apparaître dans value si style inclut l’indicateur NumberStyles.AllowDecimalPoint . Seul le chiffre 0 peut apparaître en tant que chiffre fractionnaire 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 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 (U+0000) de fin dans s sont ignorés par l’opération d’analyse, quelle que soit la valeur de l’argument style .

Une chaîne avec des chiffres uniquement (qui correspond au NumberStyles.None style) analyse toujours correctement. La plupart des membres restants NumberStyles contrôlent les éléments qui peuvent être présents, mais qui ne sont pas obligatoirement 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 digits uniquement.
AllowDecimalPoint Éléments décimaux (.) et à chiffres 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 sign au début de value.
AllowTrailingSign Élément sign à la fin de value.
AllowParentheses Élément sign 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, sign, séparateur de groupe (,) et 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 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 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 Parse méthode pour restaurer la BigInteger valeur.

Contrairement aux autres NumberStyles valeurs, qui autorisent, mais n’exigent pas, la présence d’éléments de style particuliers dans value, la 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 inclut un style numérique 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 Parse(String, NumberStyles) 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 comme value 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 dans value doit avoir la valeur zéro. Par exemple, la méthode interprète 0x80 comme une valeur négative, mais elle interprète ou 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.

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, IFormatProvider)

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

Convertit la représentation sous forme de chaîne d'un nombre, ayant un format spécifique à la culture spécifié, en sa représentation BigInteger équivalente.

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 contenant un nombre à convertir.

provider
IFormatProvider

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

Retours

BigInteger

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

Implémente

Parse(String, IFormatProvider)

Exceptions

ArgumentNullException

value a la valeur null.

FormatException

Le format de value est incorrect.

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 dans le même format que les chaînes d’origine, votre code doit appeler la BigInteger.ToString(IFormatProvider) méthode et lui 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;
      }
   }
}

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);

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);

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] 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 l’objet NumberFormatInfo retourné par la méthode de GetFormat l’objetprovider.
chiffres Séquence de chiffres compris entre 0 et 9. Tous les zéros de début sont ignorés.

Notes

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

Important

Si vous utilisez la Parse méthode pour aller-retour 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 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 Parse méthode pour restaurer la BigInteger valeur.

Le provider paramètre est une IFormatProvider implémentation dont GetFormat la 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 lui 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 passer 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érique 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 retourne simplement elle-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 est null, la mise en forme de value est interprétée en fonction de l’objet NumberFormatInfo de la culture actuelle.

Voir aussi

S’applique à

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

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

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

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 de bits de valeurs d'énumération qui spécifie le format autorisé de value.

provider
IFormatProvider

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

Retours

BigInteger

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

Implémente

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Exceptions

ArgumentException

style n’est pas une valeur NumberStyles.

- ou -

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

ArgumentNullException

value a la valeur null.

FormatException

value ne se conforme pas avec 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 séparateur de groupe ou le symbole décimal) autorisés dans le value paramètre pour que 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 de nombres (décimal ou hexadécimal) représenté par value n’est connu qu’au moment de l’exécution, ou lorsque vous souhaitez interdire l’espace blanc ou un symbole de connexion dans 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 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 Description
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 spécifique à la culture. Sa position dans value est définie par les NumberFormatInfo.CurrencyNegativePattern propriétés et NumberFormatInfo.CurrencyPositivePattern de la culture indiquée par le provider paramètre . Le symbole monétaire de la culture actuelle 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

fractional_digits

exponential_digits		 Séquence de chiffres de 0 à 9. Pour fractional_digits, seul le chiffre 0 est valide.
, Symbole de séparation de groupe spécifique à la culture. Le symbole de séparation 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 désignée par provider peut apparaître dans value si style inclut l’indicateur NumberStyles.AllowDecimalPoint . Seul le chiffre 0 peut apparaître sous la forme d’un chiffre fractionnaire 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 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 .

Un value avec des chiffres uniquement (qui correspond au NumberStyles.None style) 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 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 digits uniquement.
AllowDecimalPoint Éléments à virgule décimale (.) et à chiffres fractionnaires .
AllowExponent Caractère « e » ou « E », qui indique la 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 sign au début de value.
AllowTrailingSign Élément sign à la fin de value.
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 value, et le symbole décimal (.). Le value paramètre peut également utiliser la notation exponentielle.
Number Éléments ws, sign, sé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 n’exigent pas la présence d’éléments de style particuliers dans value, la 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 inclut un style numérique 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. En règle générale, provider il peut s’agir de l’un des éléments suivants :

  • 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 retourne simplement elle-même.)

  • Objet personnalisé qui implémente IFormatProvider et utilise la GetFormat méthode pour instancier et retourner 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

S’applique à

Parse(String, NumberStyles, IFormatProvider)

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

Convertit la représentation sous forme de chaîne d'un nombre, ayant un style et un format propre à la culture spécifiés, en sa représentation BigInteger équivalente.

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 contenant un nombre à convertir.

style
NumberStyles

Combinaison de bits de valeurs d'énumération qui spécifie le format autorisé de value.

provider
IFormatProvider

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

Retours

BigInteger

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

Implémente

Parse(String, NumberStyles, IFormatProvider)

Exceptions

ArgumentException

style n’est pas une valeur NumberStyles.

- ou -

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

ArgumentNullException

value a la valeur null.

FormatException

value ne se conforme pas avec 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 style paramètres et provider .

// 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
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;
      }
   }
}

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éparation de groupe ou le symbole de virgule décimale) autorisés dans le value paramètre pour que 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 de nombres (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 signe dans 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 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 Description
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 spécifique à la culture. Sa position dans la chaîne est définie par les NumberFormatInfo.CurrencyNegativePattern propriétés et NumberFormatInfo.CurrencyPositivePattern de la culture indiquée par le provider paramètre . Le symbole monétaire de la culture actuelle 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

fractional_digits

exponential_digits		 Séquence de chiffres de 0 à 9. Pour fractional_digits, seul le chiffre 0 est valide.
, Symbole de séparation de groupe spécifique à la culture. Le symbole de séparation 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 désignée par provider peut apparaître dans value si style inclut l’indicateur NumberStyles.AllowDecimalPoint . Seul le chiffre 0 peut apparaître sous la forme d’un chiffre fractionnaire 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 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 uniquement (qui correspond au NumberStyles.None style) 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 obligatoirement 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 digits uniquement.
AllowDecimalPoint Éléments à virgule décimale (.) et à chiffres fractionnaires .
AllowExponent Caractère « e » ou « E », qui indique la 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 sign au début de value.
AllowTrailingSign Élément sign à la fin de value.
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 value, et le symbole décimal (.). Le value paramètre peut également utiliser la notation exponentielle.
Number Éléments ws, sign, 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 Parse méthode pour effectuer un 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 Parse méthode pour restaurer la BigInteger valeur.

Contrairement aux autres NumberStyles valeurs, qui autorisent mais n’exigent pas la présence d’éléments de style particuliers dans value, la 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 inclut un style numérique 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 Parse(String, NumberStyles) 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" };
      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.

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’un des éléments suivants :

  • 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 retourne simplement elle-même.)

  • Objet personnalisé qui implémente IFormatProvider et utilise la GetFormat méthode pour instancier et retourner 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

S’applique à