NumberFormatInfo NumberFormatInfo NumberFormatInfo NumberFormatInfo Class

Definição

Fornece informações específicas da cultura para formatação e análise de valores numéricos.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
Herança
NumberFormatInfoNumberFormatInfoNumberFormatInfoNumberFormatInfo
Atributos
Implementações

Exemplos

O exemplo a seguir mostra como recuperar um NumberFormatInfo objeto para um correspondente CultureInfo de objeto e usar o objeto recuperado para o número de consultas, informações de formatação para a cultura específica.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 '$'

Comentários

O NumberFormatInfo classe contém informações específicas de cultura que são usadas quando você formatar e analisar os valores numéricos.The NumberFormatInfo class contains culture-specific information that is used when you format and parse numeric values. Essas informações incluem o símbolo de moeda, o símbolo decimal, o símbolo de separador de grupo e os símbolos em busca de sinais positivos e negativos.This information includes the currency symbol, the decimal symbol, the group separator symbol, and the symbols for positive and negative signs.

Criando uma instância de um objeto NumberFormatInfoInstantiating a NumberFormatInfo object

Você pode instanciar um NumberFormatInfo objeto que representa as convenções de formatação da cultura atual, a cultura invariável, uma cultura específica ou uma cultura neutra.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.

Criando uma instância de um objeto NumberFormatInfo para a cultura atualInstantiating a NumberFormatInfo object for the current culture

Você pode instanciar um NumberFormatInfo objeto para a cultura do thread atual em qualquer uma das seguintes maneiras.You can instantiate a NumberFormatInfo object for the current thread culture in any of the following ways. Em cada caso, retornado NumberFormatInfo objeto é somente leitura.In each case, the returned NumberFormatInfo object is read-only.

O exemplo a seguir usa esses três maneiras de criar NumberFormatInfo objetos que representam as convenções de formatação da cultura atual.The following example uses these three ways to create NumberFormatInfo objects that represent the formatting conventions of the current culture. Ele também recupera o valor da IsReadOnly propriedade para ilustrar o que cada objeto é somente leitura.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

Você pode criar um gravável NumberFormatInfo objeto que representa as convenções da cultura do thread atual em qualquer uma das seguintes maneiras:You can create a writable NumberFormatInfo object that represents the conventions of the current thread culture in any of the following ways:

O exemplo a seguir ilustra essas duas maneiras de criar uma instância uma NumberFormatInfo do objeto e exibe o valor da sua IsReadOnly propriedade para ilustrar o objeto não é somente leitura.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

Observe que o sistema operacional Windows permite que o usuário substituir algumas da NumberFormatInfo valores de propriedade usados na formatação numérica e análise de operações por meio de região e idioma item no painel de controle.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. Por exemplo, um usuário cuja cultura é inglês (Estados Unidos) pode optar por exibir valores de moeda como US 1.1 em vez do padrão de US $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. O NumberFormatInfo objetos recuperados das maneiras discutidos anteriormente refletem essas substituições do usuário.The NumberFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Se isso for indesejável, você pode criar uma NumberFormatInfo objeto que não reflita as substituições do usuário (e que também é leitura/gravação em vez de somente leitura) chamando o CultureInfo.CultureInfo(String, Boolean) construtor e fornecendo um valor de false para o useUserOverride argumento.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. O exemplo a seguir fornece uma ilustração de um sistema cuja cultura atual seja inglês (Estados Unidos) e cujo símbolo de moeda foi alterado do padrão de $ 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 o CultureInfo.UseUserOverride estiver definida como true, as propriedades CultureInfo.DateTimeFormat, CultureInfo.NumberFormat, e CultureInfo.TextInfo também são recuperadas das configurações de usuário.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 as configurações do usuário são incompatíveis com a cultura associada com o CultureInfo objeto (por exemplo, se o calendário selecionado não é um dos calendários listados pelo OptionalCalendars propriedade), os resultados dos métodos e os valores das propriedades são indefinido.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.

Criando uma instância de um objeto NumberFormatInfo para a cultura invariávelInstantiating a NumberFormatInfo object for the invariant culture

A cultura invariável representa uma cultura insensível.The invariant culture represents a culture that is culture-insensitive. Ele se baseia no idioma inglês, mas não em qualquer falante de inglês país/região específico.It is based on the English language but not on any specific English-speaking country/region. Embora os dados de culturas específicas podem ser dinâmicos e podem ser alterado para refletir as novas convenções culturais ou as preferências do usuário, não alteram os dados da cultura invariável.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. Um NumberFormatInfo objeto que representa as convenções de formatação da cultura invariável pode ser usado para operações no qual resultado cadeias de caracteres não devem variar de formatação com a 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.

Você pode instanciar um NumberFormatInfo objeto que representa as convenções de formatação da cultura invariável das seguintes maneiras:You can instantiate a NumberFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

O exemplo a seguir usa cada um desses métodos para instanciar um NumberFormatInfo objeto que representa a cultura invariável.The following example uses each of these methods to instantiate a NumberFormatInfo object that represents the invariant culture. Em seguida, ele indica se o objeto é somente leituraIt 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

