NumberFormatInfo Classe

Definizione

Fornisce informazioni specifiche delle impostazioni cultura per la formattazione e l'analisi dei valori numerici.

public ref class NumberFormatInfo sealed : IFormatProvider
public ref class NumberFormatInfo sealed : ICloneable, IFormatProvider
public sealed class NumberFormatInfo : IFormatProvider
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
type NumberFormatInfo = class
    interface IFormatProvider
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
Public NotInheritable Class NumberFormatInfo
Implements IFormatProvider
Public NotInheritable Class NumberFormatInfo
Implements ICloneable, IFormatProvider
Ereditarietà
NumberFormatInfo
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene illustrato come recuperare un oggetto per un oggetto corrispondente e utilizzare l'oggetto recuperato per eseguire query sulle informazioni di formattazione dei numeri NumberFormatInfo per le impostazioni cultura CultureInfo specifiche.

using namespace System;
using namespace System::Globalization;
using namespace System::Text;

int main()
{
    StringBuilder^ builder = gcnew StringBuilder();

    // Loop through all the specific cultures known to the CLR.
    for each(CultureInfo^ culture in 
        CultureInfo::GetCultures (CultureTypes::SpecificCultures)) 
    {
        // Only show the currency symbols for cultures 
        // that speak English.
        if (culture->TwoLetterISOLanguageName == "en")
        {
            // Display the culture name and currency symbol.
            NumberFormatInfo^ numberFormat = culture->NumberFormat;
            builder->AppendFormat("The currency symbol for '{0}'"+
                "is '{1}'",culture->DisplayName,
                numberFormat->CurrencySymbol);
            builder->AppendLine();
        }
    }
    Console::WriteLine(builder);
}

// This code produces the following output.
//
// The currency symbol for 'English (United States)' is '$'
// The currency symbol for 'English (United Kingdom)' is 'Ј'
// The currency symbol for 'English (Australia)' is '$'
// The currency symbol for 'English (Canada)' is '$'
// The currency symbol for 'English (New Zealand)' is '$'
// The currency symbol for 'English (Ireland)' is '?'
// The currency symbol for 'English (South Africa)' is 'R'
// The currency symbol for 'English (Jamaica)' is 'J$'
// The currency symbol for 'English (Caribbean)' is '$'
// The currency symbol for 'English (Belize)' is 'BZ$'
// The currency symbol for 'English (Trinidad and Tobago)' is 'TT$'
// The currency symbol for 'English (Zimbabwe)' is 'Z$'
// The currency symbol for 'English (Republic of the Philippines)' is 'Php'
using System;
using System.Globalization;
using System.Text;

public sealed class App
{
    static void Main()
    {
        StringBuilder sb = new StringBuilder();

        // Loop through all the specific cultures known to the CLR.
        foreach (CultureInfo ci in CultureInfo.GetCultures(CultureTypes.SpecificCultures))
        {
            // Only show the currency symbols for cultures that speak English.
            if (ci.TwoLetterISOLanguageName != "en") continue;

            // Display the culture name and currency symbol.
            NumberFormatInfo nfi = ci.NumberFormat;
            sb.AppendFormat("The currency symbol for '{0}' is '{1}'",
                ci.DisplayName, nfi.CurrencySymbol);
            sb.AppendLine();
        }
        Console.WriteLine(sb.ToString());
    }
}

// This code produces the following output.
//
// The currency symbol for 'English (United States)' is '$'
// The currency symbol for 'English (United Kingdom)' is '£'
// The currency symbol for 'English (Australia)' is '$'
// The currency symbol for 'English (Canada)' is '$'
// The currency symbol for 'English (New Zealand)' is '$'
// The currency symbol for 'English (Ireland)' is '?'
// The currency symbol for 'English (South Africa)' is 'R'
// The currency symbol for 'English (Jamaica)' is 'J$'
// The currency symbol for 'English (Caribbean)' is '$'
// The currency symbol for 'English (Belize)' is 'BZ$'
// The currency symbol for 'English (Trinidad and Tobago)' is 'TT$'
// The currency symbol for 'English (Zimbabwe)' is 'Z$'
// The currency symbol for 'English (Republic of the Philippines)' is 'Php'
Imports System.Globalization
Imports System.Text

Public Module Example
   Public Sub Main() 
      Dim sb As New StringBuilder()

      ' Loop through all the specific cultures known to the CLR.
      For Each ci In CultureInfo.GetCultures(CultureTypes.SpecificCultures) 
         ' Only show the currency symbols for cultures that speak English.
         If ci.TwoLetterISOLanguageName <> "en" Then Continue For

         ' Display the culture name and currency symbol.
         Dim nfi As NumberFormatInfo = ci.NumberFormat
         sb.AppendFormat("The currency symbol for '{0}' is '{1}'",
                         ci.DisplayName, nfi.CurrencySymbol)
         sb.AppendLine()
      Next
      Console.WriteLine(sb.ToString())
   End Sub
End Module
' The example displays output like the following:
'       The currency symbol for 'English (United States)' is '$'
'       The currency symbol for 'English (United Kingdom)' is '£'
'       The currency symbol for 'English (Australia)' is '$'
'       The currency symbol for 'English (Canada)' is '$'
'       The currency symbol for 'English (New Zealand)' is '$'
'       The currency symbol for 'English (Ireland)' is '?'
'       The currency symbol for 'English (South Africa)' is 'R'
'       The currency symbol for 'English (Jamaica)' is 'J$'
'       The currency symbol for 'English (Caribbean)' is '$'
'       The currency symbol for 'English (Belize)' is 'BZ$'
'       The currency symbol for 'English (Trinidad and Tobago)' is 'TT$'
'       The currency symbol for 'English (Zimbabwe)' is 'Z$'
'       The currency symbol for 'English (Republic of the Philippines)' is 'Php'
'       The currency symbol for 'English (India)' is 'Rs.'
'       The currency symbol for 'English (Malaysia)' is 'RM'
'       The currency symbol for 'English (Singapore)' is '$'

Commenti

La NumberFormatInfo classe contiene informazioni specifiche delle impostazioni cultura utilizzate quando si formattano e analizzano valori numerici. Queste informazioni includono il simbolo di valuta, il simbolo decimale, il simbolo separatore di gruppo e i simboli per i segni positivi e negativi.

Creazione di un'istanza di un oggetto NumberFormatInfo

È possibile creare un'istanza di un oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura correnti, delle impostazioni cultura invarianti, di impostazioni cultura specifiche o di NumberFormatInfo impostazioni cultura neutre.

Creazione di un'istanza di un oggetto NumberFormatInfo per le impostazioni cultura correnti

È possibile creare NumberFormatInfo un'istanza di un oggetto per le impostazioni cultura correnti in uno dei modi seguenti. In ogni caso, l'oggetto NumberFormatInfo restituito è di sola lettura.

