Analisi di stringhe numeriche in .NETParsing Numeric Strings in NET

Tutti i tipi numerici hanno due metodi di analisi statici, Parse e TryParse, che è possibile usare per convertire la rappresentazione di stringa di un numero in un tipo numerico.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. Tali metodi consentono di analizzare le stringhe generate usando le stringhe di formato documentate in Stringhe di formato numerico standard e Stringhe di formato numerico personalizzato.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. Per impostazione predefinita, i metodi Parse e TryParse consentono di convertire correttamente le stringhe contenenti cifre decimali integrali solo in valori integer.By default, the Parse and TryParse methods can successfully convert strings that contain integral decimal digits only to integer values. Consentono di convertire correttamente le stringhe che contengono cifre decimali integrali e frazionarie, separatori di gruppi e un separatore decimale in valori a virgola mobile.They can successfully convert strings that contain integral and fractional decimal digits, group separators, and a decimal separator to floating-point values. Il metodo Parse genera un'eccezione se l'operazione ha esito negativo, mentre il metodo TryParse restituisce false.The Parse method throws an exception if the operation fails, whereas the TryParse method returns false.

Analisi e provider di formatoParsing and Format Providers

In genere, le rappresentazioni di stringa dei valori numerici differiscono in base alle impostazioni cultura.Typically, the string representations of numeric values differ by culture. Gli elementi delle stringhe numeriche, ad esempio simboli di valuta, separatori di gruppi (o migliaia) e separatori decimali, variano in base alle impostazioni cultura.Elements of numeric strings such as currency symbols, group (or thousands) separators, and decimal separators all vary by culture. I metodi di analisi usano in modo implicito o esplicito un provider di formato che riconosce le variazioni specifiche delle impostazioni cultura.Parsing methods either implicitly or explicitly use a format provider that recognizes these culture-specific variations. Se non viene specificato alcun provider di formato in una chiamata al metodo Parse o TryParse, viene usato il provider di formato associato alle impostazioni cultura del thread corrente, ossia l'oggetto NumberFormatInfo restituito dalla proprietà NumberFormatInfo.CurrentInfo.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 provider di formato è rappresentato da un'implementazione IFormatProvider.A format provider is represented by an IFormatProvider implementation. Questa interfaccia ha un singolo membro, il metodo GetFormat, il cui unico parametro è un oggetto Type che rappresenta il tipo da formattare.This interface has a single member, the GetFormat method, whose single parameter is a Type object that represents the type to be formatted. Questo metodo restituisce l'oggetto che fornisce le informazioni di formattazione.This method returns the object that provides formatting information. .NET supporta le due implementazioni IFormatProvider seguenti per l'analisi di stringhe numeriche:.NET supports the following two IFormatProvider implementations for parsing numeric strings:

Nell'esempio seguente si tenta di convertire ogni stringa in una matrice in un valore Double.The following example tries to convert each string in an array to a Double value. Per prima cosa si tenta di analizzare la stringa usando un provider di formato che riflette le convenzioni delle impostazioni cultura Inglese (Stati Uniti).It first tries to parse the string by using a format provider that reflects the conventions of the English (United States) culture. Se questa operazione genera un'eccezione FormatException, si tenta di analizzare la stringa usando un provider di formato che riflette le convenzioni delle impostazioni cultura Francese (Francia).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'.

Analisi e valori NumberStylesParsing and NumberStyles Values

Gli elementi di stile, ad esempio spazi vuoti, separatori di gruppi e separatore decimale, che l'operazione di analisi è in grado di gestire sono definiti da un valore di enumerazione 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. Per impostazione predefinita, le stringhe che rappresentano i valori integer vengono analizzate usando il valore NumberStyles.Integer, che consente solo cifre numeriche, spazi vuoti iniziali e finali e un segno iniziale.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. Le stringhe che rappresentano valori a virgola mobile vengono analizzate usando una combinazione dei valori NumberStyles.Float e NumberStyles.AllowThousands. Questo stile composto consente cifre decimali con spazi vuoti iniziali e finali, un segno iniziale, un separatore decimale, un separatore di gruppi e un esponente.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. Chiamando un overload del metodo Parse o TryParse che include un parametro di tipo NumberStyles e impostando uno o più flag NumberStyles, è possibile stabilire quali elementi di stile possono essere presenti nella stringa per fare in modo che l'operazione di analisi abbia esito positivo.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.

Ad esempio, una stringa contenente un separatore di gruppo non può essere convertita in un valore Int32 tramite il metodo 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. Tuttavia, la conversione viene completata correttamente se si utilizza il flag NumberStyles.AllowThousands, come illustrato nell'esempio riportato di seguito.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

Avviso

L'operazione di analisi usa sempre le convenzioni di formattazione di determinate impostazioni cultura.The parse operation always uses the formatting conventions of a particular culture. Se non si specificano le impostazioni cultura passando un oggetto CultureInfo o NumberFormatInfo, vengono usate le impostazioni cultura associate al thread corrente.If you do not specify a culture by passing a CultureInfo or NumberFormatInfo object, the culture associated with the current thread is used.

Nella tabella seguente sono elencati i membri dell'enumerazione NumberStyles e viene descritto l'effetto degli stessi sull'operazione di analisi.The following table lists the members of the NumberStyles enumeration and describes the effect that they have on the parsing operation.