Criando uma instância de um objeto NumberFormatInfo para uma cultura específicaInstantiating a NumberFormatInfo object for a specific culture

Uma cultura específica representa uma linguagem que é falada em um país/região específico.A specific culture represents a language that is spoken in a particular country/region. Por exemplo, en-US é uma cultura específica que representa o idioma inglês falado nos Estados Unidos e en-CA é uma cultura específica que representa o idioma inglês falado no Canadá.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. Você pode instanciar um NumberFormatInfo objeto que representa as convenções de formatação de uma cultura específica das seguintes maneiras:You can instantiate a NumberFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

O exemplo a seguir usa esses quatro maneiras de criar um NumberFormatInfo objeto que reflete as convenções de formatação da cultura indonésio (Indonésia).The following example uses these four ways to create a NumberFormatInfo object that reflects the formatting conventions of the Indonesian (Indonesia) culture. Ele também indica se cada objeto é somente leitura.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

Criando uma instância de um objeto NumberFormatInfo para uma cultura neutraInstantiating a NumberFormatInfo object for a neutral culture

Uma cultura neutra representa uma cultura ou idioma que é independente de um país/região.A neutral culture represents a culture or language that is independent of a country/region. Geralmente, é o pai de um ou mais culturas específicas.It is typically the parent of one or more specific cultures. Por exemplo, fr é uma cultura neutra para o idioma francês e o pai da cultura fr-FR.For example, fr is a neutral culture for the French language and the parent of the fr-FR culture. Você cria um NumberFormatInfo objeto que representa as convenções de formatação de uma cultura neutra da mesma maneira que você cria um NumberFormatInfo objeto que representa as convenções de formatação de uma cultura específica.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.

Observação

No .NET Framework 3,5.NET Framework 3.5 e versões anteriores, tentar recuperar um NumberFormatInfo objeto que reflete as convenções de formatação de uma cultura neutra lança um NotSupportedException exceção.In 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.

No entanto, porque ele é independente de um país/região específico, uma cultura neutra não tem informações de formatação específicas da cultura.However, because it is independent of a specific country/region, a neutral culture lacks culture-specific formatting information. Em vez de preencher a NumberFormatInfo do objeto com valores genéricos, o .NET Framework retorna um NumberFormatInfo objeto que reflete as convenções de formatação de uma versão específica de cultura que é um filho de cultura neutra.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. Por exemplo, o NumberFormatInfo do objeto para a cultura neutra en reflete as convenções de formatação da cultura en-US e o NumberFormatInfo do objeto para a cultura fr reflete as convenções de formatação da 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.

Você pode usar código semelhante ao seguinte para determinar as convenções de formatação da cultura quais específico representa cada cultura neutra.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 dados dinâmicosNumberFormatInfo and dynamic data

Os dados específicos de cultura para formatação de valores numéricos fornecidos pelo NumberFormatInfo classe é dinâmico, assim como os dados culturais fornecidos pelo CultureInfo 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. Você não deve fazer suposições sobre a estabilidade dos valores para NumberFormatInfo objetos que estão associados com determinado CultureInfo objetos.You should not make any assumptions about the stability of values for NumberFormatInfo objects that are associated with particular CultureInfo objects. Somente os dados fornecidos por cultura invariável e seus respectivos NumberFormatInfo objeto esteja estável.Only the data provided by the invariant culture and its associated NumberFormatInfo object is stable. Outros dados podem ser alterados entre sessões do aplicativo, ou mesmo dentro de uma única sessão, pelos seguintes motivos:Other data can change between application sessions, or even within a single session, for the following reasons:

  • Atualizações do sistema.System updates. Alterar as preferências culturais, como o símbolo de moeda ou formatos de moeda ao longo do tempo.Cultural preferences such as the currency symbol or currency formats change over time. Quando isso acontece, a atualização do Windows inclui alterações para o NumberFormatInfo valor da propriedade para uma determinada cultura.When this happens, Windows Update includes changes to the NumberFormatInfo property value for a particular culture.

  • Culturas de substituição.Replacement cultures. O CultureAndRegionInfoBuilder classe pode ser usada para substituir os dados de uma cultura existente.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Alterações em cascata para valores de propriedade.Cascading changes to property values. Um número de propriedades relacionadas à cultura pode ser alterado em tempo de execução, o que, por sua vez, faz com que NumberFormatInfo dados para alterar.A number of culture-related properties can change at run time, which, in turn, causes NumberFormatInfo data to change. Por exemplo, a cultura atual pode ser alterada programaticamente ou por meio de ação do usuário.For example, the current culture can be changed either programmatically or through user action. Quando isso acontece, o NumberFormatInfo objeto retornado pelo CurrentInfo propriedade muda para um objeto associado com a cultura atual.When this happens, the NumberFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture.

  • Preferências do usuário.User preferences. Os usuários do seu aplicativo podem substituir alguns dos valores associados com a cultura atual do sistema por meio de opções de região e idioma no painel de controle.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. Por exemplo, os usuários podem escolher um símbolo de moeda diferente ou um símbolo do separador decimal.For example, users might choose a different currency symbol or a different decimal separator symbol. Se o CultureInfo.UseUserOverride estiver definida como true (valor padrão), as propriedades do NumberFormatInfo objeto também são recuperadas das configurações de usuário.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.

