Analyse de chaînes numériques dans .NETParsing Numeric Strings in NET

Tous les types numériques disposent de deux méthodes d’analyse statiques, Parse et TryParse, que vous pouvez utiliser pour convertir la représentation sous forme de chaîne d’un nombre en type numérique.All numeric types have two static parsing methods, Parse and TryParse, that you can use to convert the string representation of a number into a numeric type. Ces méthodes vous permettent d’analyser les chaînes qui ont été générées à l’aide de chaînes de format documentées dans Chaînes de format numériques standard et Chaînes de format numériques personnalisées.These methods enable you to parse strings that were produced by using the format strings documented in Standard Numeric Format Strings and Custom Numeric Format Strings. Par défaut, les méthodes Parse et TryParse peuvent convertir correctement les chaînes qui contiennent uniquement des chiffres décimaux intégraux en valeurs entières.By default, the Parse and TryParse methods can successfully convert strings that contain integral decimal digits only to integer values. Ils peuvent convertir correctement les chaînes qui contiennent des chiffres décimaux intégraux et fractionnaires, des séparateurs de groupe et un séparateur décimal en valeurs à virgule flottante.They can successfully convert strings that contain integral and fractional decimal digits, group separators, and a decimal separator to floating-point values. La méthode Parse lève une exception si l’opération échoue, tandis que la méthode TryParse retourne false.The Parse method throws an exception if the operation fails, whereas the TryParse method returns false.

Analyse et fournisseurs de formatParsing and Format Providers

En général, les représentations sous forme de chaîne de valeurs numériques varient selon la culture.Typically, the string representations of numeric values differ by culture. Les éléments des chaînes numériques, tels que les symboles monétaires, les séparateurs de groupes (ou de milliers) et les séparateurs décimaux, varient selon la culture.Elements of numeric strings such as currency symbols, group (or thousands) separators, and decimal separators all vary by culture. Les méthodes d’analyse utilisent implicitement ou explicitement un fournisseur de format qui identifie ces variantes spécifiques à la culture.Parsing methods either implicitly or explicitly use a format provider that recognizes these culture-specific variations. Si aucun fournisseur de format n’est spécifié dans un appel à la méthode Parse ou TryParse, le fournisseur de format associé à la culture du thread actuel (l’objet NumberFormatInfo retourné par la propriété NumberFormatInfo.CurrentInfo) est utilisé.If no format provider is specified in a call to the Parse or TryParse method, the format provider associated with the current thread culture (the NumberFormatInfo object returned by the NumberFormatInfo.CurrentInfo property) is used.

Un fournisseur de format est représenté par une implémentation IFormatProvider.A format provider is represented by an IFormatProvider implementation. Cette interface a un seul membre, la méthode GetFormat, dont l’unique paramètre est un objet Type qui représente le type à mettre en forme.This interface has a single member, the GetFormat method, whose single parameter is a Type object that represents the type to be formatted. Cette méthode retourne l’objet qui fournit des informations de mise en forme.This method returns the object that provides formatting information. .NET prend en charge les deux implémentations IFormatProvider suivantes pour analyser les chaînes numériques :.NET supports the following two IFormatProvider implementations for parsing numeric strings:

L’exemple suivant essaie de convertir chaque chaîne d’un tableau en une valeur Double.The following example tries to convert each string in an array to a Double value. Il commence par essayer d’analyser la chaîne à l’aide d’un fournisseur de format qui reflète les conventions de la culture anglophone (États-Unis).It first tries to parse the string by using a format provider that reflects the conventions of the English (United States) culture. Si cette opération lève une exception FormatException, il tente d’analyser la chaîne à l’aide d’un fournisseur de format qui reflète les conventions de la culture française (France).If this operation throws a FormatException, it tries to parse the string by using a format provider that reflects the conventions of the French (France) culture.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values = { "1,304.16", "$1,456.78", "1,094", "152", 
                          "123,45 €", "1 304,16", "Ae9f" };
      double number;
      CultureInfo culture = null;
      
      foreach (string value in values) {
         try {
            culture = CultureInfo.CreateSpecificCulture("en-US");
            number = Double.Parse(value, culture);
            Console.WriteLine("{0}: {1} --> {2}", culture.Name, value, number);
         }   
         catch (FormatException) {
            Console.WriteLine("{0}: Unable to parse '{1}'.", 
                              culture.Name, value);
            culture = CultureInfo.CreateSpecificCulture("fr-FR");
            try {
               number = Double.Parse(value, culture);
               Console.WriteLine("{0}: {1} --> {2}", culture.Name, value, number);
            }
            catch (FormatException) {
               Console.WriteLine("{0}: Unable to parse '{1}'.", 
                                 culture.Name, value);
            }
         }
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//    en-US: 1,304.16 --> 1304.16
//    
//    en-US: Unable to parse '$1,456.78'.
//    fr-FR: Unable to parse '$1,456.78'.
//    
//    en-US: 1,094 --> 1094
//    
//    en-US: 152 --> 152
//    
//    en-US: Unable to parse '123,45 €'.
//    fr-FR: Unable to parse '123,45 €'.
//    
//    en-US: Unable to parse '1 304,16'.
//    fr-FR: 1 304,16 --> 1304.16
//    
//    en-US: Unable to parse 'Ae9f'.
//    fr-FR: Unable to parse 'Ae9f'.
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { "1,304.16", "$1,456.78", "1,094", "152", 
                                 "123,45 €", "1 304,16", "Ae9f" }
      Dim number As Double
      Dim culture As CultureInfo = Nothing
      
      For Each value As String In values
         Try
            culture = CultureInfo.CreateSpecificCulture("en-US")
            number = Double.Parse(value, culture)
            Console.WriteLine("{0}: {1} --> {2}", culture.Name, value, number)
         Catch e As FormatException
            Console.WriteLine("{0}: Unable to parse '{1}'.", 
                              culture.Name, value)
            culture = CultureInfo.CreateSpecificCulture("fr-FR")
            Try
               number = Double.Parse(value, culture)
               Console.WriteLine("{0}: {1} --> {2}", culture.Name, value, number)
            Catch ex As FormatException
               Console.WriteLine("{0}: Unable to parse '{1}'.", 
                                 culture.Name, value)
            End Try
         End Try
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'    en-US: 1,304.16 --> 1304.16
'    
'    en-US: Unable to parse '$1,456.78'.
'    fr-FR: Unable to parse '$1,456.78'.
'    
'    en-US: 1,094 --> 1094
'    
'    en-US: 152 --> 152
'    
'    en-US: Unable to parse '123,45 €'.
'    fr-FR: Unable to parse '123,45 €'.
'    
'    en-US: Unable to parse '1 304,16'.
'    fr-FR: 1 304,16 --> 1304.16
'    
'    en-US: Unable to parse 'Ae9f'.
'    fr-FR: Unable to parse 'Ae9f'.

Analyse et valeurs NumberStylesParsing and NumberStyles Values

Les éléments de style (tels que les espaces blancs, les séparateurs de groupe et le séparateur décimal) que l’opération d’analyse peut gérer sont définis par une valeur d’énumération NumberStyles.The style elements (such as white space, group separators, and decimal separator) that the parse operation can handle are defined by a NumberStyles enumeration value. Par défaut, les chaînes qui représentent des valeurs entières sont analysées à l’aide de la valeur NumberStyles.Integer, qui autorise uniquement les chiffres numériques, les espaces blancs de début et de fin et un signe de début.By default, strings that represent integer values are parsed by using the NumberStyles.Integer value, which permits only numeric digits, leading and trailing white space, and a leading sign. Les chaînes qui représentent des valeurs à virgule flottante sont analysées à l’aide d’une combinaison des valeurs NumberStyles.Float et NumberStyles.AllowThousands. Ce style composite autorise les chiffres décimaux avec un espace blanc de début et de fin, un signe de début, un séparateur décimal, un séparateur de groupes et un exposant.Strings that represent floating-point values are parsed using a combination of the NumberStyles.Float and NumberStyles.AllowThousands values; this composite style permits decimal digits along with leading and trailing white space, a leading sign, a decimal separator, a group separator, and an exponent. Quand vous appelez une surcharge de la méthode Parse ou TryParse qui inclut un paramètre de type NumberStyles et que vous définissez un ou plusieurs indicateurs NumberStyles, vous pouvez contrôler les éléments de style pouvant être présents dans la chaîne pour que l’opération d’analyse aboutisse.By calling an overload of the Parse or TryParse method that includes a parameter of type NumberStyles and setting one or more NumberStyles flags, you can control the style elements that can be present in the string for the parse operation to succeed.

Par exemple, une chaîne qui contient un séparateur de groupes ne peut pas être convertie en valeur Int32 à l’aide de la méthode Int32.Parse(String).For example, a string that contains a group separator cannot be converted to an Int32 value by using the Int32.Parse(String) method. Toutefois, la conversion réussit si vous utilisez l’indicateur NumberStyles.AllowThousands, comme le montre l’exemple suivant.However, the conversion succeeds if you use the NumberStyles.AllowThousands flag, as the following example illustrates.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string value = "1,304";
      int number;
      IFormatProvider provider = CultureInfo.CreateSpecificCulture("en-US");
      if (Int32.TryParse(value, out number))
         Console.WriteLine("{0} --> {1}", value, number);
      else
         Console.WriteLine("Unable to convert '{0}'", value);
            
      if (Int32.TryParse(value, NumberStyles.Integer | NumberStyles.AllowThousands, 
                        provider, out number))
         Console.WriteLine("{0} --> {1}", value, number);
      else
         Console.WriteLine("Unable to convert '{0}'", value);
   }
}
// The example displays the following output:
//       Unable to convert '1,304'
//       1,304 --> 1304
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim value As String = "1,304"
      Dim number As Integer
      Dim provider As IFormatProvider = CultureInfo.CreateSpecificCulture("en-US")
      If Int32.TryParse(value, number) Then
         Console.WriteLine("{0} --> {1}", value, number)
      Else
         Console.WriteLine("Unable to convert '{0}'", value)
      End If
            
      If Int32.TryParse(value, NumberStyles.Integer Or NumberStyles.AllowThousands, 
                        provider, number) Then
         Console.WriteLine("{0} --> {1}", value, number)
      Else
         Console.WriteLine("Unable to convert '{0}'", value)
      End If
   End Sub