Nell'esempio seguente vengono utilizzati questi tre modi per creare NumberFormatInfo oggetti che rappresentano le convenzioni di formattazione delle impostazioni cultura correnti. Recupera anche il valore della proprietà per IsReadOnly illustrare che ogni oggetto è di sola lettura.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo current1 = CultureInfo.CurrentCulture.NumberFormat;
      Console.WriteLine(current1.IsReadOnly);

      NumberFormatInfo current2 = NumberFormatInfo.CurrentInfo;
      Console.WriteLine(current2.IsReadOnly);

      NumberFormatInfo current3 = NumberFormatInfo.GetInstance(CultureInfo.CurrentCulture);
      Console.WriteLine(current3.IsReadOnly);
   }
}
// The example displays the following output:
//       True
//       True
//       True
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat
      Console.WriteLine(current1.IsReadOnly)
      
      Dim current2 As NumberFormatInfo = NumberFormatInfo.CurrentInfo
      Console.WriteLine(current2.IsReadOnly)
      
      Dim current3 As NumberFormatInfo = NumberFormatInfo.GetInstance(CultureInfo.CurrentCulture)
      Console.WriteLine(current3.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       True
'       True
'       True

È possibile creare un oggetto NumberFormatInfo scrivibile che rappresenta le convenzioni delle impostazioni cultura correnti in uno dei modi seguenti:

Nell'esempio seguente vengono illustrati questi due modi per creare un'istanza di un oggetto e viene visualizzato il valore della relativa proprietà per illustrare che l'oggetto NumberFormatInfo non è di sola IsReadOnly lettura.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo current1 = NumberFormatInfo.CurrentInfo;
      current1 = (NumberFormatInfo) current1.Clone();
      Console.WriteLine(current1.IsReadOnly);

      CultureInfo culture2 = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
      NumberFormatInfo current2 = culture2.NumberFormat;
      Console.WriteLine(current2.IsReadOnly);
   }
}
// The example displays the following output:
//       False
//       False
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As NumberFormatInfo = NumberFormatInfo.CurrentInfo
      current1 = CType(current1.Clone(), NumberFormatInfo)
      Console.WriteLine(current1.IsReadOnly)

      Dim culture2 As CultureInfo = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name)
      Dim current2 As NumberFormatInfo = culture2.NumberFormat
      Console.WriteLine(current2.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       False
'       False

Si noti che il Windows operativo consente all'utente di eseguire l'override di alcuni dei valori di proprietà usati nelle operazioni di formattazione e analisi numerica tramite l'elemento Region e NumberFormatInfo Language in Pannello di controllo. Ad esempio, un utente le cui impostazioni cultura sono inglese (Stati Uniti) potrebbe scegliere di visualizzare i valori di valuta come 1,1 USD anziché il valore predefinito di $1,1. Gli NumberFormatInfo oggetti recuperati nei modi descritti in precedenza riflettono tutti questi override utente. Se questa operazione non è desiderabile, è possibile creare un oggetto che non rifletta le sostituzioni utente (e che è anche di lettura/scrittura anziché di sola lettura) chiamando il costruttore e fornendo un valore NumberFormatInfo per CultureInfo.CultureInfo(String, Boolean) false l'argomento useUserOverride . L'esempio seguente illustra un sistema le cui impostazioni cultura correnti sono inglese (Stati Uniti) e il cui simbolo di valuta è stato modificato dal valore predefinito $ a USD.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture;
      NumberFormatInfo nfi;

      culture = CultureInfo.CurrentCulture;
      nfi = culture.NumberFormat;
      Console.WriteLine("Culture Name:    {0}", culture.Name);
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
      Console.WriteLine("Currency Symbol: {0}\n", culture.NumberFormat.CurrencySymbol);

      culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
      Console.WriteLine("Culture Name:    {0}", culture.Name);
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol);
   }
}
// The example displays the following output:
//       Culture Name:    en-US
//       User Overrides:  True
//       Currency Symbol: USD
//
//       Culture Name:    en-US
//       User Overrides:  False
//       Currency Symbol: $
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim nfi As NumberFormatInfo
      
      culture = CultureInfo.CurrentCulture
      nfi = culture.NumberFormat
      Console.WriteLine("Culture Name:    {0}", culture.Name)
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride)
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol)
      Console.WriteLine()
            
      culture = New CultureInfo(CultureInfo.CurrentCulture.Name, False)
      Console.WriteLine("Culture Name:    {0}", culture.Name)
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride)
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol)
   End Sub
End Module
' The example displays the following output:
'       Culture Name:    en-US
'       User Overrides:  True
'       Currency Symbol: USD
'       
'       Culture Name:    en-US
'       User Overrides:  False
'       Currency Symbol: $

Se la CultureInfo.UseUserOverride proprietà è impostata su true , le proprietà , e vengono CultureInfo.DateTimeFormat CultureInfo.NumberFormat CultureInfo.TextInfo recuperate anche dalle impostazioni utente. Se le impostazioni utente non sono compatibili con le impostazioni cultura associate all'oggetto , ad esempio se il calendario selezionato non è uno dei calendari elencati dalla proprietà , i risultati dei metodi e dei valori delle proprietà non CultureInfo OptionalCalendars sono definiti.

Creazione di un'istanza di un oggetto NumberFormatInfo per le impostazioni cultura invarianti

Le impostazioni cultura invarianti rappresentano impostazioni cultura indipendenti dalle impostazioni cultura. Si basa sulla lingua inglese, ma non su un paese/area geografica specifico di lingua inglese. Anche se i dati di impostazioni cultura specifiche possono essere dinamici e possono cambiare per riflettere nuove convenzioni culturali o preferenze dell'utente, i dati delle impostazioni cultura invarianti non cambiano. Un oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura invarianti può essere usato per operazioni di formattazione in cui le stringhe di risultato non devono variare in NumberFormatInfo base alle impostazioni cultura.

È possibile creare un'istanza di un oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura NumberFormatInfo invarianti nei modi seguenti:

Nell'esempio seguente viene utilizzato ognuno di questi metodi per creare un'istanza di un oggetto che rappresenta le impostazioni cultura NumberFormatInfo invarianti. Indica quindi se l'oggetto è di sola lettura.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo nfi;

      nfi = System.Globalization.NumberFormatInfo.InvariantInfo;
      Console.WriteLine(nfi.IsReadOnly);

      nfi = CultureInfo.InvariantCulture.NumberFormat;
      Console.WriteLine(nfi.IsReadOnly);

      nfi = new NumberFormatInfo();
      Console.WriteLine(nfi.IsReadOnly);
   }
}
// The example displays the following output:
//       True
//       True
//       False
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim nfi As NumberFormatInfo
      
      nfi = System.Globalization.NumberFormatInfo.InvariantInfo
      Console.WriteLine(nfi.IsReadOnly)               
      
      nfi = CultureInfo.InvariantCulture.NumberFormat
      Console.WriteLine(nfi.IsReadOnly)               
      
      nfi = New NumberFormatInfo()
      Console.WriteLine(nfi.IsReadOnly)               
   End Sub
End Module
' The example displays the following output:
'       True
'       True
'       False

Creazione di un'istanza di un oggetto NumberFormatInfo per impostazioni cultura specifiche

Impostazioni cultura specifiche rappresentano una lingua parlata in un determinato paese/area geografica. En-US, ad esempio, è una lingua specifica che rappresenta la lingua inglese parlata nel Stati Uniti e en-CA è una lingua specifica che rappresenta la lingua inglese parlata in Canada. È possibile creare un'istanza di un oggetto che NumberFormatInfo rappresenta le convenzioni di formattazione di impostazioni cultura specifiche nei modi seguenti:

Nell'esempio seguente vengono utilizzati questi quattro modi per creare un oggetto che riflette le convenzioni di formattazione delle impostazioni cultura NumberFormatInfo indonesiane (Indonesia). Indica anche se ogni oggetto è di sola lettura.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture;
      NumberFormatInfo nfi;

      nfi = CultureInfo.GetCultureInfo("id-ID").NumberFormat;
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);

      culture = new CultureInfo("id-ID");
      nfi = NumberFormatInfo.GetInstance(culture);
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);

      culture = CultureInfo.CreateSpecificCulture("id-ID");
      nfi = culture.NumberFormat;
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);

      culture = new CultureInfo("id-ID");
      nfi = culture.NumberFormat;
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);
   }
}
// The example displays the following output:
//       Read-only: True
//       Read-only: False
//       Read-only: False
//       Read-only: False
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim nfi As NumberFormatInfo
      
      nfi = CultureInfo.GetCultureInfo("id-ID").NumberFormat
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly)
      
      culture = New CultureInfo("id-ID")
      nfi = NumberFormatInfo.GetInstance(culture)
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly)
      
      culture = CultureInfo.CreateSpecificCulture("id-ID")
      nfi = culture.NumberFormat
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly)
      
      culture = New CultureInfo("id-ID")
      nfi = culture.NumberFormat
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       Read-only: True
'       Read-only: False
'       Read-only: False
'       Read-only: False