Começando com o .NET Framework 2.0, todas as propriedades de usuário substituível de uma NumberFormatInfo objeto são inicializadas quando o objeto é criado.Starting with the .NET Framework 2.0, all user-overridable properties of a NumberFormatInfo object are initialized when the object is created. Ainda há a possibilidade de inconsistência, porque nenhuma criação do objeto nem o processo de substituição do usuário é atômico, e os valores relevantes podem ser alterados durante a criação do objeto.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. No entanto, essas inconsistências devem ser extremamente raras.However, these inconsistencies should be extremely rare.

Você pode controlar se as substituições do usuário são refletidas no NumberFormatInfo objetos que representam a mesma cultura que a cultura do thread atual.You can control whether user overrides are reflected in NumberFormatInfo objects that represent the same culture as the current thread culture. A tabela a seguir lista as maneiras em que um NumberFormatInfo objeto podem ser recuperado e indica se o objeto resultante reflete substituições do usuário.The following table lists the ways in which a NumberFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Origem do objeto CultureInfo e NumberFormatInfoSource of CultureInfo and NumberFormatInfo object Reflete as substituições do usuárioReflects user overrides
Propriedade CultureInfo.CurrentCulture.NumberFormatCultureInfo.CurrentCulture.NumberFormat property SimYes
Propriedade NumberFormatInfo.CurrentInfoNumberFormatInfo.CurrentInfo property SimYes
Método CultureInfo.CreateSpecificCultureCultureInfo.CreateSpecificCulture method SimYes
Método CultureInfo.GetCultureInfoCultureInfo.GetCultureInfo method NãoNo
Construtor CultureInfo(String)CultureInfo(String) constructor SimYes
Construtor CultureInfo.CultureInfo(String, Boolean)CultureInfo.CultureInfo(String, Boolean) constructor Depende do valor de useUserOverride parâmetroDepends on value of useUserOverride parameter

A menos que haja um motivo convincente para fazer o contrário, você deve respeitar substituições do usuário quando você usa o NumberFormatInfo objeto em aplicativos de cliente para formatar e analisar a entrada do usuário ou para exibir dados numéricos.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. Para aplicativos de servidor ou aplicativos autônomos, você não deve respeitar substituições do usuário.For server applications or unattended applications, you should not respect user overrides. No entanto, se você estiver usando o NumberFormatInfo objeto explicitamente ou implicitamente para persistir dados numéricos na forma de cadeia de caracteres, você deve usar um NumberFormatInfo objeto que reflete as convenções de formatação da cultura invariável, ou você deve especificar um cadeia de caracteres de formato numérico personalizado que você usar, independentemente da 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 formatação numéricaIFormatProvider, NumberFormatInfo, and numeric formatting

Um NumberFormatInfo objeto é usado implicitamente ou explicitamente em numérico todas as operações de formatação.A NumberFormatInfo object is used implicitly or explicitly in all numeric formatting operations. Isso inclui chamadas para os seguintes métodos:These include calls to the following methods:

Todas as operações de formatação numéricas fazer uso de um IFormatProvider implementação.All numeric formatting operations make use of an IFormatProvider implementation. O IFormatProvider interface inclui um único método, GetFormat(Type).The IFormatProvider interface includes a single method, GetFormat(Type). Esse é um método de retorno de chamada que é passado um Type objeto que representa o tipo necessário para fornecer informações de formatação.This is a callback method that is passed a Type object that represents the type needed to provide formatting information. O método é responsável por retornar uma instância desse tipo ou null, se ele não pode fornecer uma instância do tipo.The method is responsible for returning either an instance of that type or null, if it cannot provide an instance of the type. O .NET Framework fornece dois IFormatProvider implementações para formatação de números:The .NET Framework provides two IFormatProvider implementations for formatting numbers:

Se um IFormatProvider implementação não é fornecida para um método de formatação explicitamente, uma CultureInfo objeto retornado pelo CultureInfo.CurrentCulture propriedade que representa a cultura do thread atual será usada.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.

O exemplo a seguir ilustra o relacionamento entre o IFormatProvider interface e o NumberFormatInfo classe em operações de formatação, definindo um personalizado IFormatProvider implementação.The following example illustrates the relationship between the IFormatProvider interface and the NumberFormatInfo class in formatting operations by defining a custom IFormatProvider implementation. Seu GetFormat método exibe o nome do tipo do objeto solicitada pela operação de formatação.Its GetFormat method displays the type name of the object requested by the formatting operation. Se a interface está solicitando uma NumberFormatInfo do objeto, esse método fornece a NumberFormatInfo objeto para a cultura do thread atual.If the interface is requesting a NumberFormatInfo object, this method provides the NumberFormatInfo object for the current thread culture. Como a saída do exemplo mostra, o Decimal.ToString(IFormatProvider) solicitações de método uma NumberFormatInfo objeto para fornecer informações de formatação, enquanto que o String.Format(IFormatProvider, String, Object[]) solicitações de método NumberFormatInfo e DateTimeFormatInfo objetos, bem como um ICustomFormatter implementação.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 um IFormatProvider implementação não é explicitamente fornecida em uma chamada de método, as chamadas de método de formatação numérica a CultureInfo.CurrentCulture.GetFormat método, que retorna o NumberFormatInfo objeto que corresponde à cultura do thread atual.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.

