NumberFormatInfo Classe

Definição

Fornece informações específicas da cultura para formatação e análise de valores numéricos.

public ref class NumberFormatInfo sealed : IFormatProvider
public ref class NumberFormatInfo sealed : ICloneable, IFormatProvider
public sealed class NumberFormatInfo : IFormatProvider
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
type NumberFormatInfo = class
    interface IFormatProvider
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type NumberFormatInfo = class
    interface ICloneable
    interface IFormatProvider
Public NotInheritable Class NumberFormatInfo
Implements IFormatProvider
Public NotInheritable Class NumberFormatInfo
Implements ICloneable, IFormatProvider
Herança
NumberFormatInfo
Atributos
Implementações

Exemplos

O exemplo a seguir mostra como recuperar um NumberFormatInfo objeto para um objeto correspondente CultureInfo e usar o objeto recuperado para consultar informações de formatação de número para a cultura específica.

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

A NumberFormatInfo classe contém informações específicas da cultura que são usadas quando você formata e analisa valores numéricos. Essas informações incluem o símbolo de moeda, o símbolo decimal, o símbolo separador de grupo e os símbolos para sinais positivos e negativos.

Criando uma instância de um objeto NumberFormatInfo

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.

Criando uma instância de um objeto NumberFormatInfo para a cultura atual

Você pode criar uma instância de um NumberFormatInfo objeto para a cultura atual de qualquer uma das seguintes maneiras. Em cada caso, o objeto retornado NumberFormatInfo é somente leitura.

O exemplo a seguir usa essas três maneiras de criar NumberFormatInfo objetos que representam as convenções de formatação da cultura atual. Ele também recupera o valor da IsReadOnly propriedade para ilustrar que cada objeto é somente leitura.

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 objeto gravável NumberFormatInfo que representa as convenções da cultura atual de qualquer uma das seguintes maneiras:

O exemplo a seguir ilustra essas duas maneiras de instanciar um NumberFormatInfo objeto e exibe o valor de sua IsReadOnly propriedade para ilustrar que o objeto não é somente leitura.

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 substitua alguns dos valores de NumberFormatInfo propriedade usados em operações de formatação numérica e análise por meio do item Região e Idioma em Painel de Controle. 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. Os NumberFormatInfo objetos recuperados das maneiras discutidas anteriormente refletem essas substituições de usuário. Se isso for indesejável, você poderá criar um NumberFormatInfo objeto que não reflita as substituições do usuário (e que também seja leitura/gravação em vez de somente leitura) chamando o CultureInfo.CultureInfo(String, Boolean) construtor e fornecendo um valor para false o useUserOverride argumento. O exemplo a seguir fornece uma ilustração para um sistema cuja cultura atual é inglês (Estados Unidos) e cujo símbolo de moeda foi alterado do padrão de US$ para 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 a CultureInfo.UseUserOverride propriedade estiver definida como true, as propriedades CultureInfo.DateTimeFormat, CultureInfo.NumberFormate CultureInfo.TextInfo também for recuperada das configurações do usuário. Se as configurações do usuário forem incompatíveis com a cultura associada CultureInfo ao objeto (por exemplo, se o calendário selecionado não for um dos calendários listados pela OptionalCalendars propriedade), os resultados dos métodos e os valores das propriedades serão indefinidos.

Criando uma instância de um objeto NumberFormatInfo para a cultura invariável

A cultura invariável representa uma cultura insensível. Baseia-se na língua inglesa, mas não em qualquer país/região de língua inglesa específica. Embora os dados de culturas específicas possam ser dinâmicos e possam ser alterados para refletir novas convenções culturais ou preferências do usuário, os dados da cultura invariável não são alterados. Um NumberFormatInfo objeto que representa as convenções de formatação da cultura invariável pode ser usado para operações de formatação nas quais as cadeias de caracteres de resultado não devem variar de acordo com a cultura.

Você pode instanciar um NumberFormatInfo objeto que representa as convenções de formatação da cultura invariável das seguintes maneiras:

O exemplo a seguir usa cada um desses métodos para instanciar um NumberFormatInfo objeto que representa a cultura invariável. Em seguida, indica se o objeto é somente leitura,

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ífica

Uma cultura específica representa um idioma falado em um determinado país/região. Por exemplo, en-US é uma cultura específica que representa o idioma inglês falado no Estados Unidos, e en-CA é uma cultura específica que representa o idioma inglês falado no Canadá. Você pode criar uma instância de um NumberFormatInfo objeto que representa as convenções de formatação de uma cultura específica das seguintes maneiras:

O exemplo a seguir usa essas quatro maneiras de criar um NumberFormatInfo objeto que reflete as convenções de formatação da cultura indonésia (Indonésia). Ele também indica se cada objeto é somente leitura.

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 neutra

Uma cultura neutra representa uma cultura ou idioma independente de um país/região. Normalmente, é o pai de uma ou mais culturas específicas. Por exemplo, fr é uma cultura neutra para o idioma francês e o pai da cultura fr-FR. Você cria um NumberFormatInfo objeto que representa as convenções de formatação de uma cultura neutra da mesma forma que cria um NumberFormatInfo objeto que representa as convenções de formatação de uma cultura específica.

Observação

No .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 gera uma NotSupportedException exceção.

No entanto, como é independente de um país/região específico, uma cultura neutra não tem informações de formatação específicas da cultura. Em vez de preencher o NumberFormatInfo objeto com valores genéricos, o .NET Framework retorna um NumberFormatInfo objeto que reflete as convenções de formatação de uma cultura específica que é filho da cultura neutra. Por exemplo, o NumberFormatInfo objeto da cultura en neutra reflete as convenções de formatação da cultura en-US, e o NumberFormatInfo objeto para a cultura fr reflete as convenções de formatação da cultura fr-FR.

Você pode usar código como o seguinte para determinar quais convenções de formatação de cultura específica cada cultura neutra representa.

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

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

         ListSimilarChildCultures(name);
      }
   }

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

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

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

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

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

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

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

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

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

NumberFormatInfo e dados dinâmicos

Os dados específicos da cultura para formatar valores numéricos fornecidos pela NumberFormatInfo classe são dinâmicos, assim como os dados culturais fornecidos pela CultureInfo classe. Você não deve fazer nenhuma suposição sobre a estabilidade dos valores para NumberFormatInfo objetos associados a objetos específicos CultureInfo . Somente os dados fornecidos pela cultura invariável e seu objeto associado NumberFormatInfo são estáveis. Outros dados podem ser alterados entre sessões de aplicativo ou até mesmo em uma única sessão, pelos seguintes motivos:

  • Atualizações do sistema. As preferências culturais, como o símbolo de moeda ou os formatos de moeda, mudam ao longo do tempo. Quando isso acontece, Windows Update inclui alterações no valor da NumberFormatInfo propriedade para uma cultura específica.

  • Culturas de substituição. A CultureAndRegionInfoBuilder classe pode ser usada para substituir os dados de uma cultura existente.

  • Alterações em cascata nos valores da propriedade. Várias propriedades relacionadas à cultura podem ser alteradas em tempo de execução, o que, por sua vez, faz com que os dados sejam alterados NumberFormatInfo . Por exemplo, a cultura atual pode ser alterada programaticamente ou por meio da ação do usuário. Quando isso acontece, o NumberFormatInfo objeto retornado pela CurrentInfo propriedade é alterado para um objeto associado à cultura atual.

  • Preferências do usuário. Os usuários do aplicativo podem substituir alguns dos valores associados à cultura do sistema atual por meio da região e das opções de idioma em Painel de Controle. Por exemplo, os usuários podem escolher um símbolo de moeda diferente ou um símbolo separador decimal diferente. Se a CultureInfo.UseUserOverride propriedade for definida como true (seu valor padrão), as propriedades do NumberFormatInfo objeto também serão recuperadas das configurações do usuário.