Creazione di un'istanza di un oggetto NumberFormatInfo per impostazioni cultura neutre

Le impostazioni cultura neutre rappresentano impostazioni cultura o lingua indipendenti da un paese o da un'area geografica. In genere è l'elemento padre di una o più impostazioni cultura specifiche. Ad esempio, fr è una lingua neutra per la lingua francese e l'elemento padre delle impostazioni cultura fr-FR. Si crea un oggetto che rappresenta le convenzioni di formattazione di impostazioni cultura neutre nello stesso modo in cui si crea un oggetto che rappresenta le convenzioni di formattazione NumberFormatInfo NumberFormatInfo di impostazioni cultura specifiche.

Nota

Nella versione .NET Framework 3.5 e versioni precedenti, il tentativo di recuperare un oggetto che riflette le convenzioni di formattazione di impostazioni cultura non indipendenti NumberFormatInfo genera NotSupportedException un'eccezione.

Tuttavia, poiché è indipendente da un paese o un'area geografica specifica, le impostazioni cultura neutre non dispongono di informazioni di formattazione specifiche delle impostazioni cultura. Anziché popolare l'oggetto con valori generici, il .NET Framework restituisce un oggetto che riflette le convenzioni di formattazione di impostazioni cultura specifiche figlio delle impostazioni cultura NumberFormatInfo NumberFormatInfo neutre. Ad esempio, l'oggetto per le impostazioni cultura en neutre riflette le convenzioni di formattazione delle impostazioni cultura en-US e l'oggetto per le impostazioni cultura fr riflette le convenzioni di formattazione delle impostazioni cultura NumberFormatInfo NumberFormatInfo fr-FR.

È possibile usare codice simile al seguente per determinare le convenzioni di formattazione delle impostazioni cultura specifiche rappresentate da ogni lingua neutra.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      // Get all the neutral cultures
      List<String> names = new List<String>();
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    culture => names.Add(culture.Name));
      names.Sort();
      foreach (var name in names) {
         // Ignore the invariant culture.
         if (name == "") continue;

         ListSimilarChildCultures(name);
      }
   }

   private static void ListSimilarChildCultures(string name)
   {
      // Create the neutral NumberFormatInfo object.
      NumberFormatInfo nfi = CultureInfo.GetCultureInfo(name).NumberFormat;
      // Retrieve all specific cultures of the neutral culture.
      CultureInfo[] cultures = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures),
                               culture => culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase));
      // Create an array of NumberFormatInfo properties
      PropertyInfo[] properties = typeof(NumberFormatInfo).GetProperties(BindingFlags.Instance | BindingFlags.Public);
      bool hasOneMatch = false;

      foreach (var ci in cultures) {
         bool match = true;
         // Get the NumberFormatInfo for a specific culture.
         NumberFormatInfo specificNfi = ci.NumberFormat;
         // Compare the property values of the two.
         foreach (var prop in properties) {
            // We're not interested in the value of IsReadOnly.
            if (prop.Name == "IsReadOnly") continue;

            // For arrays, iterate the individual elements to see if they are the same.
            if (prop.PropertyType.IsArray) {
               IList nList = (IList) prop.GetValue(nfi, null);
               IList sList = (IList) prop.GetValue(specificNfi, null);
               if (nList.Count != sList.Count) {
                  match = false;
                  break;
               }

               for (int ctr = 0; ctr < nList.Count; ctr++) {
                  if (! nList[ctr].Equals(sList[ctr])) {
                     match = false;
                     break;
                  }
               }
            }
            else if (! prop.GetValue(specificNfi).Equals(prop.GetValue(nfi))) {
               match = false;
               break;
            }
         }
         if (match) {
            Console.WriteLine("NumberFormatInfo object for '{0}' matches '{1}'",
                                      name, ci.Name);
            hasOneMatch = true;
         }
      }
      if (! hasOneMatch)
         Console.WriteLine("NumberFormatInfo object for '{0}' --> No Match", name);

      Console.WriteLine();
   }
}
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get all the neutral cultures
      Dim names As New List(Of String)
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    Sub(culture) names.Add(culture.Name))
      names.Sort()
      For Each name In names
         ' Ignore the invariant culture.
         If name = "" Then Continue For
         
         ListSimilarChildCultures(name)        
      Next
   End Sub

   Private Sub ListSimilarChildCultures(name As String)
      ' Create the neutral NumberFormatInfo object.
      Dim nfi As NumberFormatInfo = CultureInfo.GetCultureInfo(name).NumberFormat
      ' Retrieve all specific cultures of the neutral culture.
      Dim cultures() As CultureInfo = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures), 
                               Function(culture) culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase))
      ' Create an array of NumberFormatInfo properties
      Dim properties() As PropertyInfo = GetType(NumberFormatInfo).GetProperties(BindingFlags.Instance Or BindingFlags.Public)
      Dim hasOneMatch As Boolean = False

      For Each ci In cultures
         Dim match As Boolean = True     
         ' Get the NumberFormatInfo for a specific culture.
         Dim specificNfi As NumberFormatInfo = ci.NumberFormat
         ' Compare the property values of the two.
         For Each prop In properties
            ' We're not interested in the value of IsReadOnly.     
            If prop.Name = "IsReadOnly" Then Continue For
            
            ' For arrays, iterate the individual elements to see if they are the same.
            If prop.PropertyType.IsArray Then 
               Dim nList As IList = CType(prop.GetValue(nfi, Nothing), IList)
               Dim sList As IList = CType(prop.GetValue(specificNfi, Nothing), IList)
               If nList.Count <> sList.Count Then
                  match = false
                  Exit For
               End If 

               For ctr As Integer = 0 To nList.Count - 1
                  If Not nList(ctr).Equals(sList(ctr)) 
                     match = false
                     Exit For
                  End If     
               Next
            Else If Not prop.GetValue(specificNfi).Equals(prop.GetValue(nfi))
               match = false
               Exit For   
            End If        
         Next
         If match Then
            Console.WriteLine("NumberFormatInfo object for '{0}' matches '{1}'", 
                                      name, ci.Name)
            hasOneMatch = true
         End If                                       
      Next
      If Not hasOneMatch Then
         Console.WriteLine("NumberFormatInfo object for '{0}' --> No Match", name)            
      End If
      
      Console.WriteLine()
   End Sub
End Module

NumberFormatInfo e dati dinamici

I dati specifici delle impostazioni cultura per la formattazione dei valori numerici forniti dalla classe sono dinamici, proprio come i dati culturali NumberFormatInfo forniti dalla CultureInfo classe . Non è consigliabile fare ipotesi sulla stabilità dei valori per NumberFormatInfo gli oggetti associati a oggetti CultureInfo specifici. Solo i dati forniti dalle impostazioni cultura invarianti e dall'oggetto NumberFormatInfo associato sono stabili. Altri dati possono cambiare tra le sessioni dell'applicazione o anche all'interno di una singola sessione, per i motivi seguenti:

  • Aggiornamenti di sistema. Le preferenze culturali, ad esempio il simbolo di valuta o i formati di valuta, cambiano nel tempo. In questo caso, Windows update include modifiche al valore NumberFormatInfo della proprietà per impostazioni cultura specifiche.

  • Impostazioni cultura di sostituzione. La CultureAndRegionInfoBuilder classe può essere utilizzata per sostituire i dati di impostazioni cultura esistenti.

  • Modifiche a catena ai valori delle proprietà. In fase di esecuzione è possibile modificare una serie di proprietà correlate alle impostazioni cultura che, a loro volta, causano NumberFormatInfo la modifica dei dati. Ad esempio, le impostazioni cultura correnti possono essere modificate a livello di codice o tramite l'azione dell'utente. In questo caso, NumberFormatInfo l'oggetto restituito dalla CurrentInfo proprietà cambia in un oggetto associato alle impostazioni cultura correnti.

  • Preferenze dell'utente. Gli utenti dell'applicazione potrebbero eseguire l'override di alcuni dei valori associati alle impostazioni cultura di sistema correnti tramite le opzioni relative all'area e alla lingua in Pannello di controllo. Ad esempio, gli utenti possono scegliere un simbolo di valuta diverso o un separatore decimale diverso. Se la proprietà è impostata su (valore predefinito), anche le proprietà dell'oggetto vengono recuperate CultureInfo.UseUserOverride true dalle impostazioni NumberFormatInfo utente.