Cadeias de caracteres de formato e propriedades de NumberFormatInfoFormat strings and NumberFormatInfo properties

Cada operação de formatação usa um padrão ou uma cadeia de caracteres de formato numérico personalizado para produzir uma cadeia de caracteres de resultado de um número.Every formatting operation uses either a standard or a custom numeric format string to produce a result string from a number. Em alguns casos, o uso de uma cadeia de caracteres de formato para produzir uma cadeia de caracteres de resultado é explícito, como no exemplo a seguir.In some cases, the use of a format string to produce a result string is explicit, as in the following example. Esse código chama o Decimal.ToString(IFormatProvider) método para converter um Decimal valor a um número de representações de cadeia de caracteres diferentes, usando as convenções de formatação da 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

Em outros casos, o uso de uma cadeia de caracteres de formato é implícito.In other cases, the use of a format string is implicit. Por exemplo, nas chamadas de método seguinte para o padrão ou sem parâmetros Decimal.ToString() método, o valor da Decimal instância é formatada usando o especificador de formato geral ("G") e as convenções da cultura atual, que nesse caso é o 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

Cada cadeia de caracteres de formato numérico padrão usa um ou mais NumberFormatInfo propriedades para determinar o padrão ou os símbolos usados na cadeia de caracteres de resultado.Each standard numeric format string uses one or more NumberFormatInfo properties to determine the pattern or the symbols used in the result string. Da mesma forma, cada especificador de formato numérico personalizado, exceto "0" e "#" inserir símbolos em cadeia de caracteres resultante que são definidos pelo NumberFormatInfo propriedades.Similarly, each custom numeric format specifier except "0" and "#" insert symbols in the result string that are defined by NumberFormatInfo properties. A tabela a seguir lista o padrão e especificadores de formato numérico personalizado e seus respectivos NumberFormatInfo propriedades.The following table lists the standard and custom numeric format specifiers and their associated NumberFormatInfo properties. Para alterar a aparência da cadeia de caracteres de resultado para uma cultura específica, consulte o propriedades de NumberFormatInfo modificando seção.To change the appearance of the result string for a particular culture, see the Modifying NumberFormatInfo properties section. Para obter detalhes sobre o uso desses especificadores de formato, consulte cadeias de caracteres de formato numérico padrão e às cadeias de caracteres de formato numérico personalizado.For details about the use of these format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

Especificador de formatoFormat specifier Propriedades associadasAssociated properties
"C" ou "c" (especificador de formato de moeda)"C" or "c" (currency format specifier) CurrencyDecimalDigits, para definir o número padrão de dígitos fracionários.CurrencyDecimalDigits, to define the default number of fractional digits.

CurrencyDecimalSeparator, para definir o símbolo do separador decimal.CurrencyDecimalSeparator, to define the decimal separator symbol.

CurrencyGroupSeparator, para definir o grupo ou milhares separador.CurrencyGroupSeparator, to define the group or thousands separator.

CurrencyGroupSizes, para definir os tamanhos dos grupos de integrais.CurrencyGroupSizes, to define the sizes of integral groups.

CurrencyNegativePattern, para definir o padrão de valores negativos de moeda.CurrencyNegativePattern, to define the pattern of negative currency values.

CurrencyPositivePattern, para definir o padrão de valores positivos de moeda.CurrencyPositivePattern, to define the pattern of positive currency values.

CurrencySymbol, para definir o símbolo de moeda.CurrencySymbol, to define the currency symbol.

NegativeSign, para definir o símbolo de sinal negativo.NegativeSign, to define the negative sign symbol.
"D" ou "d" (especificador de formato decimal)"D" or "d" (decimal format specifier) NegativeSign, para definir o símbolo de sinal negativo.NegativeSign, to define the negative sign symbol.
"E" ou "e" (especificador de formato exponencial ou científica)"E" or "e" (exponential or scientific format specifier) NegativeSign, para definir o símbolo de sinal negativo na mantissa e expoente.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

NumberDecimalSeparator, para definir o símbolo do separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, para definir o símbolo de sinal positivo no expoente.PositiveSign, to define the positive sign symbol in the exponent.
"F" ou "f" (especificador de formato de ponto fixo)"F" or "f" (fixed-point format specifier) NegativeSign, para definir o símbolo de sinal negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, para definir o número padrão de dígitos fracionários.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, para definir o símbolo do separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.
"G" ou "g" (especificador de formato geral)"G" or "g" (general format specifier) NegativeSign, para definir o símbolo de sinal negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, para definir o símbolo do separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, para definir o símbolo de sinal positivo para cadeias de caracteres de resultado em formato exponencial.PositiveSign, to define the positive sign symbol for result strings in exponential format.
"N" ou "n" (especificador de formato numérico)"N" or "n" (number format specifier) NegativeSign, para definir o símbolo de sinal negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, para definir o número padrão de dígitos fracionários.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, para definir o símbolo do separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.

