NumberFormatInfo NumberFormatInfo NumberFormatInfo NumberFormatInfo Class

Definizione

Fornisce informazioni specifiche delle impostazioni cultura per la formattazione e l'analisi dei valori numerici.Provides culture-specific information for formatting and parsing numeric values.

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

Esempi

Nell'esempio seguente viene illustrato come recuperare un NumberFormatInfo oggetto per un oggetto CultureInfo corrispondente e utilizzare l'oggetto recuperato per eseguire query sulle informazioni di formattazione dei numeri per determinate impostazioni cultura.The following example shows how to retrieve a NumberFormatInfo object for a corresponding CultureInfo object, and use the retrieved object to query number formatting information for the particular culture.

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 durante la formattazione e l'analisi dei valori numerici.The NumberFormatInfo class contains culture-specific information that is used when you format and parse numeric values. Queste informazioni includono il simbolo di valuta, il simbolo decimale, il simbolo del separatore di gruppi e i simboli per i segni positivi e negativi.This information includes the currency symbol, the decimal symbol, the group separator symbol, and the symbols for positive and negative signs.

Creazione di un'istanza di un oggetto NumberFormatInfoInstantiating a NumberFormatInfo object

È possibile creare un'istanza NumberFormatInfo di un oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura correnti, della lingua inglese, di impostazioni cultura specifiche o di impostazioni cultura non associate ad alcun paese.You can instantiate a NumberFormatInfo object that represents the formatting conventions of the current culture, the invariant culture, a specific culture, or a neutral culture.

Creazione di un'istanza di un oggetto NumberFormatInfo per le impostazioni cultura correntiInstantiating a NumberFormatInfo object for the current culture

È possibile creare un'istanza NumberFormatInfo di un oggetto per le impostazioni cultura del thread corrente nei modi seguenti.You can instantiate a NumberFormatInfo object for the current thread culture in any of the following ways. In ogni caso, l'oggetto NumberFormatInfo restituito è di sola lettura.In each case, the returned NumberFormatInfo object is read-only.

Nell'esempio seguente vengono utilizzati questi tre modi per NumberFormatInfo creare oggetti che rappresentano le convenzioni di formattazione delle impostazioni cultura correnti.The following example uses these three ways to create NumberFormatInfo objects that represent the formatting conventions of the current culture. Recupera inoltre il valore della IsReadOnly proprietà per illustrare che ogni oggetto è di sola lettura.It also retrieves the value of the IsReadOnly property to illustrate that each object is read-only.

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 del thread corrente in uno dei modi seguenti:You can create a writable NumberFormatInfo object that represents the conventions of the current thread culture in any of the following ways:

Nell'esempio seguente vengono illustrate queste due modalità di creazione di NumberFormatInfo un'istanza di un oggetto e viene visualizzato IsReadOnly il valore della relativa proprietà per illustrare che l'oggetto non è di sola lettura.The following example illustrates these two ways of instantiating a NumberFormatInfo object, and displays the value of its IsReadOnly property to illustrate that the object is not read-only.

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 sistema operativo Windows consente all'utente di eseguire l'override NumberFormatInfo di alcuni dei valori delle proprietà utilizzati nelle operazioni di formattazione numerica e di analisi tramite l'elemento Region e Language del pannello di controllo.Note that the Windows operating system allows the user to override some of the NumberFormatInfo property values used in numeric formatting and parsing operations through the Region and Language item in Control Panel. Ad esempio, un utente le cui impostazioni cultura sono in inglese (Stati Uniti) può scegliere di visualizzare i valori di valuta come 1,1 USD anziché il valore predefinito $1,1.For example, a user whose culture is English (United States) might choose to display currency values as 1.1 USD instead of the default of $1.1. Gli NumberFormatInfo oggetti recuperati nei modi descritti in precedenza riflettono tutti questi override degli utenti.The NumberFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Se questa operazione non è auspicabile, è NumberFormatInfo possibile creare un oggetto che non rifletta le sostituzioni utente (e che sia anche di lettura/scrittura anziché di sola CultureInfo.CultureInfo(String, Boolean) lettura) chiamando il costruttore e false specificando il useUserOverride valore per argomento.If this is undesirable, you can create a NumberFormatInfo object that does not reflect user overrides (and that is also read/write rather than read-only) by calling the CultureInfo.CultureInfo(String, Boolean) constructor and supplying a value of false for the useUserOverride argument. Nell'esempio seguente viene fornita un'illustrazione per un sistema le cui impostazioni cultura correnti sono la lingua inglese (Stati Uniti) e il cui simbolo di valuta è stato modificato dal valore predefinito di $ a USD.The following example provides an illustration for a system whose current culture is English (United States) and whose currency symbol has been changed from the default of $ to 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à CultureInfo.DateTimeFormat, CultureInfo.NumberFormate CultureInfo.TextInfo vengono recuperate anche dalle impostazioni utente.If the CultureInfo.UseUserOverride property is set to true, the properties CultureInfo.DateTimeFormat, CultureInfo.NumberFormat, and CultureInfo.TextInfo are also retrieved from the user settings. Se le impostazioni utente non sono compatibili con le impostazioni cultura associate CultureInfo all'oggetto (ad esempio, se il calendario selezionato non è uno dei calendari elencati OptionalCalendars dalla proprietà), i risultati dei metodi e i valori delle proprietà sono non definito.If the user settings are incompatible with the culture associated with the CultureInfo object (for example, if the selected calendar is not one of the calendars listed by the OptionalCalendars property), the results of the methods and the values of the properties are undefined.

Creazione di un'istanza di un oggetto NumberFormatInfo per le impostazioni cultura invariantiInstantiating a NumberFormatInfo object for the invariant culture

La lingua inglese rappresenta le impostazioni cultura che non fanno distinzione tra le impostazioni cultura.The invariant culture represents a culture that is culture-insensitive. Il linguaggio è basato sulla lingua inglese, ma non su un paese o un'area geografica di lingua inglese specifica.It is based on the English language but not on any specific English-speaking country/region. Sebbene i dati di impostazioni cultura specifiche possano essere dinamici e possano essere modificati in modo da riflettere le nuove convenzioni culturali o le preferenze dell'utente, i dati della lingua inglese non cambiano.Although the data of specific cultures can be dynamic and can change to reflect new cultural conventions or user preferences, the data of the invariant culture does not change. Un NumberFormatInfo oggetto che rappresenta le convenzioni di formattazione della lingua inglese può essere utilizzato per le operazioni di formattazione nelle quali le stringhe di risultato non devono variare in base alle impostazioni cultura.A NumberFormatInfo object that represents the formatting conventions of the invariant culture can be used for formatting operations in which result strings should not vary by culture.