A partire dalla .NET Framework 2.0, tutte le proprietà sottoponibili a override dell'utente di un oggetto vengono inizializzate quando viene NumberFormatInfo creato l'oggetto . Esiste ancora una possibilità di incoerenza, perché né la creazione di oggetti né il processo di override dell'utente sono atomici e i valori rilevanti possono cambiare durante la creazione dell'oggetto. Tuttavia, queste incoerenze dovrebbero essere estremamente rare.

È possibile controllare se le sostituzioni utente vengono riflesse negli oggetti NumberFormatInfo che rappresentano le stesse impostazioni cultura delle impostazioni cultura correnti. Nella tabella seguente sono elencati i modi in cui è possibile recuperare un oggetto e viene indicato se l'oggetto risultante riflette le NumberFormatInfo sostituzioni dell'utente.

Origine dell'oggetto CultureInfo e NumberFormatInfo Riflette le sostituzioni utente
ProprietàCultureInfo.CurrentCulture.NumberFormat
ProprietàNumberFormatInfo.CurrentInfo
Metodo CultureInfo.CreateSpecificCulture
Metodo CultureInfo.GetCultureInfo No
Costruttore CultureInfo(String)
Costruttore CultureInfo.CultureInfo(String, Boolean) Dipende dal valore del useUserOverride parametro

A meno che non vi sia un motivo valido per eseguire diversamente, è necessario rispettare le sostituzioni utente quando si usa l'oggetto nelle applicazioni client per formattare e analizzare l'input dell'utente o per visualizzare NumberFormatInfo dati numerici. Per le applicazioni server o le applicazioni automatica, non è necessario rispettare le sostituzioni utente. Tuttavia, se si usa l'oggetto in modo esplicito o implicito per rendere persistenti i dati numerici in formato stringa, è necessario usare un oggetto che rifletta le convenzioni di formattazione delle impostazioni cultura NumberFormatInfo invarianti oppure è necessario specificare una stringa di formato numerico personalizzata che viene utilizzata indipendentemente dalle impostazioni NumberFormatInfo cultura.

IFormatProvider, NumberFormatInfo e formattazione numerica

Un NumberFormatInfo oggetto viene utilizzato in modo implicito o esplicito in tutte le operazioni di formattazione numerica. Sono incluse le chiamate ai metodi seguenti:

Tutte le operazioni di formattazione numerica usano IFormatProvider un'implementazione . IFormatProviderL'interfaccia include un singolo metodo, GetFormat(Type) . Si tratta di un metodo di callback a cui viene passato Type un oggetto che rappresenta il tipo necessario per fornire informazioni di formattazione. Il metodo è responsabile della restituzione di un'istanza di quel tipo o , se non è in grado di null fornire un'istanza del tipo. Il .NET Framework fornisce due IFormatProvider implementazioni per la formattazione dei numeri:

Se un'implementazione non viene fornita in modo esplicito a un metodo di formattazione, viene utilizzato un oggetto restituito dalla proprietà che rappresenta IFormatProvider CultureInfo le impostazioni cultura CultureInfo.CurrentCulture correnti.

Nell'esempio seguente viene illustrata la relazione tra l'interfaccia e la classe nelle operazioni di formattazione IFormatProvider NumberFormatInfo definendo un'implementazione IFormatProvider personalizzata. Il GetFormat metodo visualizza il nome del tipo dell'oggetto richiesto dall'operazione di formattazione. Se l'interfaccia richiede un NumberFormatInfo oggetto , questo metodo fornisce l'oggetto per le impostazioni cultura NumberFormatInfo correnti. Come illustrato nell'output dell'esempio, il metodo richiede a un oggetto di fornire informazioni di formattazione, mentre il metodo richiede oggetti e Decimal.ToString(IFormatProvider) NumberFormatInfo String.Format(IFormatProvider, String, Object[]) NumberFormatInfo DateTimeFormatInfo ICustomFormatter un'implementazione.

using System;
using System.Globalization;

public class CurrentCultureFormatProvider : IFormatProvider
{
   public Object GetFormat(Type formatType)
   {
      Console.WriteLine("Requesting an object of type {0}",
                        formatType.Name);
      if (formatType == typeof(NumberFormatInfo))
         return NumberFormatInfo.CurrentInfo;
      else if (formatType == typeof(DateTimeFormatInfo))
         return DateTimeFormatInfo.CurrentInfo;
      else
         return null;
   }
}

public class Example
{
   public static void Main()
   {
      Decimal amount = 1203.541m;
      string value = amount.ToString("C2", new CurrentCultureFormatProvider());
      Console.WriteLine(value);
      Console.WriteLine();
      string composite = String.Format(new CurrentCultureFormatProvider(),
                                       "Date: {0}   Amount: {1}   Description: {2}",
                                       DateTime.Now, 1264.03m, "Service Charge");
      Console.WriteLine(composite);
      Console.WriteLine();
   }
}
// The example displays output like the following:
//    Requesting an object of type NumberFormatInfo
//    $1,203.54
//
//    Requesting an object of type ICustomFormatter
//    Requesting an object of type DateTimeFormatInfo
//    Requesting an object of type NumberFormatInfo
//    Date: 11/15/2012 2:00:01 PM   Amount: 1264.03   Description: Service Charge
Imports System.Globalization

Public Class CurrentCultureFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      Console.WriteLine("Requesting an object of type {0}", 
                        formatType.Name)
      If formatType Is GetType(NumberFormatInfo) Then
         Return NumberFormatInfo.CurrentInfo
      Else If formatType Is GetType(DateTimeFormatInfo) Then
         Return DateTimeFormatInfo.CurrentInfo
      Else
         Return Nothing
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim amount As Decimal = 1203.541d
      Dim value As String = amount.ToString("C2", New CurrentCultureFormatProvider())
      Console.WriteLine(value)
      Console.WriteLine()
      Dim composite As String = String.Format(New CurrentCultureFormatProvider, 
                                              "Date: {0}   Amount: {1}   Description: {2}",
                                              Date.Now, 1264.03d, "Service Charge")
      Console.WriteLine(composite)
      Console.WriteLine()
   End Sub
End Module
' The example displays output like the following:
'    Requesting an object of type NumberFormatInfo
'    $1,203.54
'    
'    Requesting an object of type ICustomFormatter
'    Requesting an object of type DateTimeFormatInfo
'    Requesting an object of type NumberFormatInfo
'    Date: 11/15/2012 2:00:01 PM   Amount: 1264.03   Description: Service Charge

Se un'implementazione non viene specificata in modo esplicito in una chiamata al metodo di formattazione numerica, il metodo chiama il metodo , che restituisce l'oggetto che IFormatProvider corrisponde alle impostazioni cultura CultureInfo.CurrentCulture.GetFormat NumberFormatInfo correnti.

Stringhe di formato e proprietà NumberFormatInfo