NumberGroupSeparator, para definir o símbolo de separador (milhares) de grupo.NumberGroupSeparator, to define the group separator (thousands) symbol.

NumberGroupSizes, para definir o número de dígitos integrais em um grupo.NumberGroupSizes, to define the number of integral digits in a group.

NumberNegativePattern, para definir o formato dos valores negativos.NumberNegativePattern, to define the format of negative values.
"P" ou "p" (especificador de formato de porcentagem)"P" or "p" (percent format specifier) NegativeSign, para definir o símbolo de sinal negativo.NegativeSign, to define the negative sign symbol.

PercentDecimalDigits, para definir o número padrão de dígitos fracionários.PercentDecimalDigits, to define the default number of fractional digits.

PercentDecimalSeparator, para definir o símbolo do separador decimal.PercentDecimalSeparator, to define the decimal separator symbol.

PercentGroupSeparator, para definir o símbolo de separador de grupo.PercentGroupSeparator, to define the group separator symbol.

PercentGroupSizes, para definir o número de dígitos integrais em um grupo.PercentGroupSizes, to define the number of integral digits in a group.

PercentNegativePattern, para definir o posicionamento do símbolo de porcentagem e o símbolo negativo para valores negativos.PercentNegativePattern, to define the placement of the percent symbol and the negative symbol for negative values.

PercentPositivePattern, para definir o posicionamento do símbolo de porcentagem para valores positivos.PercentPositivePattern, to define the placement of the percent symbol for positive values.

PercentSymbol, para definir o símbolo de porcentagem.PercentSymbol, to define the percent symbol.
"R" ou "r" (especificador de formato de ida e volta)"R" or "r" (round-trip format specifier) NegativeSign, para definir o símbolo de sinal negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, para definir o símbolo do separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, para definir o símbolo de sinal positivo em um expoente.PositiveSign, to define the positive sign symbol in an exponent.
"X" ou "x" (especificador de formato hexadecimal)"X" or "x" (hexadecimal format specifier) nenhuma.None.
"." (especificador de formato personalizado de ponto decimal)"." (decimal point custom format specifier) NumberDecimalSeparator, para definir o símbolo do separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.
"," (especificador de formato personalizado de separador de grupo)"," (group separator custom format specifier) NumberGroupSeparator, para definir o símbolo de separador de grupo (milhares).NumberGroupSeparator, to define the group (thousands) separator symbol.
"%" (especificador de formato personalizado de espaço reservado de porcentagem)"%" (percentage placeholder custom format specifier) PercentSymbol, para definir o símbolo de porcentagem.PercentSymbol, to define the percent symbol.
"‰" (por milha especificador de formato personalizado de espaço reservado)"‰" (per mille placeholder custom format specifier) PerMilleSymbol, para definir o símbolo por milha.PerMilleSymbol, to define the per mille symbol.
"E" (especificador de formato personalizado de notação exponencial)"E" (exponential notation custom format specifier) NegativeSign, para definir o símbolo de sinal negativo na mantissa e expoente.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

PositiveSign, para definir o símbolo de sinal positivo no expoente.PositiveSign, to define the positive sign symbol in the exponent.

Observe que o NumberFormatInfo classe inclui um NativeDigits propriedade que especifica os dígitos de base 10 usados por uma cultura específica.Note that the NumberFormatInfo class includes a NativeDigits property that specifies the base 10 digits used by a specific culture. No entanto, a propriedade não é usada na formatação de operações; somente os dígitos latinos básicos 0 (u+0030) a 9 (u+0039) são usados na cadeia de caracteres de resultado.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. Além disso, para Single e Double valores de NaN, PositiveInfinity, e NegativeInfinity, a cadeia de caracteres de resultado consiste exclusivamente os símbolos definidos o NaNSymbol, PositiveInfinitySymbol, e NegativeInfinitySymbol propriedades , respectivamente.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.

Modificando propriedades de NumberFormatInfoModifying NumberFormatInfo properties