È possibile creare un'istanza NumberFormatInfo di un oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura invarianti nei modi seguenti:You can instantiate a NumberFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

Nell'esempio seguente viene usato ognuno di questi metodi per creare un' NumberFormatInfo istanza di un oggetto che rappresenta le impostazioni cultura invarianti.The following example uses each of these methods to instantiate a NumberFormatInfo object that represents the invariant culture. Indica quindi se l'oggetto è di sola lettura.It then indicates whether the object is read-only,

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 specificheInstantiating a NumberFormatInfo object for a specific culture

Le impostazioni cultura specifiche rappresentano una lingua pronunciata in un determinato paese/area geografica.A specific culture represents a language that is spoken in a particular country/region. Ad esempio, en-US è un'impostazione cultura specifica che rappresenta la lingua inglese parlata nel Stati Uniti e en-CA è una cultura specifica che rappresenta la lingua inglese parlata in Canada.For example, en-US is a specific culture that represents the English language spoken in the United States, and en-CA is a specific culture that represents the English language spoken in Canada. È possibile creare un'istanza NumberFormatInfo di un oggetto che rappresenta le convenzioni di formattazione di impostazioni cultura specifiche nei modi seguenti:You can instantiate a NumberFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

Nell'esempio seguente vengono usati questi quattro modi per creare NumberFormatInfo un oggetto che riflette le convenzioni di formattazione delle impostazioni cultura indonesiano (Indonesia).The following example uses these four ways to create a NumberFormatInfo object that reflects the formatting conventions of the Indonesian (Indonesia) culture. Indica inoltre se ogni oggetto è di sola lettura.It also indicates whether each object is read-only.

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 non associate ad alcun paeseInstantiating a NumberFormatInfo object for a neutral culture

Le impostazioni cultura non associate ad alcun paese rappresentano impostazioni cultura o una lingua indipendente da un paese/area geografica.A neutral culture represents a culture or language that is independent of a country/region. Si tratta in genere dell'elemento padre di una o più impostazioni cultura specifiche.It is typically the parent of one or more specific cultures. Ad esempio, fr rappresenta impostazioni cultura non associate ad alcun paese per la lingua francese e l'elemento padre delle impostazioni cultura fr-FR.For example, fr is a neutral culture for the French language and the parent of the fr-FR culture. Si crea un NumberFormatInfo oggetto che rappresenta le convenzioni di formattazione di impostazioni cultura non associate ad alcun paese nello stesso NumberFormatInfo modo in cui si crea un oggetto che rappresenta le convenzioni di formattazione di impostazioni cultura specifiche.You create a NumberFormatInfo object that represents the formatting conventions of a neutral culture in the same way that you create a NumberFormatInfo object that represents the formatting conventions of a specific culture.

Nota

In e versioni precedenti, il tentativo di recuperare un NumberFormatInfo oggetto che riflette le convenzioni di formattazione di impostazioni cultura non NotSupportedException associate ad alcun paese genera un'eccezione. .NET Framework 3.5.NET Framework 3.5In the .NET Framework 3.5.NET Framework 3.5 and earlier versions, trying to retrieve a NumberFormatInfo object that reflects the formatting conventions of a neutral culture throws a NotSupportedException exception.

Tuttavia, poiché è indipendente da un paese specifico, le impostazioni cultura non associate ad alcun paese sono prive di informazioni di formattazione specifiche delle impostazioni cultura.However, because it is independent of a specific country/region, a neutral culture lacks culture-specific formatting information. Anziché popolare l' NumberFormatInfo oggetto con valori generici, il .NET Framework restituisce un NumberFormatInfo oggetto che riflette le convenzioni di formattazione di impostazioni cultura specifiche figlio delle impostazioni cultura non associate ad alcun paese.Rather than populating the NumberFormatInfo object with generic values, the .NET Framework returns a NumberFormatInfo object that reflects the formatting conventions of a specific culture that is a child of the neutral culture. Ad esempio, l' NumberFormatInfo oggetto per le impostazioni cultura it neutre riflette le convenzioni di formattazione delle impostazioni cultura en- NumberFormatInfo US e l'oggetto per le impostazioni cultura fr riflette le convenzioni di formattazione delle impostazioni cultura fr-fr.For example, the NumberFormatInfo object for the neutral en culture reflects the formatting conventions of the en-US culture, and the NumberFormatInfo object for the fr culture reflects the formatting conventions of the fr-FR culture.

È possibile utilizzare codice simile al seguente per determinare le convenzioni di formattazione delle impostazioni cultura specifiche rappresentate dalle impostazioni cultura non associate ad alcun paese.You can use code like the following to determine which specific culture's formatting conventions each neutral culture represents.

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
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 Dynamic DataNumberFormatInfo and dynamic data