A partir do .NET Framework 2.0, todas as propriedades substituíveis pelo usuário de um NumberFormatInfo objeto são inicializadas quando o objeto é criado. Ainda há uma possibilidade de inconsistência, pois nem a criação de objeto nem o processo de substituição do usuário são atômicos e os valores relevantes podem ser alterados durante a criação do objeto. No entanto, essas inconsistências devem ser extremamente raras.

Você pode controlar se as substituições de usuário são refletidas em NumberFormatInfo objetos que representam a mesma cultura que a cultura atual. A tabela a seguir lista as maneiras pelas quais um NumberFormatInfo objeto pode ser recuperado e indica se o objeto resultante reflete as substituições do usuário.

Origem do objeto CultureInfo e NumberFormatInfo Reflete as substituições do usuário
Propriedade CultureInfo.CurrentCulture.NumberFormat Sim
Propriedade NumberFormatInfo.CurrentInfo Sim
Método CultureInfo.CreateSpecificCulture Yes
Método CultureInfo.GetCultureInfo Não
Construtor CultureInfo(String) Sim
Construtor CultureInfo.CultureInfo(String, Boolean) Depende do valor do useUserOverride parâmetro

A menos que haja um motivo convincente para fazer o contrário, você deve respeitar as substituições do usuário ao usar o NumberFormatInfo objeto em aplicativos cliente para formatar e analisar a entrada do usuário ou exibir dados numéricos. Para aplicativos de servidor ou aplicativos autônomos, você não deve respeitar as substituições do usuário. No entanto, se você estiver usando o NumberFormatInfo objeto explicitamente ou implicitamente para persistir dados numéricos no formulário de cadeia de caracteres, use um NumberFormatInfo objeto que reflita as convenções de formatação da cultura invariável ou especifique uma cadeia de caracteres de formato numérico personalizada que você usa independentemente da cultura.

IFormatProvider, NumberFormatInfo e formatação numérica

Um NumberFormatInfo objeto é usado implicitamente ou explicitamente em todas as operações de formatação numérica. Elas incluem chamadas para os seguintes métodos:

Todas as operações de formatação numérica usam uma implementação IFormatProvider . A IFormatProvider interface inclui um único método. GetFormat(Type) Esse é um método de retorno de chamada que é passado por um Type objeto que representa o tipo necessário para fornecer informações de formatação. O método é responsável por retornar uma instância desse tipo ou null, se não puder fornecer uma instância do tipo. O .NET Framework fornece duas IFormatProvider implementações para formatação de números:

Se uma IFormatProvider implementação não for fornecida a um método de formatação explicitamente, um CultureInfo objeto retornado pela CultureInfo.CurrentCulture propriedade que representa a cultura atual será usado.

O exemplo a seguir ilustra a relação entre a IFormatProvider interface e a NumberFormatInfo classe em operações de formatação definindo uma implementação personalizada IFormatProvider . Seu GetFormat método exibe o nome do tipo do objeto solicitado pela operação de formatação. Se a interface estiver solicitando um NumberFormatInfo objeto, esse método fornecerá o NumberFormatInfo objeto para a cultura atual. Como mostra a saída do exemplo, o Decimal.ToString(IFormatProvider) método solicita um NumberFormatInfo objeto para fornecer informações de formatação, enquanto o String.Format(IFormatProvider, String, Object[]) método solicita NumberFormatInfo e DateTimeFormatInfo objetos, bem como uma implementação ICustomFormatter .

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 uma IFormatProvider implementação não for fornecida explicitamente em uma chamada de método de formatação numérica, o método chamará o CultureInfo.CurrentCulture.GetFormat método, que retorna o NumberFormatInfo objeto que corresponde à cultura atual.

Cadeias de caracteres de formato e propriedades de NumberFormatInfo

Cada operação de formatação usa uma cadeia de caracteres de formato numérico padrão ou personalizada para produzir uma cadeia de caracteres de resultado de um número. 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. Esse código chama o Decimal.ToString(IFormatProvider) método para converter um Decimal valor em várias representações de cadeia de caracteres diferentes usando as convenções de formatação da cultura en-US.