Ogni operazione di formattazione usa una stringa di formato numerico standard o personalizzata per produrre una stringa di risultato da un numero. In alcuni casi, l'uso di una stringa di formato per produrre una stringa di risultato è esplicito, come nell'esempio seguente. Questo codice chiama il metodo per convertire un valore in diverse rappresentazioni di stringa usando le convenzioni di formattazione delle impostazioni cultura Decimal.ToString(IFormatProvider) Decimal en-US.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formatStrings = { "C2", "E1", "F", "G3", "N",
                                 "#,##0.000", "0,000,000,000.0##" };
      CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");
      Decimal[] values = { 1345.6538m, 1921651.16m };

      foreach (var value in values) {
         foreach (var formatString in formatStrings) {
            string resultString = value.ToString(formatString, culture);
            Console.WriteLine("{0,-18} -->  {1}", formatString, resultString);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       C2                 -->  $1,345.65
//       E1                 -->  1.3E+003
//       F                  -->  1345.65
//       G3                 -->  1.35E+03
//       N                  -->  1,345.65
//       #,##0.000          -->  1,345.654
//       0,000,000,000.0##  -->  0,000,001,345.654
//
//       C2                 -->  $1,921,651.16
//       E1                 -->  1.9E+006
//       F                  -->  1921651.16
//       G3                 -->  1.92E+06
//       N                  -->  1,921,651.16
//       #,##0.000          -->  1,921,651.160
//       0,000,000,000.0##  -->  0,001,921,651.16
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim formatStrings() As String = { "C2", "E1", "F", "G3", "N", 
                                        "#,##0.000", "0,000,000,000.0##" }
      Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim values() As Decimal = { 1345.6538d, 1921651.16d }
      
      For Each value In values
         For Each formatString In formatStrings
            Dim resultString As String = value.ToString(formatString, culture)
            Console.WriteLine("{0,-18} -->  {1}", formatString, resultString)
         Next
         Console.WriteLine()      
      Next   
   End Sub
End Module
' The example displays the following output:
'       C2                 -->  $1,345.65
'       E1                 -->  1.3E+003
'       F                  -->  1345.65
'       G3                 -->  1.35E+03
'       N                  -->  1,345.65
'       #,##0.000          -->  1,345.654
'       0,000,000,000.0##  -->  0,000,001,345.654
'       
'       C2                 -->  $1,921,651.16
'       E1                 -->  1.9E+006
'       F                  -->  1921651.16
'       G3                 -->  1.92E+06
'       N                  -->  1,921,651.16
'       #,##0.000          -->  1,921,651.160
'       0,000,000,000.0##  -->  0,001,921,651.16

In altri casi, l'uso di una stringa di formato è implicito. Ad esempio, nelle chiamate di metodo seguenti al metodo predefinito o senza parametri, il valore dell'istanza viene formattato usando l'identificatore di formato generale ("G") e le convenzioni delle impostazioni cultura correnti, che in questo caso sono le impostazioni cultura Decimal.ToString() Decimal en-US.

using System;

public class Example
{
   public static void Main()
   {
      Decimal[] values = { 1345.6538m, 1921651.16m };

      foreach (var value in values) {
         string resultString = value.ToString();
         Console.WriteLine(resultString);
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       1345.6538
//
//       1921651.16
Module Example
   Public Sub Main()
      Dim values() As Decimal = { 1345.6538d, 1921651.16d }
      
      For Each value In values
         Dim resultString As String = value.ToString()
         Console.WriteLine(resultString)
         Console.WriteLine()      
      Next   
   End Sub
End Module
' The example displays the following output:
'       1345.6538
'       
'       1921651.16

Ogni stringa di formato numerico standard usa una o NumberFormatInfo più proprietà per determinare il modello o i simboli usati nella stringa di risultato. Analogamente, ogni identificatore di formato numerico personalizzato, ad eccezione di "0" e "#", inserisce simboli nella stringa di risultato definita dalle NumberFormatInfo proprietà. Nella tabella seguente sono elencati gli identificatori di formato numerico standard e personalizzato e le relative proprietà NumberFormatInfo associate. Per modificare l'aspetto della stringa di risultato per impostazioni cultura specifiche, vedere la sezione Modifica delle proprietà NumberFormatInfo. Per informazioni dettagliate sull'uso di questi identificatori di formato, vedere Stringhe di formato numerico standard e Stringhe di formato numerico personalizzato.

Identificatore di formato Proprietà associate
"C" o "c" (identificatore di formato di valuta) CurrencyDecimalDigitsper definire il numero predefinito di cifre frazionarie.

CurrencyDecimalSeparator, per definire il simbolo di separatore decimale.

CurrencyGroupSeparator, per definire il separatore delle migliaia o del gruppo.

CurrencyGroupSizesper definire le dimensioni dei gruppi integrali.

CurrencyNegativePattern, per definire il modello di valori di valuta negativi.

CurrencyPositivePattern, per definire il modello di valori di valuta positivi.

CurrencySymbolper definire il simbolo di valuta.

NegativeSign, per definire il simbolo di segno negativo.
"D" o "d" (identificatore di formato decimale) NegativeSign, per definire il simbolo di segno negativo.
"E" o "e" (identificatore di formato esponenziale o scientifico) NegativeSign, per definire il simbolo di segno negativo nella mantissa e nell'esponente.

NumberDecimalSeparator, per definire il simbolo di separatore decimale.

PositiveSign, per definire il simbolo di segno positivo nell'esponente.
"F" o "f" (identificatore di formato a virgola fissa) NegativeSign, per definire il simbolo di segno negativo.

NumberDecimalDigitsper definire il numero predefinito di cifre frazionarie.

NumberDecimalSeparator, per definire il simbolo di separatore decimale.
"G" o "g" (identificatore di formato generale) NegativeSign, per definire il simbolo di segno negativo.

NumberDecimalSeparator, per definire il simbolo di separatore decimale.

PositiveSign, per definire il simbolo di segno positivo per le stringhe di risultato in formato esponenziale.
"N" o "n" (identificatore di formato numerico) NegativeSign, per definire il simbolo di segno negativo.

NumberDecimalDigitsper definire il numero predefinito di cifre frazionarie.

NumberDecimalSeparator, per definire il simbolo di separatore decimale.

NumberGroupSeparator, per definire il simbolo di separatore di gruppo (migliaia).

NumberGroupSizesper definire il numero di cifre integrali in un gruppo.

NumberNegativePatternper definire il formato dei valori negativi.
"P" o "p" (identificatore di formato percentuale) NegativeSign, per definire il simbolo di segno negativo.

PercentDecimalDigitsper definire il numero predefinito di cifre frazionarie.

PercentDecimalSeparator, per definire il simbolo di separatore decimale.

PercentGroupSeparator, per definire il simbolo del separatore di gruppo.

PercentGroupSizesper definire il numero di cifre integrali in un gruppo.

PercentNegativePatternper definire la posizione del simbolo di percentuale e il simbolo negativo per i valori negativi.

PercentPositivePatternper definire la posizione del simbolo di percentuale per i valori positivi.

PercentSymbol, per definire il simbolo di percentuale.
"R" o "r" (identificatore di formato round trip) NegativeSign, per definire il simbolo di segno negativo.

NumberDecimalSeparator, per definire il simbolo di separatore decimale.

PositiveSign, per definire il simbolo di segno positivo in un esponente.
"X" o "x" (identificatore di formato esadecimale) Nessuno.
"." (identificatore di formato personalizzato con virgola decimale) NumberDecimalSeparator, per definire il simbolo di separatore decimale.
"," (identificatore di formato personalizzato separatore di gruppo) NumberGroupSeparator, per definire il simbolo separatore del gruppo (migliaia).
"%" (identificatore di formato personalizzato segnaposto percentuale) PercentSymbol, per definire il simbolo di percentuale.
"‰" (identificatore di formato personalizzato segnaposto per mille) PerMilleSymbol, per definire il simbolo per mille.
"E" (identificatore di formato personalizzato con notazione esponenziale) NegativeSign, per definire il simbolo di segno negativo nella mantissa e nell'esponente.

PositiveSign, per definire il simbolo di segno positivo nell'esponente.

Si noti che NumberFormatInfo la classe include una proprietà che specifica le cifre in base NativeDigits 10 usate da impostazioni cultura specifiche. Tuttavia, la proprietà non viene utilizzata nelle operazioni di formattazione. Nella stringa di risultato vengono usate solo le cifre latini di base da 0 (U+0030) a 9 (U+0039). Inoltre, per i valori e di , e , la stringa di risultato è costituita esclusivamente dai simboli definiti rispettivamente dalle proprietà Single Double , e NaN PositiveInfinity NegativeInfinity NaNSymbol PositiveInfinitySymbol NegativeInfinitySymbol .

Modifica delle proprietà NumberFormatInfo

È possibile modificare le proprietà di un oggetto NumberFormatInfo per personalizzare la stringa di risultato prodotta in un'operazione di formattazione numerica. Per eseguire questa operazione:

  1. Creare una copia di lettura/scrittura di un oggetto di cui si desidera modificare NumberFormatInfo le convenzioni di formattazione. Per altre informazioni, vedere la sezione Creazione di un'istanza di un oggetto NumberFormatInfo.

  2. Modificare la proprietà o le proprietà utilizzate per produrre la stringa di risultato desiderata. Per informazioni su come i metodi di formattazione usano le proprietà per definire le stringhe NumberFormatInfo di risultato, vedere la sezione Stringhe di formato e proprietà NumberFormatInfo.

  3. Usare l'oggetto NumberFormatInfo personalizzato come argomento nelle chiamate ai metodi di IFormatProvider formattazione.

Nota

Anziché modificare dinamicamente i valori delle proprietà delle impostazioni cultura ogni volta che viene avviata un'applicazione, è possibile usare la classe per definire impostazioni cultura personalizzate (impostazioni cultura con un nome univoco e che integrano impostazioni cultura esistenti) o impostazioni cultura sostitutive (usate al posto di impostazioni cultura CultureAndRegionInfoBuilder specifiche).

Le sezioni seguenti forniscono alcuni esempi.

Modifica del simbolo di valuta e del modello

Nell'esempio seguente viene modificato un NumberFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura en-US. Assegna il simbolo di valuta ISO-4217 alla proprietà e definisce un modello per i valori di valuta costituito dal simbolo di valuta seguito da uno spazio e da CurrencySymbol un valore numerico.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Retrieve a writable NumberFormatInfo object.
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      NumberFormatInfo nfi = enUS.NumberFormat;

      // Use the ISO currency symbol instead of the native currency symbol.
      nfi.CurrencySymbol =  (new RegionInfo(enUS.Name)).ISOCurrencySymbol;
      // Change the positive currency pattern to <code><space><value>.
      nfi.CurrencyPositivePattern = 2;
      // Change the negative currency pattern to <code><space><sign><value>.
      nfi.CurrencyNegativePattern = 12;

      // Produce the result strings by calling ToString.
      Decimal[] values = { 1065.23m, 19.89m, -.03m, -175902.32m };
      foreach (var value in values)
         Console.WriteLine(value.ToString("C", enUS));

      Console.WriteLine();

      // Produce the result strings by calling a composite formatting method.
      foreach (var value in values)
         Console.WriteLine(String.Format(enUS, "{0:C}", value));
   }
}
// The example displays the following output:
//       USD 1,065.23
//       USD 19.89
//       USD -0.03
//       USD -175,902.32
//
//       USD 1,065.23
//       USD 19.89
//       USD -0.03
//       USD -175,902.32
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Retrieve a writable NumberFormatInfo object.
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim nfi As NumberFormatInfo = enUS.NumberFormat

      ' Use the ISO currency symbol instead of the native currency symbol.
      nfi.CurrencySymbol =  (New RegionInfo(enUS.Name)).ISOCurrencySymbol
      ' Change the positive currency pattern to <code><space><value>.
      nfi.CurrencyPositivePattern = 2
      ' Change the negative currency pattern to <code><space><sign><value>.     
      nfi.CurrencyNegativePattern = 12
      
      ' Produce the result strings by calling ToString.
      Dim values() As Decimal = { 1065.23d, 19.89d, -.03d, -175902.32d }
      For Each value In values
         Console.WriteLine(value.ToString("C", enUS))
      Next      
      Console.WriteLine()
      
      ' Produce the result strings by calling a composite formatting method.
      For Each value In values
         Console.WriteLine(String.Format(enUS, "{0:C}", value))      
      Next
   End Sub
End Module
' The example displays the following output:
'       USD 1,065.23
'       USD 19.89
'       USD -0.03
'       USD -175,902.32
'       
'       USD 1,065.23
'       USD 19.89
'       USD -0.03
'       USD -175,902.32

Formattazione di un numero di identificazione nazionale

Molti numeri di identificazione nazionale sono costituiti esclusivamente da cifre e quindi possono essere formattati facilmente modificando le proprietà di un NumberFormatInfo oggetto. Ad esempio, un codice di previdenza sociale nel Stati Uniti costituito da 9 cifre disposte come segue: XXX-XX-XXXX . Nell'esempio seguente si presuppone che i numeri di previdenza sociale siano archiviati come valori interi e li formatti in modo appropriato.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Instantiate a read-only NumberFormatInfo object.
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      NumberFormatInfo nfi = enUS.NumberFormat;

      // Modify the relevant properties.
      nfi.NumberGroupSeparator = "-";
      nfi.NumberGroupSizes = new int[] { 3, 2, 4};
      nfi.NumberDecimalDigits = 0;

      int[] ids = { 111223333, 999776666 };

      // Produce the result string by calling ToString.
      foreach (var id in ids)
         Console.WriteLine(id.ToString("N", enUS));

      Console.WriteLine();

      // Produce the result string using composite formatting.
      foreach (var id in ids)
         Console.WriteLine(String.Format(enUS, "{0:N}", id));
   }
}
// The example displays the following output:
//       1112-23-333
//       9997-76-666
//
//       1112-23-333
//       9997-76-666
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Instantiate a read-only NumberFormatInfo object.
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim nfi As NumberFormatInfo = enUS.NumberFormat

      ' Modify the relevant properties.
      nfi.NumberGroupSeparator = "-"
      nfi.NumberGroupSizes = { 3, 2, 4}
      nfi.NumberDecimalDigits = 0
      
      Dim ids() As Integer = { 111223333, 999776666 }
      
      ' Produce the result string by calling ToString.
      For Each id In ids
         Console.WriteLine(id.ToString("N", enUS))
      Next 
      Console.WriteLine()
      
      ' Produce the result string using composite formatting.
      For Each id In ids
         Console.WriteLine(String.Format(enUS, "{0:N}", id))
      Next
   End Sub
End Module
' The example displays the following output:
'       1112-23-333
'       9997-76-666
'       
'       1112-23-333
'       9997-76-666

Analisi di stringhe numeriche

L'analisi comporta la conversione della rappresentazione di stringa di un numero in un numero. Ogni tipo numerico nell'.NET Framework include due metodi di analisi di overload: Parse e TryParse . Il Parse metodo converte una stringa in un numero e genera un'eccezione se la conversione non riesce. Il metodo converte una stringa in un numero, assegna il numero a un argomento e restituisce un valore che indica se la conversione è TryParse out Boolean riuscita.

I metodi di analisi usano in modo implicito o esplicito un valore di enumerazione per determinare quali elementi di stile( ad esempio separatori di gruppi, separatori decimali o simboli di valuta) possono essere presenti in una stringa se l'operazione di analisi deve avere esito NumberStyles positivo. Se non viene specificato un valore nella chiamata al metodo, il valore predefinito è un valore che include i flag e , che specifica che la stringa analizzata può includere simboli di NumberStyles gruppo, un separatore decimale, un segno negativo e spazi vuoti oppure può essere la rappresentazione di stringa di un numero NumberStyles Float in AllowThousands notazione esponenziale.

I metodi di analisi usano anche in modo implicito o esplicito un oggetto che definisce i simboli e i modelli specifici che possono verificarsi nella NumberFormatInfo stringa da analizzare. Se non NumberFormatInfo viene fornito un oggetto , il valore predefinito è per le impostazioni cultura NumberFormatInfo correnti. Per altre informazioni sull'analisi, vedere i singoli metodi di analisi, ad esempio Int16.Parse(String) , , , , e Int32.Parse(String, NumberStyles) Int64.Parse(String, IFormatProvider) Decimal.Parse(String, NumberStyles, IFormatProvider) Double.TryParse(String, Double) BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger) .

Nell'esempio seguente viene illustrata la natura con distinzione delle impostazioni cultura dell'analisi delle stringhe. Tenta di analizzare una stringa che include separatori delle migliaia usando le convenzioni delle impostazioni cultura en-US, fr-FR e invarianti. Una stringa che include la virgola come separatore di gruppo e il punto come separatore decimale non viene analizzato nelle impostazioni cultura fr-FR e una stringa con spazi vuoti come separatore di gruppo e una virgola come separatore decimale non viene analizzata nelle impostazioni cultura en-US e invarianti.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] values = { "1,034,562.91", "9 532 978,07" };
      String[] cultureNames = { "en-US", "fr-FR", "" };

      foreach (var value in values) {
         foreach (var cultureName in cultureNames) {
            CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
            String name = culture.Name == "" ? "Invariant" : culture.Name;
            try {
               Decimal amount = Decimal.Parse(value, culture);
               Console.WriteLine("'{0}' --> {1} ({2})", value, amount, name);
            }
            catch (FormatException) {
               Console.WriteLine("'{0}': FormatException ({1})",
                                 value, name);
            }
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       '1,034,562.91' --> 1034562.91 (en-US)
//       '1,034,562.91': FormatException (fr-FR)
//       '1,034,562.91' --> 1034562.91 (Invariant)
//
//       '9 532 978,07': FormatException (en-US)
//       '9 532 978,07' --> 9532978.07 (fr-FR)
//       '9 532 978,07': FormatException (Invariant)
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { "1,034,562.91", "9 532 978,07" }
      Dim cultureNames() As String = { "en-US", "fr-FR", "" }
      
      For Each value In values
         For Each cultureName In cultureNames
            Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
            Dim name As String = If(culture.Name = "", "Invariant", culture.Name)
            Try
               Dim amount As Decimal = Decimal.Parse(value, culture)
               Console.WriteLine("'{0}' --> {1} ({2})", value, amount, name)
            Catch e As FormatException
               Console.WriteLine("'{0}': FormatException ({1})",
                                 value, name)
            End Try   
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       '1,034,562.91' --> 1034562.91 (en-US)
'       '1,034,562.91': FormatException (fr-FR)
'       '1,034,562.91' --> 1034562.91 (Invariant)
'       
'       '9 532 978,07': FormatException (en-US)
'       '9 532 978,07' --> 9532978.07 (fr-FR)
'       '9 532 978,07': FormatException (Invariant)

L'analisi si verifica in genere in due contesti:

  • Come operazione progettata per convertire l'input dell'utente in un valore numerico.

  • Come operazione progettata per eseguire il round trip di un valore numerico; per deserializzare un valore numerico serializzato in precedenza come stringa.

Le sezioni seguenti illustrano queste due operazioni in modo più dettagliato.

Analisi delle stringhe utente

Quando si analizzano stringhe numeriche di input da parte dell'utente, è sempre necessario creare un'istanza di un oggetto che rifletta le NumberFormatInfo impostazioni cultura dell'utente. Per informazioni su come creare un'istanza NumberFormatInfo di un oggetto che riflette le personalizzazioni utente, vedere la sezione NumberFormatInfo e dynamic data.

Nell'esempio seguente viene illustrata la differenza tra un'operazione di analisi che riflette le impostazioni cultura dell'utente e una che non lo fa. In questo caso, le impostazioni cultura di sistema predefinite sono en-US, ma l'utente ha definito "," come simbolo decimale e "." come separatore di gruppi in Pannello di controllo, Region e Language. In genere, questi simboli vengono invertati nelle impostazioni cultura en-US predefinite. Quando l'utente immette una stringa che riflette le impostazioni utente e la stringa viene analizzata da un oggetto che riflette anche le impostazioni utente (sostituzioni), l'operazione di analisi restituisce un NumberFormatInfo risultato corretto. Tuttavia, quando la stringa viene analizzata da un oggetto che riflette le impostazioni cultura en-US standard, commette errori nel simbolo della virgola per un separatore di gruppo e restituisce un NumberFormatInfo risultato non corretto.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo stdCulture = CultureInfo.GetCultureInfo("en-US");
      CultureInfo custCulture = CultureInfo.CreateSpecificCulture("en-US");

      String value = "310,16";
      try {
         Console.WriteLine("{0} culture reflects user overrides: {1}",
                           stdCulture.Name, stdCulture.UseUserOverride);
         Decimal amount = Decimal.Parse(value, stdCulture);
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture));
      }
      catch (FormatException) {
         Console.WriteLine("Unable to parse '{0}'", value);
      }
      Console.WriteLine();

      try {
         Console.WriteLine("{0} culture reflects user overrides: {1}",
                           custCulture.Name, custCulture.UseUserOverride);
         Decimal amount = Decimal.Parse(value, custCulture);
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture));
      }
      catch (FormatException) {
         Console.WriteLine("Unable to parse '{0}'", value);
      }
   }
}
// The example displays the following output:
//       en-US culture reflects user overrides: False
//       '310,16' --> 31016
//
//       en-US culture reflects user overrides: True
//       '310,16' --> 310.16
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim stdCulture As CultureInfo = CultureInfo.GetCultureInfo("en-US")
      Dim custCulture As CultureInfo = CultureInfo.CreateSpecificCulture("en-US") 
            
      Dim value As String = "310,16"
      Try
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           stdCulture.Name, stdCulture.UseUserOverride)
         Dim amount As Decimal = Decimal.Parse(value, stdCulture)
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture))                                                                                        
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}'", value)
      End Try   
      Console.WriteLine()
                                            
      Try
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           custCulture.Name, custCulture.UseUserOverride)
         Dim amount As Decimal = Decimal.Parse(value, custCulture)
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture))                                                                                        
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}'", value)
      End Try   
   End Sub