End Module
' The example displays the following output:
'       Unable to convert '1,304'
'       1,304 --> 1304

Avertissement

L’opération d’analyse utilise toujours les conventions de mise en forme d’une culture particulière.The parse operation always uses the formatting conventions of a particular culture. Si vous ne spécifiez pas de culture en passant un objet CultureInfo ou NumberFormatInfo, la culture associée au thread actuel est utilisée.If you do not specify a culture by passing a CultureInfo or NumberFormatInfo object, the culture associated with the current thread is used.

Le tableau suivant répertorie les membres de l’énumération NumberStyles et décrit l’effet qu’ils ont sur l’opération d’analyse.The following table lists the members of the NumberStyles enumeration and describes the effect that they have on the parsing operation.

Valeur NumberStylesNumberStyles value Effet sur la chaîne à analyserEffect on the string to be parsed
NumberStyles.None Seuls les chiffres sont autorisés.Only numeric digits are permitted.
NumberStyles.AllowDecimalPoint Le séparateur décimal et les chiffres fractionnaires sont autorisés.The decimal separator and fractional digits are permitted. Pour les valeurs entières, le seul chiffre fractionnaire autorisé est zéro.For integer values, only zero is permitted as a fractional digit. Les séparateurs décimaux valides sont déterminés par la propriété NumberFormatInfo.NumberDecimalSeparator ou NumberFormatInfo.CurrencyDecimalSeparator.Valid decimal separators are determined by the NumberFormatInfo.NumberDecimalSeparator or NumberFormatInfo.CurrencyDecimalSeparator property.
NumberStyles.AllowExponent Les caractères « e » ou « E » peuvent être utilisés pour indiquer une notation exponentielle.The "e" or "E" character can be used to indicate exponential notation. Pour plus d’informations, consultez NumberStyles.See NumberStyles for additional information.
NumberStyles.AllowLeadingWhite L’espace blanc de début est autorisé.Leading white space is permitted.
NumberStyles.AllowTrailingWhite L’espace blanc de fin est autorisé.Trailing white space is permitted.
NumberStyles.AllowLeadingSign Un signe positif ou négatif peut précéder les chiffres.A positive or negative sign can precede numeric digits.
NumberStyles.AllowTrailingSign Un signe positif ou négatif peut suivre les chiffres.A positive or negative sign can follow numeric digits.
NumberStyles.AllowParentheses Les parenthèses peuvent être utilisées pour indiquer des valeurs négatives.Parentheses can be used to indicate negative values.
NumberStyles.AllowThousands Le séparateur de groupes est autorisé.The group separator is permitted. Le caractère de séparateur de groupes est déterminé par la propriété NumberFormatInfo.NumberGroupSeparator ou NumberFormatInfo.CurrencyGroupSeparator.The group separator character is determined by the NumberFormatInfo.NumberGroupSeparator or NumberFormatInfo.CurrencyGroupSeparator property.
NumberStyles.AllowCurrencySymbol Le symbole monétaire est autorisé.The currency symbol is permitted. Le symbole monétaire est défini par la propriété NumberFormatInfo.CurrencySymbol.The currency symbol is defined by the NumberFormatInfo.CurrencySymbol property.
NumberStyles.AllowHexSpecifier La chaîne à analyser est interprétée comme un nombre hexadécimal.The string to be parsed is interpreted as a hexadecimal number. Elle peut inclure les chiffres hexadécimaux 0-9, A-F et a-f.It can include the hexadecimal digits 0-9, A-F, and a-f. Cet indicateur peut être utilisé uniquement pour analyser des valeurs entières.This flag can be used only to parse integer values.