using System;
using System.Globalization;

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

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

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

Em outros casos, o uso de uma cadeia de caracteres de formato é implícito. Por exemplo, no método a seguir chama o método padrão ou sem Decimal.ToString() parâmetros, o valor da Decimal instância é formatado usando o especificador de formato geral ("G") e as convenções da cultura atual, que nesse caso é a cultura en-US.

using System;

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

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

Cada cadeia de caracteres de formato numérico padrão usa uma ou mais NumberFormatInfo propriedades para determinar o padrão ou os símbolos usados na cadeia de caracteres de resultado. Da mesma forma, cada especificador de formato numérico personalizado, exceto "0" e "#", insere símbolos na cadeia de caracteres de resultado definida pelas NumberFormatInfo propriedades. A tabela a seguir lista os especificadores de formato numérico padrão e personalizado e suas propriedades associadas NumberFormatInfo . Para alterar a aparência da cadeia de caracteres de resultado para uma cultura específica, consulte a seção Modificando propriedades NumberFormatInfo . Para obter detalhes sobre o uso desses especificadores de formato, consulte Cadeias de caracteres de formato numérico padrão e cadeias de caracteres de formato numérico personalizado.

Especificador de formato Propriedades associadas
"C" ou "c" (especificador de formato de moeda) CurrencyDecimalDigits, para definir o número padrão de dígitos fracionários.

CurrencyDecimalSeparator, para definir o símbolo separador decimal.

CurrencyGroupSeparator, para definir o separador de grupo ou milhares.

CurrencyGroupSizes, para definir os tamanhos de grupos integrais.

CurrencyNegativePattern, para definir o padrão de valores de moeda negativos.

CurrencyPositivePattern, para definir o padrão de valores de moeda positivos.

CurrencySymbol, para definir o símbolo de moeda.

NegativeSign, para definir o símbolo de sinal negativo.
"D" ou "d" (especificador de formato decimal) NegativeSign, para definir o símbolo de sinal negativo.
"E" ou "e" (especificador de formato exponencial ou científico) NegativeSign, para definir o símbolo de sinal negativo na mantissa e expoente.

NumberDecimalSeparator, para definir o símbolo separador decimal.

PositiveSign, para definir o símbolo de sinal positivo no expoente.
"F" ou "f" (especificador de formato de ponto fixo) NegativeSign, para definir o símbolo de sinal negativo.

NumberDecimalDigits, para definir o número padrão de dígitos fracionários.

NumberDecimalSeparator, para definir o símbolo separador decimal.
"G" ou "g" (especificador de formato geral) NegativeSign, para definir o símbolo de sinal negativo.

NumberDecimalSeparator, para definir o símbolo separador decimal.

PositiveSign, para definir o símbolo de sinal positivo para cadeias de caracteres de resultado no formato exponencial.
"N" ou "n" (especificador de formato de número) NegativeSign, para definir o símbolo de sinal negativo.

NumberDecimalDigits, para definir o número padrão de dígitos fracionários.

NumberDecimalSeparator, para definir o símbolo separador decimal.

NumberGroupSeparator, para definir o símbolo separador de grupo (milhares).

NumberGroupSizes, para definir o número de dígitos integrais em um grupo.

NumberNegativePattern, para definir o formato de valores negativos.
"P" ou "p" (especificador de formato de porcentagem) NegativeSign, para definir o símbolo de sinal negativo.

PercentDecimalDigits, para definir o número padrão de dígitos fracionários.

PercentDecimalSeparator, para definir o símbolo separador decimal.

PercentGroupSeparator, para definir o símbolo do separador de grupo.

PercentGroupSizes, para definir o número de dígitos integrais em um grupo.

PercentNegativePattern, para definir o posicionamento do símbolo de porcentagem e o símbolo negativo para valores negativos.

PercentPositivePattern, para definir o posicionamento do símbolo de porcentagem para valores positivos.