End Module
' The example displays the following output:
'       en-US culture reflects user overrides: False
'       '310,16' --> 31016
'       
'       en-US culture reflects user overrides: True
'       '310,16' --> 310.16

Serializzazione e deserializzazione di dati numerici

Quando i dati numerici vengono serializzati in formato stringa e successivamente deserializzati e analizzati, le stringhe devono essere generate e analizzate usando le convenzioni delle impostazioni cultura invarianti. Le operazioni di formattazione e analisi non devono mai riflettere le convenzioni di impostazioni cultura specifiche. Se vengono usate impostazioni specifiche delle impostazioni cultura, la portabilità dei dati è rigorosamente limitata. può essere deserializzato correttamente solo in un thread le cui impostazioni specifiche delle impostazioni cultura sono identiche a quelle del thread in cui è stato serializzato. In alcuni casi, ciò significa che i dati non possono essere deserializzati correttamente nello stesso sistema in cui sono stati serializzati.

L'esempio seguente illustra cosa può accadere quando viene violato questo principio. I valori a virgola mobile in una matrice vengono convertiti in stringhe quando il thread corrente usa le impostazioni cultura specifiche delle impostazioni cultura en-US. I dati vengono quindi analizzati da un thread che usa le impostazioni cultura specifiche delle impostazioni cultura pt-BR. In questo caso, anche se ogni operazione di analisi ha esito positivo, i dati non vengono completati correttamente e si verifica il danneggiamento dei dati. In altri casi, un'operazione di analisi potrebbe non riuscire e FormatException potrebbe essere generata un'eccezione.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   public static void Main()
   {
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      PersistData();

      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("pt-BR");
      RestoreData();
   }

   private static void PersistData()
   {
      // Define an array of floating-point values.
      Double[] values = { 160325.972, 8631.16, 1.304e5, 98017554.385,
                          8.5938287084321676e94 };
      Console.WriteLine("Original values: ");
      foreach (var value in values)
         Console.WriteLine(value.ToString("R", CultureInfo.InvariantCulture));

      // Serialize an array of doubles to a file
      StreamWriter sw = new StreamWriter(@".\NumericData.bin");
      for (int ctr = 0; ctr < values.Length; ctr++) {
         sw.Write(values[ctr].ToString("R"));
         if (ctr < values.Length - 1) sw.Write("|");
      }
      sw.Close();
      Console.WriteLine();
   }

   private static void RestoreData()
   {
      // Deserialize the data
      StreamReader sr = new StreamReader(@".\NumericData.bin");
      String data = sr.ReadToEnd();
      sr.Close();

      String[] stringValues = data.Split('|');
      List<Double> newValueList = new List<Double>();

      foreach (var stringValue in stringValues) {
         try {
            newValueList.Add(Double.Parse(stringValue));
         }
         catch (FormatException) {
            newValueList.Add(Double.NaN);
         }
      }

      Console.WriteLine("Restored values:");
      foreach (var newValue in newValueList)
         Console.WriteLine(newValue.ToString("R", NumberFormatInfo.InvariantInfo));
   }
}
// The example displays the following output:
//       Original values:
//       160325.972
//       8631.16
//       130400
//       98017554.385
//       8.5938287084321671E+94
//
//       Restored values:
//       160325972
//       863116
//       130400
//       98017554385
//       8.5938287084321666E+110
Imports System.Collections.Generic
Imports System.Globalization
Imports System.IO
Imports System.Threading