En outre, l’énumération NumberStyles fournit les styles composites suivants, qui comprennent plusieurs indicateurs NumberStyles.In addition, the NumberStyles enumeration provides the following composite styles, which include multiple NumberStyles flags.

Valeur NumberStyles compositeComposite NumberStyles value MembresIncludes members
NumberStyles.Integer Inclut les styles NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite et NumberStyles.AllowLeadingSign.Includes the NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, and NumberStyles.AllowLeadingSign styles. Il s’agit du style par défaut utilisé pour analyser des valeurs entières.This is the default style used to parse integer values.
NumberStyles.Number Inclut les styles NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, NumberStyles.AllowLeadingSign, NumberStyles.AllowTrailingSign, NumberStyles.AllowDecimalPoint et NumberStyles.AllowThousands.Includes the NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, NumberStyles.AllowLeadingSign, NumberStyles.AllowTrailingSign, NumberStyles.AllowDecimalPoint, and NumberStyles.AllowThousands styles.
NumberStyles.Float Inclut les styles NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, NumberStyles.AllowLeadingSign, NumberStyles.AllowDecimalPoint et NumberStyles.AllowExponent.Includes the NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, NumberStyles.AllowLeadingSign, NumberStyles.AllowDecimalPoint, and NumberStyles.AllowExponent styles.
NumberStyles.Currency Inclut tous les styles sauf NumberStyles.AllowExponent et NumberStyles.AllowHexSpecifier.Includes all styles except NumberStyles.AllowExponent and NumberStyles.AllowHexSpecifier.
NumberStyles.Any Inclut tous les styles sauf NumberStyles.AllowHexSpecifier.Includes all styles except NumberStyles.AllowHexSpecifier.
NumberStyles.HexNumber Inclut les styles NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite et NumberStyles.AllowHexSpecifier.Includes the NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, and NumberStyles.AllowHexSpecifier styles.

Analyse et chiffres UnicodeParsing and Unicode Digits