I dati specifici delle impostazioni cultura per la formattazione di valori numerici forniti dalla NumberFormatInfo classe sono dinamici, esattamente come i dati culturali forniti CultureInfo dalla classe.The culture-specific data for formatting numeric values provided by the NumberFormatInfo class is dynamic, just like the cultural data provided by the CultureInfo class. Non è consigliabile creare presupposti sulla stabilità dei valori per NumberFormatInfo gli oggetti associati a determinati CultureInfo oggetti.You should not make any assumptions about the stability of values for NumberFormatInfo objects that are associated with particular CultureInfo objects. Solo i dati forniti dalle impostazioni cultura invarianti e l' NumberFormatInfo oggetto associato sono stabili.Only the data provided by the invariant culture and its associated NumberFormatInfo object is stable. Altri dati possono variare tra le sessioni dell'applicazione o anche in una singola sessione per i motivi seguenti:Other data can change between application sessions, or even within a single session, for the following reasons:

  • Aggiornamenti del sistema.System updates. Le preferenze culturali quali il simbolo di valuta o i formati di valuta cambiano nel tempo.Cultural preferences such as the currency symbol or currency formats change over time. In questo caso, Windows Update include le modifiche apportate al valore della NumberFormatInfo proprietà per determinate impostazioni cultura.When this happens, Windows Update includes changes to the NumberFormatInfo property value for a particular culture.

  • Impostazioni cultura di sostituzione.Replacement cultures. La CultureAndRegionInfoBuilder classe può essere utilizzata per sostituire i dati di impostazioni cultura esistenti.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Propagazione delle modifiche ai valori delle proprietà.Cascading changes to property values. Una serie di proprietà correlate alle impostazioni cultura può cambiare in fase di esecuzione, che a sua volta NumberFormatInfo causa la modifica dei dati.A number of culture-related properties can change at run time, which, in turn, causes NumberFormatInfo data to change. Ad esempio, le impostazioni cultura correnti possono essere modificate a livello di codice o tramite l'azione dell'utente.For example, the current culture can be changed either programmatically or through user action. In tal caso, l' NumberFormatInfo oggetto restituito CurrentInfo dalla proprietà viene modificato in un oggetto associato alle impostazioni cultura correnti.When this happens, the NumberFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture.

  • Preferenze dell'utente.User preferences. Gli utenti dell'applicazione potrebbero eseguire l'override di alcuni valori associati alle impostazioni cultura correnti del sistema tramite le opzioni area e lingua nel pannello di controllo.Users of your application might override some of the values associated with the current system culture through the region and language options in Control Panel. Ad esempio, gli utenti possono scegliere un simbolo di valuta diverso o un simbolo separatore decimale diverso.For example, users might choose a different currency symbol or a different decimal separator symbol. Se la CultureInfo.UseUserOverride proprietà è impostata su true (valore predefinito) NumberFormatInfo , le proprietà dell'oggetto vengono recuperate anche dalle impostazioni utente.If the CultureInfo.UseUserOverride property is set to true (its default value), the properties of the NumberFormatInfo object are also retrieved from the user settings.

A partire da .NET Framework 2,0, tutte le proprietà sottoponibili a override NumberFormatInfo dell'utente di un oggetto vengono inizializzate quando viene creato l'oggetto.Starting with the .NET Framework 2.0, all user-overridable properties of a NumberFormatInfo object are initialized when the object is created. Esiste comunque la possibilità di incoerenza, poiché né la creazione di oggetti né il processo di override dell'utente sono atomiche e i valori rilevanti possono cambiare durante la creazione dell'oggetto.There is still a possibility of inconsistency, because neither object creation nor the user override process is atomic, and the relevant values may change during object creation. Tuttavia, queste incoerenze dovrebbero essere estremamente rare.However, these inconsistencies should be extremely rare.

È possibile controllare se gli override degli utenti vengono NumberFormatInfo riflessi negli oggetti che rappresentano le stesse impostazioni cultura delle impostazioni cultura del thread corrente.You can control whether user overrides are reflected in NumberFormatInfo objects that represent the same culture as the current thread culture. Nella tabella seguente sono elencati i modi in cui NumberFormatInfo è possibile recuperare un oggetto e viene indicato se l'oggetto risultante riflette le sostituzioni utente.The following table lists the ways in which a NumberFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Origine dell'oggetto CultureInfo e NumberFormatInfoSource of CultureInfo and NumberFormatInfo object Riflette le sostituzioni utenteReflects user overrides
ProprietàCultureInfo.CurrentCulture.NumberFormatCultureInfo.CurrentCulture.NumberFormat property Yes
ProprietàNumberFormatInfo.CurrentInfoNumberFormatInfo.CurrentInfo property Yes
Metodo CultureInfo.CreateSpecificCultureCultureInfo.CreateSpecificCulture method Yes
Metodo CultureInfo.GetCultureInfoCultureInfo.GetCultureInfo method NoNo
Costruttore CultureInfo(String)CultureInfo(String) constructor Yes
Costruttore CultureInfo.CultureInfo(String, Boolean)CultureInfo.CultureInfo(String, Boolean) constructor Dipende dal valore del useUserOverride parametroDepends on value of useUserOverride parameter

A meno che non esista un motivo valido per eseguire questa operazione, è necessario rispettare le sostituzioni utente NumberFormatInfo quando si usa l'oggetto nelle applicazioni client per formattare e analizzare l'input dell'utente o per visualizzare dati numerici.Unless there is a compelling reason to do otherwise, you should respect user overrides when you use the NumberFormatInfo object in client applications to format and parse user input or to display numeric data. Per le applicazioni server o le applicazioni automatiche, è consigliabile non rispettare le sostituzioni utente.For server applications or unattended applications, you should not respect user overrides. Tuttavia, se si utilizza l' NumberFormatInfo oggetto in modo esplicito o implicito per salvare in modo permanente i dati numerici in formato stringa, è necessario utilizzare un NumberFormatInfo oggetto che rifletta le convenzioni di formattazione delle impostazioni cultura invarianti oppure specificare una stringa di formato numerico personalizzata utilizzata indipendentemente dalle impostazioni cultura.However, if you are using the NumberFormatInfo object either explicitly or implicitly to persist numeric data in string form, you should either use a NumberFormatInfo object that reflects the formatting conventions of the invariant culture, or you should specify a custom numeric format string that you use regardless of culture.

IFormatProvider, NumberFormatInfo e formattazione numericaIFormatProvider, NumberFormatInfo, and numeric formatting

Un NumberFormatInfo oggetto viene utilizzato in modo implicito o esplicito in tutte le operazioni di formattazione numerica.A NumberFormatInfo object is used implicitly or explicitly in all numeric formatting operations. Sono incluse le chiamate ai metodi seguenti:These include calls to the following methods:

Tutte le operazioni di formattazione numerica usano IFormatProvider un'implementazione di.All numeric formatting operations make use of an IFormatProvider implementation. L' IFormatProvider interfaccia include un solo metodo, GetFormat(Type).The IFormatProvider interface includes a single method, GetFormat(Type). Si tratta di un metodo di callback a cui Type viene passato un oggetto che rappresenta il tipo necessario per fornire informazioni sulla formattazione.This is a callback method that is passed a Type object that represents the type needed to provide formatting information. Il metodo è responsabile della restituzione di un'istanza di quel tipo nullo, se non è in grado di fornire un'istanza del tipo.The method is responsible for returning either an instance of that type or null, if it cannot provide an instance of the type. Il .NET Framework fornisce due IFormatProvider implementazioni per la formattazione dei numeri:The .NET Framework provides two IFormatProvider implementations for formatting numbers:

Se un' IFormatProvider implementazione non viene fornita in modo esplicito a un metodo di CultureInfo formattazione, viene utilizzato CultureInfo.CurrentCulture un oggetto restituito dalla proprietà che rappresenta le impostazioni cultura del thread corrente.If an IFormatProvider implementation is not provided to a formatting method explicitly, a CultureInfo object returned by the CultureInfo.CurrentCulture property that represents the current thread culture is used.

Nell'esempio seguente viene illustrata la relazione tra IFormatProvider l'interfaccia e NumberFormatInfo la classe nelle operazioni di formattazione definendo un' IFormatProvider implementazione personalizzata.The following example illustrates the relationship between the IFormatProvider interface and the NumberFormatInfo class in formatting operations by defining a custom IFormatProvider implementation. Il GetFormat metodo Visualizza il nome del tipo dell'oggetto richiesto dall'operazione di formattazione.Its GetFormat method displays the type name of the object requested by the formatting operation. Se l'interfaccia richiede un NumberFormatInfo oggetto, questo metodo fornisce l' NumberFormatInfo oggetto per le impostazioni cultura del thread corrente.If the interface is requesting a NumberFormatInfo object, this method provides the NumberFormatInfo object for the current thread culture. Come illustrato nell'output dell'esempio Decimal.ToString(IFormatProvider) , il metodo richiede un NumberFormatInfo oggetto per fornire informazioni sulla formattazione, mentre le String.Format(IFormatProvider, String, Object[]) richieste NumberFormatInfo e DateTimeFormatInfo gli oggetti del metodo, nonché ICustomFormatter un implementazione.As the output from the example shows, the Decimal.ToString(IFormatProvider) method requests a NumberFormatInfo object to provide formatting information, whereas the String.Format(IFormatProvider, String, Object[]) method requests NumberFormatInfo and DateTimeFormatInfo objects as well as an ICustomFormatter implementation.

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' IFormatProvider implementazione non viene specificata in modo esplicito in una chiamata al metodo di formattazione numerica CultureInfo.CurrentCulture.GetFormat , il metodo chiama il NumberFormatInfo metodo, che restituisce l'oggetto che corrisponde alle impostazioni cultura del thread corrente.If an IFormatProvider implementation is not explicitly provided in a numeric formatting method call, the method calls the CultureInfo.CurrentCulture.GetFormat method, which returns the NumberFormatInfo object that corresponds to the current thread culture.

Stringhe di formato e proprietà NumberFormatInfoFormat strings and NumberFormatInfo properties

Ogni operazione di formattazione usa una stringa di formato numerico standard o personalizzata per produrre una stringa di risultato da un numero.Every formatting operation uses either a standard or a custom numeric format string to produce a result string from a number. In alcuni casi, l'uso di una stringa di formato per produrre una stringa di risultato è esplicito, come nell'esempio seguente.In some cases, the use of a format string to produce a result string is explicit, as in the following example. Questo codice chiama il Decimal.ToString(IFormatProvider) metodo per convertire un Decimal valore in una serie di rappresentazioni di stringa diverse usando le convenzioni di formattazione delle impostazioni cultura en-US.This code calls the Decimal.ToString(IFormatProvider) method to convert a Decimal value to a number of different string representations by using the formatting conventions of the en-US culture.

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.In other cases, the use of a format string is implicit. Ad esempio, nelle chiamate al metodo predefinite o senza parametri Decimal.ToString() , il valore Decimal dell'istanza viene formattato usando l'identificatore di formato generale ("G") e le convenzioni delle impostazioni cultura correnti, che in questo caso è il impostazioni cultura en-US.For example, in the following method calls to the default or parameterless Decimal.ToString() method, the value of the Decimal instance is formatted by using the general ("G") format specifier and the conventions of the current culture, which in this case is the en-US culture.

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.Each standard numeric format string uses one or more NumberFormatInfo properties to determine the pattern or the symbols used in the result string. Analogamente, ogni identificatore di formato numerico personalizzato, ad eccezione di "0" e "#", inserisce i simboli nella NumberFormatInfo stringa di risultato definita dalle proprietà.Similarly, each custom numeric format specifier except "0" and "#" insert symbols in the result string that are defined by NumberFormatInfo properties. Nella tabella seguente sono elencati gli identificatori di formato numerico standard e personalizzati e NumberFormatInfo le relative proprietà associate.The following table lists the standard and custom numeric format specifiers and their associated NumberFormatInfo properties. Per modificare l'aspetto della stringa di risultato per determinate impostazioni cultura, vedere la sezione modifica delle proprietà di NumberFormatInfo .To change the appearance of the result string for a particular culture, see the Modifying NumberFormatInfo properties section. Per informazioni dettagliate sull'uso di questi identificatori di formato, vedere stringhe di formato numerico standard e stringhe di formato numerico personalizzate.For details about the use of these format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

Identificatore di formatoFormat specifier Proprietà associateAssociated properties
"C" o "c" (identificatore di formato valuta)"C" or "c" (currency format specifier) CurrencyDecimalDigits, per definire il numero predefinito di cifre frazionarie.CurrencyDecimalDigits, to define the default number of fractional digits.

CurrencyDecimalSeparator, per definire il simbolo di separatore decimale.CurrencyDecimalSeparator, to define the decimal separator symbol.

CurrencyGroupSeparator, per definire il separatore di gruppo o di migliaia.CurrencyGroupSeparator, to define the group or thousands separator.

CurrencyGroupSizes, per definire le dimensioni dei gruppi integrali.CurrencyGroupSizes, to define the sizes of integral groups.

CurrencyNegativePattern, per definire il modello di valori di valuta negativi.CurrencyNegativePattern, to define the pattern of negative currency values.