Module Example
   Public Sub Main()
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      PersistData()
      
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("pt-BR")
      RestoreData()
   End Sub
   
   Private Sub PersistData()
      ' Define an array of floating-point values.
      Dim values() As Double = { 160325.972, 8631.16, 1.304e5, 98017554.385, 
                                 8.5938287084321676e94 }
      Console.WriteLine("Original values: ")
      For Each value In values
         Console.WriteLine(value.ToString("R", CultureInfo.InvariantCulture))
      Next
         
      ' Serialize an array of doubles to a file 
      Dim sw As New StreamWriter(".\NumericData.bin")
      For ctr As Integer = 0 To values.Length - 1
         sw.Write(values(ctr).ToString("R"))
         If ctr < values.Length - 1 Then sw.Write("|")
      Next
      sw.Close()
      Console.WriteLine()
   End Sub
   
   Private Sub RestoreData()   
      ' Deserialize the data
      Dim sr AS New StreamReader(".\NumericData.bin")
      Dim data As String = sr.ReadToEnd()
      sr.Close()
      
      Dim stringValues() As String = data.Split("|"c)
      Dim newValueList As New List(Of Double)
      
      For Each stringValue In stringValues
         Try
            newValueList.Add(Double.Parse(stringValue))
         Catch e As FormatException
            newValueList.Add(Double.NaN)
         End Try   
      Next                                   

      Console.WriteLine("Restored values:")
      For Each newValue In newValueList
         Console.WriteLine(newValue.ToString("R", NumberFormatInfo.InvariantInfo))
      Next
   End Sub