PercentSymbol, para definir o símbolo de porcentagem.
"R" ou "r" (especificador de formato de ida e volta) NegativeSign, para definir o símbolo de sinal negativo.

NumberDecimalSeparator, para definir o símbolo separador decimal.

PositiveSign, para definir o símbolo de sinal positivo em um expoente.
"X" ou "x" (especificador de formato hexadecimal) Nenhum.
"." (especificador de formato personalizado de ponto decimal) NumberDecimalSeparator, para definir o símbolo separador decimal.
"," (especificador de formato personalizado separador de grupo) NumberGroupSeparator, para definir o símbolo separador de grupo (milhares).
"%" (especificador de formato personalizado de espaço reservado percentual) PercentSymbol, para definir o símbolo de porcentagem.
"‰" (especificador de formato personalizado de espaço reservado por mille) PerMilleSymbol, para definir o símbolo por mille.
"E" (especificador de formato personalizado de notação exponencial) NegativeSign, para definir o símbolo de sinal negativo na mantissa e expoente.

PositiveSign, para definir o símbolo de sinal positivo no expoente.

Observe que a NumberFormatInfo classe inclui uma NativeDigits propriedade que especifica os 10 dígitos base usados por uma cultura específica. No entanto, a propriedade não é usada em operações de formatação; somente os dígitos latinos básicos 0 (U+0030) a 9 (U+0039) são usados na cadeia de caracteres de resultado. Além disso, para Single e Double valores de NaN, PositiveInfinitye NegativeInfinity, a cadeia de caracteres de resultado consiste exclusivamente dos símbolos definidos pelo NaNSymbol, PositiveInfinitySymbole NegativeInfinitySymbol propriedades, respectivamente.

Modificando propriedades de NumberFormatInfo

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. Para fazer isso:

  1. Crie uma cópia de leitura/gravação de um NumberFormatInfo objeto cujas convenções de formatação você deseja modificar. Para obter mais informações, consulte a seção Instanciando um objeto NumberFormatInfo .

  2. Modifique a propriedade ou as propriedades usadas para produzir a cadeia de caracteres de resultado desejada. Para obter informações sobre como os métodos de formatação usam NumberFormatInfo propriedades para definir cadeias de caracteres de resultado, consulte a seção Formatar cadeias de caracteres e propriedades NumberFormatInfo .

  3. Use o objeto personalizado NumberFormatInfo como o IFormatProvider argumento em chamadas para formatar métodos.

Observação

Em vez de modificar dinamicamente os valores de propriedade de uma cultura sempre que um aplicativo é iniciado, você pode usar a CultureAndRegionInfoBuilder classe para definir uma cultura personalizada (uma cultura que tem um nome exclusivo e que complementa culturas existentes) ou uma cultura de substituição (uma que é usada em vez de uma cultura específica).

As seções a seguir fornecem alguns exemplos.

Modificando o símbolo e o padrão da moeda

O exemplo a seguir modifica um NumberFormatInfo objeto que representa as convenções de formatação da cultura en-US. Ele atribui o símbolo de moeda ISO-4217 à CurrencySymbol propriedade e define um padrão para valores de moeda que consiste no símbolo de moeda seguido por um espaço e um valor numérico.

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 nacional

Muitos números de identificação nacional consistem exclusivamente em dígitos e, portanto, podem ser facilmente formatados modificando as propriedades de um NumberFormatInfo objeto. Por exemplo, um número de segurança social no Estados Unidos consiste em 9 dígitos organizados da seguinte maneira: XXX-XX-XXXX. O exemplo a seguir pressupõe que os números de segurança social são armazenados como valores inteiros e os formata adequadamente.

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éricas

A análise envolve a conversão da representação de cadeia de caracteres de um número em um número. Cada tipo numérico no .NET Framework inclui dois métodos de análise sobrecarregados: Parse e TryParse. O Parse método converte uma cadeia de caracteres em um número e gera uma exceção se a conversão falhar. O TryParse método converte uma cadeia de caracteres em um número, atribui o número a um out argumento e retorna um Boolean valor que indica se a conversão foi bem-sucedida.

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