Você pode modificar as propriedades de um NumberFormatInfo objeto para personalizar a cadeia de caracteres de resultado produzida em uma operação de formatação numérica.You can modify the properties of a NumberFormatInfo object to customize the result string produced in a numeric formatting operation. Para fazer isso:To do this:

  1. Criar uma cópia de leitura/gravação de um NumberFormatInfo objeto cujas convenções de formatação que você deseja modificar.Create a read/write copy of a NumberFormatInfo object whose formatting conventions you want to modify. Para obter mais informações, consulte o instanciar um objeto NumberFormatInfo seção.For more information, see the Instantiating a NumberFormatInfo object section.

  2. Modifique a propriedade ou propriedades que são usadas para produzir a cadeia de caracteres de resultado desejado.Modify the property or properties that are used to produce the desired result string. Para obter informações sobre o uso de métodos como a formatação NumberFormatInfo propriedades para definir as cadeias de caracteres de resultado, consulte a Formatar cadeias de caracteres e propriedades de NumberFormatInfo seção.For information about how formatting methods use NumberFormatInfo properties to define result strings, see the Format strings and NumberFormatInfo properties section.

  3. Usar o custom NumberFormatInfo objeto como o IFormatProvider argumento em chamadas para métodos de formatação.Use the custom NumberFormatInfo object as the IFormatProvider argument in calls to formatting methods.

Observação

Em vez de modificar dinamicamente valores de propriedade de uma cultura sempre que um aplicativo é iniciado, você pode usar o CultureAndRegionInfoBuilder classe para definir uma cultura personalizada (uma cultura que tem um nome exclusivo e que complementa as culturas existentes) ou uma substituição cultura (aquele que é usado em vez de uma cultura específica).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).

As seções a seguir fornecem alguns exemplos.The following sections provide some examples.

Modificando o símbolo e o padrão da moedaModifying the currency symbol and pattern

O exemplo a seguir modifica uma NumberFormatInfo objeto que representa as convenções de formatação da cultura en-US.The following example modifies a NumberFormatInfo object that represents the formatting conventions of the en-US culture. Ele atribui o símbolo de moeda ISO 4217 para o CurrencySymbol propriedade e define um padrão para valores de moeda que consiste o símbolo de moeda seguido por um espaço e um valor numérico.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

Formatando um número de identificação nacionalFormatting a national identification number

Muitos números de identificação nacional consistir exclusivamente em dígitos e então facilmente podem ser formatados, modificando as propriedades de um NumberFormatInfo objeto.Many national identification numbers consist exclusively of digits and so can easily be formatted by modifying the properties of a NumberFormatInfo object. Por exemplo, um número do seguro social dos Estados Unidos consiste de 9 dígitos organizados da seguinte maneira: XXX-XX-XXXX.For example, a social security number in the United States consists of 9 digits arranged as follows: XXX-XX-XXXX. O exemplo a seguir pressupõe que os números do seguro social são armazenados como valores de inteiro e formata-os adequadamente.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

Analisando cadeias de caracteres numéricasParsing numeric strings

Análise envolve a conversão a representação de cadeia de caracteres de um número em um número.Parsing involves converting the string representation of a number to a number. Cada tipo numérico no .NET Framework inclui dois métodos sobrecarregados de análise: Parse e TryParse.Each numeric type in the .NET Framework includes two overloaded parsing methods: Parse and TryParse. O Parse método converte uma cadeia de caracteres em um número e gera uma exceção se a conversão falhar.The Parse method converts a string to a number and throws an exception if the conversion fails. O TryParse método converte uma cadeia de caracteres em um número, atribui o número para um out argumento e retorna um Boolean valor que indica se a conversão foi bem-sucedida.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.

Os métodos de análise implicitamente ou explicitamente, use um NumberStyles valor de enumeração para determinar quais elementos de estilo (como separadores de grupo, um separador decimal ou um símbolo de moeda) podem estar presentes em uma cadeia de caracteres, se a operação de análise seja bem-sucedida.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 um NumberStyles valor não for fornecido na chamada de método, o padrão é um NumberStyles valor que inclui o Float e AllowThousands sinalizadores, que especifica que a cadeia de caracteres analisada pode incluir símbolos de grupo, um separador decimal, um sinal negativo, e caracteres de espaço em branco, ou ele pode ser a representação de cadeia de caracteres de um número em notação exponencial.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.

Os métodos de análise também implícita ou explicitamente, use um NumberFormatInfo objeto que define os símbolos específicos e os padrões que pode ocorrer na cadeia de caracteres a ser analisada.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 um NumberFormatInfo objeto não for fornecido, o padrão é o NumberFormatInfo para a cultura do thread atual.If a NumberFormatInfo object is not provided, the default is the NumberFormatInfo for the current thread culture. Para obter mais informações sobre análise, consulte os métodos de análise individuais, como Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), 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).

O exemplo a seguir ilustra a natureza sensível à cultura da análise de cadeias de caracteres.The following example illustrates the culture-sensitive nature of parsing strings. Ele tenta analisar uma cadeia de caracteres que incluem milhares separadores usando as convenções do en-US, fr-FR e culturas invariáveis.It tries to parse a string that include thousands separators by using the conventions of the en-US, fr-FR, and invariant cultures. Uma cadeia de caracteres que inclui a vírgula como um separador de grupo e o período, como um separador decimal Falha ao analisar a cultura fr-FR e uma cadeia de caracteres com uma vírgula como separador decimal e de white space como um separador de grupo não pode analisar nas culturas invariáveis e en-US.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)