CurrencyPositivePattern, per definire il modello di valori di valuta positivi.CurrencyPositivePattern, to define the pattern of positive currency values.

CurrencySymbol, per definire il simbolo di valuta.CurrencySymbol, to define the currency symbol.

NegativeSign, per definire il simbolo di segno negativo.NegativeSign, to define the negative sign symbol.
"D" o "d" (identificatore di formato decimale)"D" or "d" (decimal format specifier) NegativeSign, per definire il simbolo di segno negativo.NegativeSign, to define the negative sign symbol.
"E" o "e" (identificatore di formato esponenziale o scientifico)"E" or "e" (exponential or scientific format specifier) NegativeSign, per definire il simbolo di segno negativo in mantissa ed esponente.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

NumberDecimalSeparator, per definire il simbolo di separatore decimale.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, per definire il simbolo di segno positivo nell'esponente.PositiveSign, to define the positive sign symbol in the exponent.
"F" o "f" (identificatore di formato a virgola fissa)"F" or "f" (fixed-point format specifier) NegativeSign, per definire il simbolo di segno negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, per definire il numero predefinito di cifre frazionarie.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, per definire il simbolo di separatore decimale.NumberDecimalSeparator, to define the decimal separator symbol.
"G" o "g" (identificatore di formato generale)"G" or "g" (general format specifier) NegativeSign, per definire il simbolo di segno negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, per definire il simbolo di separatore decimale.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, per definire il simbolo di segno positivo per le stringhe di risultato in formato esponenziale.PositiveSign, to define the positive sign symbol for result strings in exponential format.
"N" o "n" (identificatore di formato numerico)"N" or "n" (number format specifier) NegativeSign, per definire il simbolo di segno negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, per definire il numero predefinito di cifre frazionarie.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, per definire il simbolo di separatore decimale.NumberDecimalSeparator, to define the decimal separator symbol.

NumberGroupSeparator, per definire il simbolo del separatore di gruppi (migliaia).NumberGroupSeparator, to define the group separator (thousands) symbol.

NumberGroupSizes, per definire il numero di cifre integrali in un gruppo.NumberGroupSizes, to define the number of integral digits in a group.

NumberNegativePattern, per definire il formato dei valori negativi.NumberNegativePattern, to define the format of negative values.
"P" o "p" (identificatore di formato percentuale)"P" or "p" (percent format specifier) NegativeSign, per definire il simbolo di segno negativo.NegativeSign, to define the negative sign symbol.

PercentDecimalDigits, per definire il numero predefinito di cifre frazionarie.PercentDecimalDigits, to define the default number of fractional digits.

PercentDecimalSeparator, per definire il simbolo di separatore decimale.PercentDecimalSeparator, to define the decimal separator symbol.

PercentGroupSeparator, per definire il simbolo del separatore di gruppi.PercentGroupSeparator, to define the group separator symbol.

PercentGroupSizes, per definire il numero di cifre integrali in un gruppo.PercentGroupSizes, to define the number of integral digits in a group.

PercentNegativePattern, per definire la posizione del simbolo di percentuale e il simbolo negativo per i valori negativi.PercentNegativePattern, to define the placement of the percent symbol and the negative symbol for negative values.

PercentPositivePattern, per definire la posizione del simbolo di percentuale per i valori positivi.PercentPositivePattern, to define the placement of the percent symbol for positive values.

PercentSymbol, per definire il simbolo di percentuale.PercentSymbol, to define the percent symbol.
"R" o "r" (identificatore di formato round trip)"R" or "r" (round-trip format specifier) NegativeSign, per definire il simbolo di segno negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, per definire il simbolo di separatore decimale.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, per definire il simbolo di segno positivo in un esponente.PositiveSign, to define the positive sign symbol in an exponent.
"X" o "x" (identificatore di formato esadecimale)"X" or "x" (hexadecimal format specifier) Nessuno.None.
"." (identificatore di formato personalizzato del separatore decimale)"." (decimal point custom format specifier) NumberDecimalSeparator, per definire il simbolo di separatore decimale.NumberDecimalSeparator, to define the decimal separator symbol.
"," (identificatore di formato personalizzato del separatore di gruppi)"," (group separator custom format specifier) NumberGroupSeparator, per definire il simbolo del separatore di gruppi (migliaia).NumberGroupSeparator, to define the group (thousands) separator symbol.
"%" (identificatore di formato personalizzato del segnaposto percentuale)"%" (percentage placeholder custom format specifier) PercentSymbol, per definire il simbolo di percentuale.PercentSymbol, to define the percent symbol.
"‰" (identificatore di formato personalizzato per mille segnaposto)"‰" (per mille placeholder custom format specifier) PerMilleSymbol, per definire il simbolo per mille.PerMilleSymbol, to define the per mille symbol.
"E" (identificatore di formato personalizzato per la notazione esponenziale)"E" (exponential notation custom format specifier) NegativeSign, per definire il simbolo di segno negativo in mantissa ed esponente.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

PositiveSign, per definire il simbolo di segno positivo nell'esponente.PositiveSign, to define the positive sign symbol in the exponent.

Si noti che NumberFormatInfo la classe include NativeDigits una proprietà che specifica le cifre in base 10 utilizzate da impostazioni cultura specifiche.Note that the NumberFormatInfo class includes a NativeDigits property that specifies the base 10 digits used by a specific culture. Tuttavia, la proprietà non viene utilizzata nelle operazioni di formattazione. nella stringa di risultato vengono usate solo le cifre latine di base da 0 (U + 0030) a 9 (U + 0039).However, the property is not used in formatting operations; only the Basic Latin digits 0 (U+0030) through 9 (U+0039) are used in the result string. Inoltre Single , per i valori Double e di NaN, PositiveInfinitye NegativeInfinity, la stringa di risultato è costituita esclusivamente dai simboli definiti dalle NaNSymbolproprietà PositiveInfinitySymbol, e NegativeInfinitySymbol . rispettivamente.In addition, for Single and Double values of NaN, PositiveInfinity, and NegativeInfinity, the result string consists exclusively of the symbols defined by the NaNSymbol, PositiveInfinitySymbol, and NegativeInfinitySymbol properties, respectively.