Os métodos de análise também usam implicitamente ou explicitamente um NumberFormatInfo objeto que define os símbolos e padrões específicos que podem ocorrer na cadeia de caracteres a ser analisada. Se um NumberFormatInfo objeto não for fornecido, o padrão será a NumberFormatInfo cultura atual. Para obter mais informações sobre análise, consulte os métodos de análise individuais, comoInt16.Parse(String), , Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), , Decimal.Parse(String, NumberStyles, IFormatProvider)e Double.TryParse(String, Double)BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).

O exemplo a seguir ilustra a natureza sensível à cultura das cadeias de caracteres de análise. Ele tenta analisar uma cadeia de caracteres que inclui milhares de separadores usando as convenções das culturas en-US, fr-FR e invariáveis. Uma cadeia de caracteres que inclui a vírgula como separador de grupo e o período como separador decimal não consegue analisar na cultura fr-FR, e uma cadeia de caracteres com espaço em branco como separador de grupo e uma vírgula como separador decimal não consegue analisar no en-US e culturas invariáveis.

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)

A análise geralmente ocorre em dois contextos:

  • Como uma operação projetada para converter a entrada do usuário em um valor numérico.

  • Como uma operação que foi projetada para fazer uma viagem de ida e volta com um valor numérico; ou seja, para desserializar um valor numérico que foi serializado anteriormente como uma cadeia de caracteres.

As seções a seguir discutem essas duas operações com mais detalhes.

Analisando cadeias de caracteres do usuário

Ao analisar a entrada de cadeias de caracteres numéricas pelo usuário, você sempre deverá criar uma instância de um NumberFormatInfo objeto que reflita as configurações culturais do usuário. Para obter informações sobre como instanciar um NumberFormatInfo objeto que reflete as personalizações do usuário, consulte a seção NumberFormatInfo e dados dinâmicos .

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 uma que não reflete. Nesse caso, a cultura padrão do sistema é en-US, mas o usuário definiu "" como o símbolo decimal e "." como o separador de grupo em Painel de Controle, Região e Idioma. Normalmente, esses símbolos são invertidos na cultura padrão en-US. Quando o usuário insere uma cadeia de caracteres que reflete as configurações do 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. No entanto, quando a cadeia de caracteres é analisada por um NumberFormatInfo objeto que reflete as configurações culturais padrão nos EUA, ela erra o símbolo de vírgula para um separador de grupo e retorna um resultado incorreto.

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éricos

Quando os dados numéricos são serializados no formato de cadeia de caracteres e posteriormente desserializados e analisados, as cadeias de caracteres devem ser geradas e analisadas usando as convenções da cultura invariável. As operações de formatação e análise nunca devem refletir as convenções de uma cultura específica. Se as configurações específicas da cultura forem usadas, a portabilidade dos dados será estritamente limitada; ele pode ser desserializado com êxito somente em um thread cujas configurações específicas de cultura são idênticas às do thread no qual ele foi serializado. Em alguns casos, isso significa que os dados não podem sequer ser desserializados com êxito no mesmo sistema no qual foram serializados.

O exemplo a seguir ilustra o que pode acontecer quando esse princípio é violado. Os 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 en-US. Em seguida, os dados são analisados por um thread que usa as configurações específicas da cultura pt-BR. Nesse caso, embora cada operação de análise seja bem-sucedida, os dados não são executados com êxito e ocorrem dados corrompidos. Em outros casos, uma operação de análise pode falhar e uma FormatException exceção pode ser gerada.

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

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

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

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

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

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

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

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

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

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

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

Construtores

NumberFormatInfo()

Inicializa uma nova instância gravável da classe NumberFormatInfo que é independente da cultura (invariável).

Propriedades

CurrencyDecimalDigits

Obtém ou define o número de casas decimais a ser usado em valores de moeda.