La norme Unicode définit des points de code pour les chiffres dans différents systèmes d’écriture.The Unicode standard defines code points for digits in various writing systems. Par exemple, les points de code U+0030 à U+0039 représentent les chiffres latins de base 0 à 9, les points de code de U+09E6 à U+09EF représentent les chiffres bengalis compris entre 0 et 9, et les points de code U+FF10 à U+FF19 représentent les chiffres pleine chasse compris entre 0 et 9.For example, code points from U+0030 to U+0039 represent the basic Latin digits 0 through 9, code points from U+09E6 to U+09EF represent the Bangla digits 0 through 9, and code points from U+FF10 to U+FF19 represent the Fullwidth digits 0 through 9. Toutefois, les seuls chiffres identifiés par les méthodes d’analyse sont les chiffres latins de base 0 à 9 avec des points de code compris entre U+0030 et U+0039.However, the only numeric digits recognized by parsing methods are the basic Latin digits 0-9 with code points from U+0030 to U+0039. Si une chaîne contenant tout autre chiffre est passée à une méthode d’analyse numérique, celle-ci lève une exception FormatException.If a numeric parsing method is passed a string that contains any other digits, the method throws a FormatException.

L’exemple suivant utilise la méthode Int32.Parse pour analyser des chaînes composées de chiffres dans différents systèmes d’écriture.The following example uses the Int32.Parse method to parse strings that consist of digits in different writing systems. Comme l’indique le résultat de l’exemple, la tentative d’analyse des chiffres latins de base réussit, mais la tentative d’analyse des chiffres pleine chasse, arabe-hindi et bengali échoue.As the output from the example shows, the attempt to parse the basic Latin digits succeeds, but the attempt to parse the Fullwidth, Arabic-Indic, and Bangla digits fails.

using System;

public class Example
{
   public static void Main()
   {
      string value;
      // Define a string of basic Latin digits 1-5.
      value = "\u0031\u0032\u0033\u0034\u0035";
      ParseDigits(value);

      // Define a string of Fullwidth digits 1-5.
      value = "\uFF11\uFF12\uFF13\uFF14\uFF15";
      ParseDigits(value);
      
      // Define a string of Arabic-Indic digits 1-5.
      value = "\u0661\u0662\u0663\u0664\u0665";
      ParseDigits(value);
      
      // Define a string of Bangla digits 1-5.
      value = "\u09e7\u09e8\u09e9\u09ea\u09eb";
      ParseDigits(value);
   }

   static void ParseDigits(string value)
   {
      try {
         int number = Int32.Parse(value);
         Console.WriteLine("'{0}' --> {1}", value, number);
      }   
      catch (FormatException) {
         Console.WriteLine("Unable to parse '{0}'.", value);      
      }     
   }
}
// The example displays the following output:
//       '12345' --> 12345
//       Unable to parse '12345'.
//       Unable to parse '١٢٣٤٥'.
//       Unable to parse '১২৩৪৫'.
Module Example
   Public Sub Main()
      Dim value As String
      ' Define a string of basic Latin digits 1-5.
      value = ChrW(&h31) + ChrW(&h32) + ChrW(&h33) + ChrW(&h34) + ChrW(&h35)
      ParseDigits(value)

      ' Define a string of Fullwidth digits 1-5.
      value = ChrW(&hff11) + ChrW(&hff12) + ChrW(&hff13) + ChrW(&hff14) + ChrW(&hff15)
      ParseDigits(value)
      
      ' Define a string of Arabic-Indic digits 1-5.
      value = ChrW(&h661) + ChrW(&h662) + ChrW(&h663) + ChrW(&h664) + ChrW(&h665)
      ParseDigits(value)
      
      ' Define a string of Bangla digits 1-5.
      value = ChrW(&h09e7) + ChrW(&h09e8) + ChrW(&h09e9) + ChrW(&h09ea) + ChrW(&h09eb)
      ParseDigits(value)
   End Sub

   Sub ParseDigits(value As String)
      Try
         Dim number As Integer = Int32.Parse(value)
         Console.WriteLine("'{0}' --> {1}", value, number)
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}'.", value)      
      End Try     
   End Sub
End Module
' The example displays the following output:
'       '12345' --> 12345
'       Unable to parse '12345'.
'       Unable to parse '١٢٣٤٥'.
'       Unable to parse '১২৩৪৫'.

Voir aussiSee also