Modifica delle proprietà di NumberFormatInfoModifying NumberFormatInfo properties

È possibile modificare le proprietà di un NumberFormatInfo oggetto per personalizzare la stringa di risultato prodotta in un'operazione di formattazione numerica.You can modify the properties of a NumberFormatInfo object to customize the result string produced in a numeric formatting operation. Per eseguire questa operazione:To do this:

  1. Creare una copia di lettura/scrittura di NumberFormatInfo un oggetto di cui si desidera modificare le convenzioni di formattazione.Create a read/write copy of a NumberFormatInfo object whose formatting conventions you want to modify. Per ulteriori informazioni, vedere la sezione Creazione di un' istanza di un oggetto NumberFormatInfo .For more information, see the Instantiating a NumberFormatInfo object section.

  2. Modificare la proprietà o le proprietà utilizzate per produrre la stringa di risultato desiderata.Modify the property or properties that are used to produce the desired result string. Per informazioni sul modo in cui i NumberFormatInfo metodi di formattazione utilizzano le proprietà per definire le stringhe di risultato, vedere la sezione stringhe di formato e proprietà NumberFormatInfo .For information about how formatting methods use NumberFormatInfo properties to define result strings, see the Format strings and NumberFormatInfo properties section.

  3. Usare l'oggetto NumberFormatInfo personalizzato IFormatProvider come argomento nelle chiamate ai metodi di formattazione.Use the custom NumberFormatInfo object as the IFormatProvider argument in calls to formatting methods.

Nota

Anziché modificare dinamicamente i valori delle proprietà di una lingua ogni volta che viene avviata un'applicazione, è CultureAndRegionInfoBuilder possibile usare la classe per definire impostazioni cultura personalizzate (impostazioni cultura che hanno un nome univoco e che integrano le impostazioni cultura esistenti) o una sostituzione impostazioni cultura (uno usato al posto di impostazioni cultura specifiche).Instead of dynamically modifying a culture's property values each time an application is started, you can use the CultureAndRegionInfoBuilder class to define either a custom culture (a culture that has a unique name and that supplements existing cultures) or a replacement culture (one that is used instead of a specific culture).

Nelle sezioni seguenti vengono forniti alcuni esempi.The following sections provide some examples.

Modifica del simbolo e del modello di valutaModifying the currency symbol and pattern

Nell'esempio seguente viene modificato NumberFormatInfo un oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura en-US.The following example modifies a NumberFormatInfo object that represents the formatting conventions of the en-US culture. Assegna il simbolo di valuta ISO-4217 alla CurrencySymbol proprietà e definisce un modello per i valori di valuta costituito dal simbolo di valuta seguito da uno spazio e un valore numerico.It assigns the ISO-4217 currency symbol to the CurrencySymbol property and defines a pattern for currency values that consists of the currency symbol followed by a space and a numeric value.

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 nazionaleFormatting a national identification number

Molti numeri di identificazione nazionali sono costituiti esclusivamente da cifre, quindi possono essere facilmente formattati modificando NumberFormatInfo le proprietà di un oggetto.Many national identification numbers consist exclusively of digits and so can easily be formatted by modifying the properties of a NumberFormatInfo object. Ad esempio, un numero di previdenza sociale nel Stati Uniti è costituito da 9 cifre XXX-XX-XXXXdisposte come segue:.For example, a social security number in the United States consists of 9 digits arranged as follows: XXX-XX-XXXX. Nell'esempio seguente si presuppone che i numeri di previdenza sociale vengano archiviati come valori integer e li formati in modo appropriato.The following example assumes that social security numbers are stored as integer values and formats them appropriately.

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 numericheParsing numeric strings

L'analisi comporta la conversione della rappresentazione di stringa di un numero in un numero.Parsing involves converting the string representation of a number to a number. Ogni tipo numerico nell'.NET Framework include due metodi di analisi di overload: Parse e. TryParseEach numeric type in the .NET Framework includes two overloaded parsing methods: Parse and TryParse. Il Parse metodo converte una stringa in un numero e genera un'eccezione se la conversione non riesce.The Parse method converts a string to a number and throws an exception if the conversion fails. Il TryParse metodo converte una stringa in un numero, assegna il numero a un out argomento e restituisce un Boolean valore che indica se la conversione è stata eseguita correttamente.The TryParse method converts a string to a number, assigns the number to an out argument, and returns a Boolean value that indicates whether the conversion succeeded.

I metodi di analisi usano in modo implicito o esplicito un NumberStyles valore di enumerazione per determinare quali elementi di stile, ad esempio i separatori di gruppo, un separatore decimale o un simbolo di valuta, possono essere presenti in una stringa se l'operazione di analisi ha esito positivo.The parsing methods implicitly or explicitly use a NumberStyles enumeration value to determine what style elements (such as group separators, a decimal separator, or a currency symbol) can be present in a string if the parsing operation is to succeed. Se nella chiamata al metodo non viene specificato alcun NumberStyles Float AllowThousands valore, il valore predefinito è un valore che include i flag e, che specificano che la stringa analizzata può includere i simboli di gruppo, un separatore decimale, un segno negativo, NumberStyles e spazi vuoti, oppure possono essere la rappresentazione di stringa di un numero in notazione esponenziale.If a NumberStyles value is not provided in the method call, the default is a NumberStyles value that includes the Float and AllowThousands flags, which specifies that the parsed string can include group symbols, a decimal separator, a negative sign, and white-space characters, or it can be the string representation of a number in exponential notation.

Anche i metodi di analisi usano in modo implicito o esplicito un NumberFormatInfo oggetto che definisce i simboli e i modelli specifici che possono verificarsi nella stringa da analizzare.The parsing methods also implicitly or explicitly use a NumberFormatInfo object that defines the specific symbols and patterns that can occur in the string to be parsed. Se non NumberFormatInfo viene specificato un oggetto, il valore predefinito NumberFormatInfo è per le impostazioni cultura del thread corrente.If a NumberFormatInfo object is not provided, the default is the NumberFormatInfo for the current thread culture. Per ulteriori informazioni sull'analisi, vedere i singoli metodi di analisi, ad esempio Int16.Parse(String) Int64.Parse(String, IFormatProvider), Int32.Parse(String, NumberStyles),, Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double)e BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).For more information about parsing, see the individual parsing methods, such as Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double), and BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).