CurrencyDecimalSeparator

Obtém ou define a cadeia de caracteres a ser usada como separador decimal em valores de moeda.

CurrencyGroupSeparator

Obtém ou define a cadeia de caracteres que separa grupos de dígitos à esquerda do decimal em valores de moeda.

CurrencyGroupSizes

Obtém ou define o número de dígitos em cada grupo à esquerda do decimal em valores de moeda.

CurrencyNegativePattern

Obtém ou define o padrão de formato para valores negativos de moeda.

CurrencyPositivePattern

Obtém ou define o padrão de formato para valores positivos de moeda.

CurrencySymbol

Obtém ou define a cadeia de caracteres a ser usada como o símbolo de moeda.

CurrentInfo

Obtém o NumberFormatInfo somente leitura que formata valores com base na cultura atual.

DigitSubstitution

Obtém ou define um valor que especifica como a interface gráfica do usuário exibe a forma de um dígito.

InvariantInfo

Obtém o objeto NumberFormatInfo somente leitura que é independente da cultura (invariável).

IsReadOnly

Obtém um valor que indica se este objeto NumberFormatInfo é somente leitura.

NaNSymbol

Obtém ou define a cadeia de caracteres que representa o valor de IEEE NaN (não é um número).

NativeDigits

Obtém ou define uma matriz de cadeia de caracteres de dígitos nativos equivalentes aos dígitos ocidentais de 0 a 9.

NegativeInfinitySymbol

Obtém ou define a cadeia de caracteres que representa o infinito negativo.

NegativeSign

Obtém ou define a cadeia de caracteres que indica que o número associado é negativo.

NumberDecimalDigits

Obtém ou define o número de casas decimais a ser usado em valores numéricos.

NumberDecimalSeparator

Obtém ou define a cadeia de caracteres a ser usada como separador decimal em valores numéricos.

NumberGroupSeparator

Obtém ou define a cadeia de caracteres que separa grupos de dígitos à esquerda da vírgula decimal em valores numéricos.

NumberGroupSizes

Obtém ou define o número de dígitos em cada grupo à esquerda do decimal em valores numéricos.

NumberNegativePattern

Obtém ou define o padrão de formato para valores numéricos negativos.

PercentDecimalDigits

Obtém ou define o número de casas decimais a ser usado em valores percentuais.

PercentDecimalSeparator

Obtém ou define a cadeia de caracteres a ser usada como o separador decimal em valores de porcentagem.

PercentGroupSeparator

Obtém ou define a cadeia de caracteres que separa os grupos de dígitos à esquerda do separador decimal em valores de percentual.

PercentGroupSizes

Obtém ou define o número de dígitos em cada grupo à esquerda do decimal em valores percentuais.

PercentNegativePattern

Obtém ou define o padrão de formato dos valores percentuais negativos.

PercentPositivePattern

Obtém ou define o padrão de formato para valores percentuais positivos.

PercentSymbol

Obtém ou define a cadeia de caracteres a ser usada como o símbolo de porcentagem.

PerMilleSymbol

Obtém ou define a cadeia de caracteres a ser usada como o símbolo por milha.

PositiveInfinitySymbol

Obtém ou define a cadeia de caracteres que representa o infinito positivo.

PositiveSign

Obtém ou define a cadeia de caracteres que indica que o número associado é positivo.

Métodos

Clone()

Cria uma cópia superficial do objeto NumberFormatInfo.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.

(Herdado de Object)
GetFormat(Type)

Obtém um objeto do tipo especificado que fornece um serviço de formatação de número.

GetHashCode()

Serve como a função de hash padrão.

(Herdado de Object)
GetInstance(IFormatProvider)

Obtém o NumberFormatInfo associado ao IFormatProvider especificado.

GetType()

Obtém o Type da instância atual.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.

(Herdado de Object)
ReadOnly(NumberFormatInfo)

Retorna um wrapper NumberFormatInfo de somente leitura.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.

(Herdado de Object)

Aplica-se a

Confira também