End Module
' The example displays the following output:
'       Original values:
'       160325.972
'       8631.16
'       130400
'       98017554.385
'       8.5938287084321671E+94
'       
'       Restored values:
'       160325972
'       863116
'       130400
'       98017554385
'       8.5938287084321666E+110

Costruttori

NumberFormatInfo()

Inizializza una nuova istanza scrivibile della classe NumberFormatInfo che è indipendente dalle impostazioni cultura (invariante).

Proprietà

CurrencyDecimalDigits

Ottiene o imposta il numero di posizioni decimali da usare nei valori di valuta.

CurrencyDecimalSeparator

Ottiene o imposta la stringa da usare come separatore decimale nei valori di valuta.

CurrencyGroupSeparator

Ottiene o imposta la stringa di separazione dei gruppi di cifre che si trovano a sinistra del separatore decimale nei valori di valuta.

CurrencyGroupSizes

Ottiene o imposta il numero di cifre in ciascun gruppo che si trova a sinistra del separatore decimale nei valori di valuta.

CurrencyNegativePattern

Ottiene o imposta il modello di formato per i valori di valuta negativi.

CurrencyPositivePattern

Ottiene o imposta il modello di formato per i valori di valuta positivi.

CurrencySymbol

Ottiene o imposta la stringa da usare come simbolo di valuta.

CurrentInfo

Ottiene un oggetto NumberFormatInfo di sola lettura che formatta i valori in base alle impostazioni cultura correnti.

DigitSubstitution

Ottiene o imposta un valore che specifica come viene visualizzata la forma di una cifra dall'interfaccia utente grafica.

InvariantInfo

Ottiene un oggetto NumberFormatInfo di sola lettura indipendente dalle impostazioni cultura (invariante).

IsReadOnly

Ottiene un valore che indica se l'oggetto NumberFormatInfo è di sola lettura.

NaNSymbol

Ottiene o imposta la stringa che rappresenta il valore IEEE NaN (Not a Number).

NativeDigits

Ottiene o imposta una matrice di stringhe di cifre native equivalenti ai numeri europei da 0 a 9.

NegativeInfinitySymbol

Ottiene o imposta la stringa che rappresenta il valore di infinito negativo.

NegativeSign

Ottiene o imposta la stringa che indica che il numero associato è negativo.

NumberDecimalDigits

Ottiene o imposta il numero di posizioni decimali da usare nei valori numerici.

NumberDecimalSeparator

Ottiene o imposta la stringa da usare come separatore decimale nei valori numerici.

NumberGroupSeparator

Ottiene o imposta la stringa di separazione dei gruppi di cifre che si trovano a sinistra del separatore decimale nei valori numerici.

NumberGroupSizes

Ottiene o imposta il numero di cifre in ciascun gruppo che si trova a sinistra del separatore decimale nei valori numerici.

NumberNegativePattern

Ottiene o imposta il modello di formato per i valori numerici negativi.

PercentDecimalDigits

Ottiene o imposta il numero di posizioni decimali da usare nei valori percentuali.

PercentDecimalSeparator

Ottiene o imposta la stringa da usare come separatore decimale nei valori percentuali.

PercentGroupSeparator

Ottiene o imposta la stringa di separazione dei gruppi di cifre che si trovano a sinistra del separatore decimale nei valori percentuali.

PercentGroupSizes

Ottiene o imposta il numero di cifre in ciascun gruppo che si trova a sinistra del separatore decimale nei valori percentuali.

PercentNegativePattern

Ottiene o imposta il modello di formato per i valori percentuali negativi.

PercentPositivePattern

Ottiene o imposta il modello di formato per i valori percentuali positivi.

PercentSymbol

Ottiene o imposta la stringa da usare come simbolo di percentuale.

PerMilleSymbol

Ottiene o imposta la stringa da usare come simbolo di per mille.

PositiveInfinitySymbol

Ottiene o imposta la stringa che rappresenta il valore di infinito positivo.

PositiveSign

Ottiene o imposta la stringa che indica che il numero associato è positivo.

Metodi

Clone()

Crea una copia superficiale dell'oggetto NumberFormatInfo.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetFormat(Type)

Ottiene un oggetto del tipo specificato che fornisce un servizio di formattazione dei numeri.

GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetInstance(IFormatProvider)

Ottiene l'oggetto NumberFormatInfo associato all'oggetto IFormatProvider specificato.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
ReadOnly(NumberFormatInfo)

Restituisce un wrapper NumberFormatInfo di sola lettura.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)

Si applica a

Vedi anche