Análise geralmente ocorre em dois contextos:Parsing generally occurs in two contexts:

  • Como uma operação que foi projetada para converter a entrada do usuário em um valor numérico.As an operation that is designed to convert user input into a numeric value.

  • Como uma operação que foi projetada para um valor numérico; de ida e volta ou seja, para desserializar um valor numérico que anteriormente foi serializado como uma cadeia de caracteres.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.

As seções a seguir discutem essas duas operações mais detalhadamente.The following sections discuss these two operations in greater detail.

Analisando cadeias de caracteres do usuárioParsing user strings

Quando você estiver analisando cadeias de caracteres numéricos inseridas pelo usuário, você sempre deve instanciar um NumberFormatInfo objeto que reflete as configurações culturais do usuário.When you are parsing numeric strings input by the user, you should always instantiate a NumberFormatInfo object that reflects the user's cultural settings. Para obter informações sobre como criar uma instância de um NumberFormatInfo objeto que reflete as personalizações do usuário, consulte a NumberFormatInfo e dados dinâmicos seção.For information about how to instantiate a NumberFormatInfo object that reflects user customizations, see the NumberFormatInfo and dynamic data section.

O exemplo a seguir ilustra a diferença entre uma operação de análise que reflete as configurações culturais do usuário e que não faz isso.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. Nesse caso, a cultura padrão do sistema é en-US, mas o usuário tiver definido "," como o símbolo decimal e "." como o separador de grupo no painel de controle região e idioma.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. Normalmente, esses símbolos são revertidos na cultura en-US padrão.Ordinarily, these symbols are reversed in the default en-US culture. Quando o usuário insere uma cadeia de caracteres que reflete as configurações de usuário e a cadeia de caracteres é analisada por um NumberFormatInfo objeto que também reflete as configurações do usuário (substituições), a operação de análise retorna um resultado correto.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. No entanto, quando a cadeia de caracteres é analisada por um NumberFormatInfo objeto que reflete as configurações culturais en-US padrão, ele o símbolo de vírgula para um separador de grupo de erros e retorna um resultado incorreto.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

Serializando e desserializando dados numéricosSerializing and deserializing numeric data

Quando dados numéricos são serializados em formato de cadeia de caracteres e posterior desserializados e analisados, as cadeias de caracteres devem ser geradas e analisadas usando as convenções da cultura invariável.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. As operações de formatação e análise nunca devem refletir as convenções de uma cultura específica.The formatting and parsing operations should never reflect the conventions of a specific culture. Se forem usadas configurações específicas da cultura, a portabilidade dos dados é estritamente limitada. ele pode ser desserializado com êxito somente em um thread cujas configurações específicas de cultura são idênticas do thread no qual ele foi serializado.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. Em alguns casos, isso significa que os dados não é possível até mesmo ser desserializado com êxito no mesmo sistema no qual ele foi serializado.In some cases, this means that the data cannot even be successfully deserialized on the same system on which it was serialized.

O exemplo a seguir ilustra o que pode acontecer quando esse princípio é violado.The following example illustrates what can happen when this principle is violated. Valores de ponto flutuante em uma matriz são convertidos em cadeias de caracteres quando o thread atual usa as configurações específicas da cultura da 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. Os dados, em seguida, são analisados por um thread que usa as configurações específicas da cultura da cultura en-GB.The data is then parsed by a thread that uses the culture-specific settings of the en-GB culture. Nesse caso, embora cada operação de análise for bem-sucedida, os dados não ida e volta com êxito e corrupção de dados ocorre.In this case, although each parsing operation succeeds, the data does not round-trip successfully and data corruption occurs. Em outros casos, uma operação de análise pode falhar e um FormatException exceção foi lançada.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

Construtores

NumberFormatInfo() NumberFormatInfo() NumberFormatInfo() NumberFormatInfo()

Inicializa uma nova instância gravável da classe NumberFormatInfo que é independente da cultura (invariável).Initializes a new writable instance of the NumberFormatInfo class that is culture-independent (invariant).

Propriedades

CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits

Obtém ou define o número de casas decimais a ser usado em valores de moeda.Gets or sets the number of decimal places to use in currency values.

CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator

Obtém ou define a cadeia de caracteres a ser usada como separador decimal em valores de moeda.Gets or sets the string to use as the decimal separator in currency values.

CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator

Obtém ou define a cadeia de caracteres que separa grupos de dígitos à esquerda do decimal em valores de moeda.Gets or sets the string that separates groups of digits to the left of the decimal in currency values.

CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes

Obtém ou define o número de dígitos em cada grupo à esquerda do decimal em valores de moeda.Gets or sets the number of digits in each group to the left of the decimal in currency values.

CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern

Obtém ou define o padrão de formato para valores negativos de moeda.Gets or sets the format pattern for negative currency values.

CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern

Obtém ou define o padrão de formato para valores positivos de moeda.Gets or sets the format pattern for positive currency values.

CurrencySymbol CurrencySymbol CurrencySymbol CurrencySymbol

Obtém ou define a cadeia de caracteres a ser usada como o símbolo de moeda.Gets or sets the string to use as the currency symbol.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Obtém o NumberFormatInfo somente leitura que formata valores com base na cultura atual.Gets a read-only NumberFormatInfo that formats values based on the current culture.