Nell'esempio seguente viene illustrata la natura con distinzione delle impostazioni cultura delle stringhe di analisi.The following example illustrates the culture-sensitive nature of parsing strings. Tenta di analizzare una stringa che include separatori di migliaia usando le convenzioni delle impostazioni cultura en-US, fr-FR e invariante.It tries to parse a string that include thousands separators by using the conventions of the en-US, fr-FR, and invariant cultures. Una stringa che include la virgola come separatore di gruppi e il punto come separatore decimale non è in grado di analizzare nelle impostazioni cultura fr-FR e una stringa con spazi vuoti come separatore di gruppi e una virgola come separatore decimale non riesce ad analizzare nelle impostazioni cultura en-US e invariant.A string that includes the comma as a group separator and the period as a decimal separator fails to parse in the fr-FR culture, and a string with white space as a group separator and a comma as a decimal separator fails to parse in the en-US and invariant cultures.

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:Parsing generally occurs in two contexts:

  • Come operazione progettata per convertire l'input dell'utente in un valore numerico.As an operation that is designed to convert user input into a numeric value.

  • Come operazione progettata per eseguire il round trip di un valore numerico; ovvero per deserializzare un valore numerico precedentemente serializzato come stringa.As an operation that is designed to round-trip a numeric value; that is, to deserialize a numeric value that was previously serialized as a string.

Le sezioni seguenti illustrano in modo più dettagliato queste due operazioni.The following sections discuss these two operations in greater detail.

Analisi delle stringhe utenteParsing user strings

Quando si esegue l'analisi di stringhe numeriche input da parte dell'utente, è sempre necessario NumberFormatInfo creare un'istanza di un oggetto che riflette le impostazioni cultura dell'utente.When you are parsing numeric strings input by the user, you should always instantiate a NumberFormatInfo object that reflects the user's cultural settings. Per informazioni su come creare un'istanza di NumberFormatInfo un oggetto che riflette le personalizzazioni degli utenti, vedere la sezione NumberFormatInfo e Dynamic Data .For information about how to instantiate a NumberFormatInfo object that reflects user customizations, see the NumberFormatInfo and dynamic data section.

Nell'esempio seguente viene illustrata la differenza tra un'operazione di analisi che riflette le impostazioni cultura dell'utente e una che non lo è.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. In questo caso, le impostazioni cultura predefinite del sistema sono en-US, ma l'utente ha definito "," come simbolo decimale e "." come separatore di gruppi nel pannello di controllo, area e lingua.In this case, the default system culture is en-US, but the user has defined "," as the decimal symbol and "." as the group separator in Control Panel, Region and Language. In genere, questi simboli vengono invertiti nelle impostazioni cultura en-US predefinite.Ordinarily, these symbols are reversed in the default en-US culture. Quando l'utente immette una stringa che riflette le impostazioni utente e la stringa viene analizzata da un NumberFormatInfo oggetto che riflette anche le impostazioni utente (sostituzioni), l'operazione di analisi restituisce un risultato corretto.When the user enters a string that reflects user settings, and the string is parsed by a NumberFormatInfo object that also reflects user settings (overrides), the parsing operation returns a correct result. Tuttavia, quando la stringa viene analizzata da un NumberFormatInfo oggetto che riflette le impostazioni cultura en-US standard, il simbolo di virgola per un separatore di gruppo viene erroneo e viene restituito un risultato errato.However, when the string is parsed by a NumberFormatInfo object that reflects standard en-US cultural settings, it mistakes the comma symbol for a group separator and returns an incorrect result.

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 numericiSerializing and deserializing numeric data

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.When numeric data is serialized in string format and later deserialized and parsed, the strings should be generated and parsed by using the conventions of the invariant culture. Le operazioni di formattazione e analisi non devono mai riflettere le convenzioni di impostazioni cultura specifiche.The formatting and parsing operations should never reflect the conventions of a specific culture. Se vengono utilizzate 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.If culture-specific settings are used, the portability of the data is strictly limited; it can be successfully deserialized only on a thread whose culture-specific settings are identical to those of the thread on which it was serialized. In alcuni casi, ciò significa che i dati non possono anche essere deserializzati correttamente nello stesso sistema in cui è stato serializzato.In some cases, this means that the data cannot even be successfully deserialized on the same system on which it was serialized.

Nell'esempio seguente viene illustrato ciò che può verificarsi quando questo principio viene violato.The following example illustrates what can happen when this principle is violated. I valori a virgola mobile in una matrice vengono convertiti in stringhe quando il thread corrente usa le impostazioni specifiche delle impostazioni cultura delle impostazioni cultura en-US.Floating-point values in an array are converted to strings when the current thread uses the culture-specific settings of the en-US culture. I dati vengono quindi analizzati da un thread che usa le impostazioni specifiche delle impostazioni cultura delle impostazioni cultura en-GB.The data is then parsed by a thread that uses the culture-specific settings of the en-GB culture. In questo caso, anche se ogni operazione di analisi ha esito positivo, i dati non vengono completati correttamente e si verifica un danneggiamento dei dati.In this case, although each parsing operation succeeds, the data does not round-trip successfully and data corruption occurs. In altri casi, un'operazione di analisi potrebbe non riuscire FormatException e potrebbe essere generata un'eccezione.In other cases, a parsing operation could fail and a FormatException exception could be thrown.

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

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      PersistData();
      
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      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()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      PersistData()
      
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
      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() NumberFormatInfo() NumberFormatInfo() NumberFormatInfo()

Inizializza una nuova istanza modificabile della classe NumberFormatInfo che è indipendente dalle impostazioni cultura associate alla lingua inglese.Initializes a new writable instance of the NumberFormatInfo class that is culture-independent (invariant).

Proprietà

CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits

Ottiene o imposta il numero di posizioni decimali da usare nei valori di valuta.Gets or sets the number of decimal places to use in currency values.

CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator

Ottiene o imposta la stringa da usare come separatore decimale nei valori di valuta.Gets or sets the string to use as the decimal separator in currency values.

CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator

Ottiene o imposta la stringa di separazione dei gruppi di cifre che si trovano a sinistra del separatore decimale nei valori di valuta.Gets or sets the string that separates groups of digits to the left of the decimal in currency values.

CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes

Ottiene o imposta il numero di cifre in ciascun gruppo che si trova a sinistra del separatore decimale nei valori di valuta.Gets or sets the number of digits in each group to the left of the decimal in currency values.

CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern

Ottiene o imposta il modello di formato per i valori di valuta negativi.Gets or sets the format pattern for negative currency values.

CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern

Ottiene o imposta il modello di formato per i valori di valuta positivi.Gets or sets the format pattern for positive currency values.

CurrencySymbol CurrencySymbol CurrencySymbol CurrencySymbol

Ottiene o imposta la stringa da usare come simbolo di valuta.Gets or sets the string to use as the currency symbol.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Ottiene un oggetto NumberFormatInfo di sola lettura che formatta i valori in base alle impostazioni cultura correnti.Gets a read-only NumberFormatInfo that formats values based on the current culture.

DigitSubstitution DigitSubstitution DigitSubstitution DigitSubstitution

Ottiene o imposta un valore che specifica come viene visualizzata la forma di una cifra dall'interfaccia utente grafica.Gets or sets a value that specifies how the graphical user interface displays the shape of a digit.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Ottiene un oggetto NumberFormatInfo di sola lettura indipendente dalle impostazioni cultura (invariante).Gets a read-only NumberFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Ottiene un valore che indica se l'oggetto NumberFormatInfo è di sola lettura.Gets a value that indicates whether this NumberFormatInfo object is read-only.

NaNSymbol NaNSymbol NaNSymbol NaNSymbol

Ottiene o imposta la stringa che rappresenta il valore IEEE NaN (Not a Number).Gets or sets the string that represents the IEEE NaN (not a number) value.

NativeDigits NativeDigits NativeDigits NativeDigits

Ottiene o imposta una matrice di stringhe di cifre native equivalenti ai numeri europei da 0 a 9.Gets or sets a string array of native digits equivalent to the Western digits 0 through 9.

NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol

Ottiene o imposta la stringa che rappresenta il valore di infinito negativo.Gets or sets the string that represents negative infinity.

NegativeSign NegativeSign NegativeSign NegativeSign

Ottiene o imposta la stringa che indica che il numero associato è negativo.Gets or sets the string that denotes that the associated number is negative.

NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits

Ottiene o imposta il numero di posizioni decimali da usare nei valori numerici.Gets or sets the number of decimal places to use in numeric values.

NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator

Ottiene o imposta la stringa da usare come separatore decimale nei valori numerici.Gets or sets the string to use as the decimal separator in numeric values.

NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator

Ottiene o imposta la stringa di separazione dei gruppi di cifre che si trovano a sinistra del separatore decimale nei valori numerici.Gets or sets the string that separates groups of digits to the left of the decimal in numeric values.

NumberGroupSizes NumberGroupSizes NumberGroupSizes NumberGroupSizes

Ottiene o imposta il numero di cifre in ciascun gruppo che si trova a sinistra del separatore decimale nei valori numerici.Gets or sets the number of digits in each group to the left of the decimal in numeric values.

NumberNegativePattern NumberNegativePattern NumberNegativePattern NumberNegativePattern

Ottiene o imposta il modello di formato per i valori numerici negativi.Gets or sets the format pattern for negative numeric values.

PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits

Ottiene o imposta il numero di posizioni decimali da usare nei valori percentuali.Gets or sets the number of decimal places to use in percent values.

PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator

Ottiene o imposta la stringa da usare come separatore decimale nei valori percentuali.Gets or sets the string to use as the decimal separator in percent values.

PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator

Ottiene o imposta la stringa di separazione dei gruppi di cifre che si trovano a sinistra del separatore decimale nei valori percentuali.Gets or sets the string that separates groups of digits to the left of the decimal in percent values.

PercentGroupSizes PercentGroupSizes PercentGroupSizes PercentGroupSizes

Ottiene o imposta il numero di cifre in ciascun gruppo che si trova a sinistra del separatore decimale nei valori percentuali.Gets or sets the number of digits in each group to the left of the decimal in percent values.

PercentNegativePattern PercentNegativePattern PercentNegativePattern PercentNegativePattern

Ottiene o imposta il modello di formato per i valori percentuali negativi.Gets or sets the format pattern for negative percent values.

PercentPositivePattern PercentPositivePattern PercentPositivePattern PercentPositivePattern

Ottiene o imposta il modello di formato per i valori percentuali positivi.Gets or sets the format pattern for positive percent values.

PercentSymbol PercentSymbol PercentSymbol PercentSymbol

Ottiene o imposta la stringa da usare come simbolo di percentuale.Gets or sets the string to use as the percent symbol.

PerMilleSymbol PerMilleSymbol PerMilleSymbol PerMilleSymbol

Ottiene o imposta la stringa da usare come simbolo di per mille.Gets or sets the string to use as the per mille symbol.

PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol

Ottiene o imposta la stringa che rappresenta il valore di infinito positivo.Gets or sets the string that represents positive infinity.

PositiveSign PositiveSign PositiveSign PositiveSign

Ottiene o imposta la stringa che indica che il numero associato è positivo.Gets or sets the string that denotes that the associated number is positive.

Metodi

Clone() Clone() Clone() Clone()

Crea una copia superficiale dell'oggetto NumberFormatInfo.Creates a shallow copy of the NumberFormatInfo object.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetFormat(Type) GetFormat(Type) GetFormat(Type) GetFormat(Type)

Ottiene un oggetto del tipo specificato che fornisce un servizio di formattazione dei numeri.Gets an object of the specified type that provides a number formatting service.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider)

Ottiene l'oggetto NumberFormatInfo associato all'oggetto IFormatProvider specificato.Gets the NumberFormatInfo associated with the specified IFormatProvider.

GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
ReadOnly(NumberFormatInfo) ReadOnly(NumberFormatInfo) ReadOnly(NumberFormatInfo) ReadOnly(NumberFormatInfo)

Restituisce un wrapper NumberFormatInfo di sola lettura.Returns a read-only NumberFormatInfo wrapper.

ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Si applica a

Vedi anche