Valore NumberStylesNumberStyles value Effetto sulla stringa da analizzareEffect on the string to be parsed
NumberStyles.None Sono consentiti solo valori numerici.Only numeric digits are permitted.
NumberStyles.AllowDecimalPoint Sono consentiti il separatore decimale e i numeri frazionari.The decimal separator and fractional digits are permitted. Per i valori integer è consentito solo lo zero come numero frazionario.For integer values, only zero is permitted as a fractional digit. I separatori decimali validi sono determinati dalla proprietà NumberFormatInfo.NumberDecimalSeparator o NumberFormatInfo.CurrencyDecimalSeparator.Valid decimal separators are determined by the NumberFormatInfo.NumberDecimalSeparator or NumberFormatInfo.CurrencyDecimalSeparator property.
NumberStyles.AllowExponent Il carattere "e" o "E" può essere usato per indicare la notazione esponenziale.The "e" or "E" character can be used to indicate exponential notation. Per altre informazioni, vedere NumberStyles.See NumberStyles for additional information.
NumberStyles.AllowLeadingWhite È consentito lo spazio vuoto iniziale.Leading white space is permitted.
NumberStyles.AllowTrailingWhite È consentito lo spazio vuoto finale.Trailing white space is permitted.
NumberStyles.AllowLeadingSign Un segno positivo o negativo può precedere le cifre numeriche.A positive or negative sign can precede numeric digits.
NumberStyles.AllowTrailingSign Un segno positivo o negativo può seguire le cifre numeriche.A positive or negative sign can follow numeric digits.
NumberStyles.AllowParentheses Si possono usare parentesi per indicare i valori negativi.Parentheses can be used to indicate negative values.
NumberStyles.AllowThousands È consentito il separatore di gruppi.The group separator is permitted. Il carattere separatore di gruppi è determinato dalla proprietà NumberFormatInfo.NumberGroupSeparator o NumberFormatInfo.CurrencyGroupSeparator.The group separator character is determined by the NumberFormatInfo.NumberGroupSeparator or NumberFormatInfo.CurrencyGroupSeparator property.
NumberStyles.AllowCurrencySymbol È consentito il simbolo di valuta.The currency symbol is permitted. Il simbolo di valuta è definito dalla proprietà NumberFormatInfo.CurrencySymbol.The currency symbol is defined by the NumberFormatInfo.CurrencySymbol property.
NumberStyles.AllowHexSpecifier La stringa da analizzare viene interpretata come numero esadecimale.The string to be parsed is interpreted as a hexadecimal number. Può includere le cifre esadecimali 0-9, A-F e a-f.It can include the hexadecimal digits 0-9, A-F, and a-f. Questo flag può essere usato solo per analizzare i valori integer.This flag can be used only to parse integer values.

L'enumerazione NumberStyles usa anche i stili compositi seguenti, che includono più flag NumberStyles.In addition, the NumberStyles enumeration provides the following composite styles, which include multiple NumberStyles flags.

Valore composito NumberStylesComposite NumberStyles value Include i membriIncludes members
NumberStyles.Integer Include gli stili NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite e NumberStyles.AllowLeadingSign.Includes the NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, and NumberStyles.AllowLeadingSign styles. Questo è lo stile predefinito usato per analizzare i valori integer.This is the default style used to parse integer values.
NumberStyles.Number Include gli stili NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, NumberStyles.AllowLeadingSign, NumberStyles.AllowTrailingSign, NumberStyles.AllowDecimalPoint e NumberStyles.AllowThousands.Includes the NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, NumberStyles.AllowLeadingSign, NumberStyles.AllowTrailingSign, NumberStyles.AllowDecimalPoint, and NumberStyles.AllowThousands styles.
NumberStyles.Float Include gli stili NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, NumberStyles.AllowLeadingSign, NumberStyles.AllowDecimalPoint e NumberStyles.AllowExponent.Includes the NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, NumberStyles.AllowLeadingSign, NumberStyles.AllowDecimalPoint, and NumberStyles.AllowExponent styles.
NumberStyles.Currency Include tutti gli stili tranne NumberStyles.AllowExponent e NumberStyles.AllowHexSpecifier.Includes all styles except NumberStyles.AllowExponent and NumberStyles.AllowHexSpecifier.
NumberStyles.Any Include tutti gli stili tranne NumberStyles.AllowHexSpecifier.Includes all styles except NumberStyles.AllowHexSpecifier.
NumberStyles.HexNumber Include gli stili NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite e NumberStyles.AllowHexSpecifier.Includes the NumberStyles.AllowLeadingWhite, NumberStyles.AllowTrailingWhite, and NumberStyles.AllowHexSpecifier styles.

Analisi e cifre UnicodeParsing and Unicode Digits

Lo standard Unicode definisce gli elementi di codice per le cifre in diversi sistemi di scrittura.The Unicode standard defines code points for digits in various writing systems. Ad esempio, gli elementi di codice compresi tra U+0030 e U+0039 rappresentano le cifre latine di base da 0 a 9, gli elementi di codice compresi tra U+09E6 e U+09EF rappresentano le cifre bengalesi da 0 a 9 e gli elementi di codice compresi tra U+FF10 e U+FF19 rappresentano le cifre Fullwidth da 0 a 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. Tuttavia, solo cifre numeriche riconosciute dai metodi di analisi sono le cifre latine di base da 0 a 9 con elementi di codice da U+0030 a 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. Se a un metodo di analisi numerico viene passata una stringa che contiene altre cifre, il metodo genera un'eccezione FormatException.If a numeric parsing method is passed a string that contains any other digits, the method throws a FormatException.

Nell'esempio seguente viene usato il metodo Int32.Parse per analizzare le stringhe costituite da cifre in diversi sistemi di scrittura.The following example uses the Int32.Parse method to parse strings that consist of digits in different writing systems. Come illustrato nell'output dell'esempio, il tentativo di analizzare le cifre latine di base ha esito positivo, mentre il tentativo di analisi delle cifre Fullwidth, indoarabiche e bengalesi ha esito negativo.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 '১২৩৪৫'.

Vedere ancheSee also