DigitSubstitution DigitSubstitution DigitSubstitution DigitSubstitution

Obtém ou define um valor que especifica como a interface gráfica do usuário exibe a forma de um dígito.Gets or sets a value that specifies how the graphical user interface displays the shape of a digit.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Obtém o objeto NumberFormatInfo somente leitura que é independente da cultura (invariável).Gets a read-only NumberFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtém um valor que indica se este objeto NumberFormatInfo é somente leitura.Gets a value that indicates whether this NumberFormatInfo object is read-only.

NaNSymbol NaNSymbol NaNSymbol NaNSymbol

Obtém ou define a cadeia de caracteres que representa o valor de IEEE NaN (não é um número).Gets or sets the string that represents the IEEE NaN (not a number) value.

NativeDigits NativeDigits NativeDigits NativeDigits

Obtém ou define uma matriz de cadeia de caracteres de dígitos nativos equivalentes aos dígitos ocidentais de 0 a 9.Gets or sets a string array of native digits equivalent to the Western digits 0 through 9.

NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol

Obtém ou define a cadeia de caracteres que representa o infinito negativo.Gets or sets the string that represents negative infinity.

NegativeSign NegativeSign NegativeSign NegativeSign

Obtém ou define a cadeia de caracteres que indica que o número associado é negativo.Gets or sets the string that denotes that the associated number is negative.

NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits

Obtém ou define o número de casas decimais a ser usado em valores numéricos.Gets or sets the number of decimal places to use in numeric values.

NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator

Obtém ou define a cadeia de caracteres a ser usada como separador decimal em valores numéricos.Gets or sets the string to use as the decimal separator in numeric values.

NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator

Obtém ou define a cadeia de caracteres que separa grupos de dígitos à esquerda da vírgula decimal em valores numéricos.Gets or sets the string that separates groups of digits to the left of the decimal in numeric values.

NumberGroupSizes NumberGroupSizes NumberGroupSizes NumberGroupSizes

Obtém ou define o número de dígitos em cada grupo à esquerda do decimal em valores numéricos.Gets or sets the number of digits in each group to the left of the decimal in numeric values.

NumberNegativePattern NumberNegativePattern NumberNegativePattern NumberNegativePattern

Obtém ou define o padrão de formato para valores numéricos negativos.Gets or sets the format pattern for negative numeric values.

PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits

Obtém ou define o número de casas decimais a ser usado em valores percentuais.Gets or sets the number of decimal places to use in percent values.

PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator

Obtém ou define a cadeia de caracteres a ser usada como o separador decimal em valores de porcentagem.Gets or sets the string to use as the decimal separator in percent values.

PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator

Obtém ou define a cadeia de caracteres que separa os grupos de dígitos à esquerda do separador decimal em valores de percentual.Gets or sets the string that separates groups of digits to the left of the decimal in percent values.

PercentGroupSizes PercentGroupSizes PercentGroupSizes PercentGroupSizes

Obtém ou define o número de dígitos em cada grupo à esquerda do decimal em valores percentuais.Gets or sets the number of digits in each group to the left of the decimal in percent values.

PercentNegativePattern PercentNegativePattern PercentNegativePattern PercentNegativePattern

Obtém ou define o padrão de formato dos valores percentuais negativos.Gets or sets the format pattern for negative percent values.

PercentPositivePattern PercentPositivePattern PercentPositivePattern PercentPositivePattern

Obtém ou define o padrão de formato para valores percentuais positivos.Gets or sets the format pattern for positive percent values.

PercentSymbol PercentSymbol PercentSymbol PercentSymbol

Obtém ou define a cadeia de caracteres a ser usada como o símbolo de porcentagem.Gets or sets the string to use as the percent symbol.

PerMilleSymbol PerMilleSymbol PerMilleSymbol PerMilleSymbol

Obtém ou define a cadeia de caracteres a ser usada como o símbolo por milha.Gets or sets the string to use as the per mille symbol.

PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol

Obtém ou define a cadeia de caracteres que representa o infinito positivo.Gets or sets the string that represents positive infinity.

PositiveSign PositiveSign PositiveSign PositiveSign

Obtém ou define a cadeia de caracteres que indica que o número associado é positivo.Gets or sets the string that denotes that the associated number is positive.

Métodos

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

Cria uma cópia superficial do objeto NumberFormatInfo.Creates a shallow copy of the NumberFormatInfo object.

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

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

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

Obtém um objeto do tipo especificado que fornece um serviço de formatação de número.Gets an object of the specified type that provides a number formatting service.

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

Serve como a função de hash padrão.Serves as the default hash function.

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

Obtém o NumberFormatInfo associado ao IFormatProvider especificado.Gets the NumberFormatInfo associated with the specified IFormatProvider.

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

Obtém o Type da instância atual.Gets the Type of the current instance.

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

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

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

Retorna um wrapper NumberFormatInfo de somente leitura.Returns a read-only NumberFormatInfo wrapper.

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

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Inherited from Object)

Aplica-se a

Veja também