NumberFormatInfo Classe

Definição

Espaço de Nomes:: System.Globalization

Assemblagens:: mscorlib.dll, System.Globalization.dll

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagem:: System.Globalization.dll

Assemblagem:: System.Runtime.dll

Assemblagem:: mscorlib.dll

Assemblagem:: netstandard.dll

Origem:: NumberFormatInfo.cs

Origem:: NumberFormatInfo.cs

Origem:: NumberFormatInfo.cs

Origem:: NumberFormatInfo.cs

Origem:: NumberFormatInfo.cs

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Fornece informação específica por 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: Object
NumberFormatInfo

Atributos: SerializableAttribute ComVisibleAttribute

Implementações: IFormatProvider ICloneable

Observações

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.

Instanciar um objeto NumberFormatInfo

Você pode instanciar um NumberFormatInfo objeto que representa as convenções de formatação da cultura atual, a cultura invariante, uma cultura específica ou uma cultura neutra.

Instanciar um objeto NumberFormatInfo para a cultura atual

Você pode instanciar um NumberFormatInfo objeto para a cultura atual de qualquer uma das seguintes maneiras. Em cada caso, o objeto NumberFormatInfo retornado é apenas de leitura.

Recuperando um objeto CultureInfo que representa a cultura atual a partir da propriedade CultureInfo.CurrentCulture, e recuperando o objeto NumberFormatInfo da propriedade CultureInfo.NumberFormat.
Recuperar o objeto NumberFormatInfo retornado pela propriedade static (Shared no Visual Basic CurrentInfo).
Chamando o GetInstance método com um CultureInfo objeto que representa a cultura atual.

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 obtém o valor da propriedade IsReadOnly para ilustrar que cada objeto é apenas leitura.

using System;
using System.Globalization;

public class InstantiateEx1
{
    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

Você pode criar um objeto gravável NumberFormatInfo que represente as convenções da cultura atual de qualquer uma das seguintes maneiras:

Recuperando um objeto de alguma das maneiras NumberFormatInfo ilustradas no exemplo de código anterior e chamando o método Clone no objeto NumberFormatInfo retornado. Isso cria uma cópia do objeto original NumberFormatInfo , exceto que sua IsReadOnly propriedade é false.
Chamando o CultureInfo.CreateSpecificCulture método para criar um CultureInfo objeto que representa a cultura atual e, em seguida, usando sua CultureInfo.NumberFormat propriedade para recuperar o NumberFormatInfo objeto.

O exemplo a seguir demonstra essas duas maneiras de instanciar um NumberFormatInfo objeto e exibe o valor de sua IsReadOnly propriedade para demonstrar que o objeto não é de leitura única.

using System;
using System.Globalization;

public class InstantiateEx2
{
    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

Observe que o sistema operativo Windows permite que o utilizador altere alguns dos NumberFormatInfo valores de propriedade usados em operações de formatação e análise numérica, por meio do item Região e Idioma no Painel de Controlo. Por exemplo, um usuário cuja cultura é inglês (Estados Unidos) pode optar por exibir valores de moeda como 1,1 USD em vez do padrão de $1,1. Os NumberFormatInfo objetos recuperados das maneiras discutidas anteriormente refletem estas personalizações do utilizador. Se isso for indesejável, você pode criar um NumberFormatInfo objeto que não reflita substituições de 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 de false para 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 $ para USD.

using System;
using System.Globalization;

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

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

        culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
        Console.WriteLine($"Culture Name:    {culture.Name}");
        Console.WriteLine($"User Overrides:  {culture.UseUserOverride}");
        Console.WriteLine($"Currency Symbol: {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: $

Se a CultureInfo.UseUserOverride propriedade estiver definida como true, as propriedades CultureInfo.DateTimeFormat, CultureInfo.NumberFormate CultureInfo.TextInfo também serão recuperadas das configurações do usuário. Se as configurações do usuário forem incompatíveis com a cultura associada ao CultureInfo 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.

Instanciar um objeto NumberFormatInfo para a cultura invariante

A cultura invariante representa uma cultura que é insensível à cultura. 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 mudar para refletir novas convenções culturais ou preferências do usuário, os dados da cultura invariante não mudam. Um NumberFormatInfo objeto que representa as convenções de formatação da cultura invariante 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 invariante das seguintes maneiras:

Recuperando o valor da propriedade InvariantInfo. O objeto retornado NumberFormatInfo é somente leitura.
Ao recuperar o valor da propriedade CultureInfo.NumberFormat do objeto CultureInfo que é retornado pela propriedade CultureInfo.InvariantCulture. O objeto retornado NumberFormatInfo é somente leitura.
Invocando o construtor da classe sem parâmetros NumberFormatInfo. O objeto NumberFormatInfo retornado é de leitura e escrita.

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

using System;
using System.Globalization;

public class InstantiateEx4
{
    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

Instanciar um objeto NumberFormatInfo para uma cultura específica

Uma cultura específica representa uma língua falada num determinado país/região. Por exemplo, en-US é uma cultura específica que representa a língua inglesa falada nos Estados Unidos, e en-CA é uma cultura específica que representa a língua inglesa falada no Canadá. Você pode instanciar um NumberFormatInfo objeto que representa as convenções de formatação de uma cultura específica das seguintes maneiras:

Ao chamar o método CultureInfo.GetCultureInfo(String) e recuperar o valor da propriedade CultureInfo do objeto retornado NumberFormat. O objeto retornado NumberFormatInfo é somente leitura.
Ao passar um CultureInfo objeto que representa a cultura cujo NumberFormatInfo objeto se pretende recuperar para o método estático GetInstance. O objeto NumberFormatInfo retornado é de leitura e escrita.
Ao chamar o método CultureInfo.CreateSpecificCulture e recuperar o valor da propriedade CultureInfo do objeto retornado NumberFormat. O objeto NumberFormatInfo retornado é de leitura e escrita.
Chamando um dos construtores da classe CultureInfo.CultureInfo e recuperando o valor da propriedade CultureInfo do objeto retornado NumberFormat. O objeto NumberFormatInfo retornado é de leitura e escrita.

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 é de leitura apenas.

using System;
using System.Globalization;

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

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

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

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

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

Instanciar um objeto NumberFormatInfo para uma cultura neutra

Uma cultura neutra representa uma cultura ou língua independente de um país/região. É tipicamente o progenitor de uma ou mais culturas específicas. Por exemplo, fr é uma cultura neutra para a língua francesa 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.

No entanto, por ser independente de um país/região específico, uma cultura neutra carece de informações de formatação específicas da cultura. Em vez de preencher o objeto com valores genéricos, .NET retorna um objeto NumberFormatInfo que reflete as convenções de formatação de uma cultura específica, filha da cultura neutra. Por exemplo, o NumberFormatInfo objeto para a 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 um 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 InstantiateEx6
{
    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 '{name}' matches '{ci.Name}'");
                hasOneMatch = true;
            }
        }
        if (!hasOneMatch)
            Console.WriteLine($"NumberFormatInfo object for '{name}' --> No Match");

        Console.WriteLine();
    }
}

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 suposições sobre a estabilidade de valores para NumberFormatInfo objetos associados a objetos específicos CultureInfo . Apenas os dados fornecidos pela cultura invariante e seu objeto associado NumberFormatInfo são estáveis. Outros dados podem mudar entre sessões de aplicação, ou mesmo dentro de uma única sessão, pelos seguintes motivos:

Atualizações do sistema. As preferências culturais, como o símbolo da moeda ou os formatos da moeda, mudam ao longo do tempo. Quando isso acontece, o Windows Update inclui alterações no valor da propriedade NumberFormatInfo 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 de propriedade. Várias propriedades relacionadas com a cultura podem mudar em tempo de execução, o que, por sua vez, provoca NumberFormatInfo alterações nos dados. Por exemplo, a cultura atual pode ser alterada programaticamente ou por meio de ação do usuário. Quando isso acontece, o NumberFormatInfo CurrentInfo objeto retornado pela propriedade muda para um objeto associado à cultura atual.
Preferências do utilizador. Os usuários do seu aplicativo podem substituir alguns dos valores associados à cultura atual do sistema por meio das opções de região e idioma no 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 estiver definida como true (seu valor padrão), as NumberFormatInfo propriedades do objeto também serão recuperadas das configurações do usuário.

Todas as propriedades substituíveis pelo usuário de um NumberFormatInfo objeto são inicializadas quando o objeto é criado. Existe ainda a possibilidade de inconsistência, porque nem a criação de objetos nem o processo de sobreposição do usuário são operações atômicas, e os valores relevantes podem mudar durante a criação do objeto. No entanto, estas incoerências devem ser extremamente raras.

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

Fonte do objeto CultureInfo e NumberFormatInfo	Reflete substituições do usuário
`CultureInfo.CurrentCulture.NumberFormat` propriedade	Sim
NumberFormatInfo.CurrentInfo propriedade	Sim
CultureInfo.CreateSpecificCulture método	Sim
CultureInfo.GetCultureInfo método	No
CultureInfo(String) construtor	Sim
CultureInfo.CultureInfo(String, Boolean) construtor	Depende do valor do `useUserOverride` parâmetro

A menos que haja uma razão convincente para fazer o contrário, deve-se respeitar as substituições do utilizador ao usar o objeto NumberFormatInfo em aplicações cliente para formatar e analisar a entrada do utilizador ou para exibir dados numéricos. Para aplicações de servidor ou aplicações não assistidas, não se deve respeitar as substituições do utilizador. No entanto, se você estiver usando o NumberFormatInfo objeto explícita ou implicitamente para persistir dados numéricos em forma de cadeia de caracteres, deverá usar um NumberFormatInfo objeto que reflita as convenções de formatação da cultura invariante ou especificar 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 implícita ou explicitamente em todas as operações de formatação numérica. Estes incluem chamadas para os seguintes métodos:

Todos os métodos de formatação numérica, como Int32.ToString, Double.ToStringe Convert.ToString(Int32).
O principal método de formatação composta, String.Format.
Outros métodos de formatação composta, como Console.WriteLine(String, Object[]) e StringBuilder.AppendFormat(String, Object[]).

Todas as operações de formatação numérica fazem uso de uma IFormatProvider implementação. A IFormatProvider interface inclui um único método, GetFormat(Type). Este é um método callback ao qual é passado um objeto Type 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 fornece duas IFormatProvider implementações para formatar números:

A CultureInfo classe, que representa uma cultura específica (ou um idioma específico em um país/região específico). Em uma operação de formatação numérica, o CultureInfo.GetFormat método retorna o objeto associado à NumberFormatInfo sua CultureInfo.NumberFormat propriedade.
A NumberFormatInfo classe, que fornece informações sobre as convenções de formatação de sua cultura associada. O NumberFormatInfo.GetFormat método retorna uma instância de si mesmo.

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 ICustomFormatter implementação.

using System;
using System.Globalization;

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

public class FormatProviderEx
{
    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

Se uma IFormatProvider implementação não for fornecida explicitamente numa chamada de método de formatação numérica, o método chama o CultureInfo.CurrentCulture.GetFormat método, que retorna o NumberFormatInfo objeto que corresponde à cultura vigente.

Formatos de texto e propriedades do 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 a partir 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. Este código chama o método Decimal.ToString(IFormatProvider) para converter um valor Decimal em várias representações diferentes de cadeias de texto, utilizando as convenções de formatação da cultura de en-US.

using System;
using System.Globalization;

public class PropertiesEx1
{
    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

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

using System;

public class PropertiesEx2
{
    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

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 que são definidos por 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 Modify NumberFormatInfo propriedades. 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 personalizadas.

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 do separador decimal. CurrencyGroupSeparator, para definir o separador de grupo ou de milhares. CurrencyGroupSizes, para definir os tamanhos dos grupos integrais. CurrencyNegativePattern, para definir o padrão de valores cambiais negativos. CurrencyPositivePattern, para definir o padrão de valores positivos da moeda. CurrencySymbol, para definir o símbolo da moeda. NegativeSign, para definir o símbolo do sinal negativo.
"D" ou "d" (especificador de formato decimal)	NegativeSign, para definir o símbolo do sinal negativo.
"E" ou "e" (especificador de formato exponencial ou científico)	NegativeSign, para definir o símbolo do sinal negativo na mantissa e expoente. NumberDecimalSeparator, para definir o símbolo do separador decimal. PositiveSign, para definir o símbolo do sinal positivo no expoente.
"F" ou "f" (especificador de formato de ponto fixo)	NegativeSign, para definir o símbolo do sinal negativo. NumberDecimalDigits, para definir o número padrão de dígitos fracionários. NumberDecimalSeparator, para definir o símbolo do separador decimal.
"G" ou "g" (especificador de formato geral)	NegativeSign, para definir o símbolo do sinal negativo. NumberDecimalSeparator, para definir o símbolo do separador decimal. PositiveSign, para definir o símbolo de sinal positivo para cadeias de resultados em formato exponencial.
"N" ou "n" (especificador de formato numérico)	NegativeSign, para definir o símbolo do sinal negativo. NumberDecimalDigits, para definir o número padrão de dígitos fracionários. NumberDecimalSeparator, para definir o símbolo do separador decimal. NumberGroupSeparator, para definir o símbolo do separador de grupo (milhares). NumberGroupSizes, para definir o número de dígitos integrais em um grupo. NumberNegativePattern, para definir o formato dos valores negativos.
"P" ou "p" (especificador de formato percentual)	NegativeSign, para definir o símbolo do sinal negativo. PercentDecimalDigits, para definir o número padrão de dígitos fracionários. PercentDecimalSeparator, para definir o símbolo do separador decimal. PercentGroupSeparator, para definir o símbolo 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 do 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 percentagem.
"R" ou "r" (especificador de formato de ida e regresso)	NegativeSign, para definir o símbolo do sinal negativo. NumberDecimalSeparator, para definir o símbolo do 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 do separador decimal.
"," (especificador de formato personalizado do separador de grupo)	NumberGroupSeparator, para definir o símbolo do separador de grupo (milhares).
"%" (especificador de formato percentual personalizado)	PercentSymbol, para definir o símbolo de percentagem.
"‰" (especificador de formato personalizado por mil)	PerMilleSymbol, para definir o símbolo per mille.
"E" (especificador de formato personalizado de notação exponencial)	NegativeSign, para definir o símbolo do sinal negativo na mantissa e expoente. PositiveSign, para definir o símbolo do sinal positivo no expoente.

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

Modificar propriedades 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 efetuar este procedimento:

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 Instanciar um objeto NumberFormatInfo .
Modifique a propriedade ou propriedades que são usadas para produzir a cadeia de caracteres de resultado desejada. Para obter informações sobre como os métodos de formatação utilizam propriedades NumberFormatInfo para definir cadeias de caracteres de resultado, consulte a seção Cadeias de Formatação e Propriedades de NumberFormatInfo.
Use o objeto personalizado NumberFormatInfo como argumento IFormatProvider em chamadas para métodos de formatação.

Note

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

As seções a seguir fornecem alguns exemplos.

Modificar 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

Formatar um número de identificação nacional

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

using System;
using System.Globalization;

public class CustomizeSSNEx
{
    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

Analisar cadeias 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 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 lança 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 implícita ou explicitamente 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 for bem-sucedida. Caso um valor NumberStyles não seja fornecido na chamada de método, o valor padrão será NumberStyles, que inclui os sinalizadores Float e AllowThousands, especificando que a string analisada pode incluir símbolos de agrupamento, um separador decimal, um sinal negativo e caracteres de espaço em branco, ou pode ser a representação de um número em notação científica.

Os métodos de análise também usam implícita 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á o NumberFormatInfo para a cultura atual. 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).

O exemplo a seguir ilustra a natureza sensível à cultura da análise de cadeias de caracteres. Ele tenta analisar uma cadeia de caracteres que inclui milhares de separadores usando as convenções das culturas en-US, fr-FRe invariantes. Uma cadeia de caracteres que inclui a vírgula como um separador de grupo e o ponto como um separador decimal falha ao analisar na cultura fr-FR, e uma cadeia de caracteres com espaço em branco como um separador de grupo e uma vírgula como um separador decimal falha ao analisar nas culturas en-US e invariantes.

using System;
using System.Globalization;

public class ParseEx1
{
    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($"'{value}' --> {amount} ({name})");
                }
                catch (FormatException)
                {
                    Console.WriteLine($"'{value}': FormatException ({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)

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 é projetada para ida e volta 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 mais detalhadamente.

Analisar cadeias de caracteres de usuário

Ao analisar cadeias de caracteres numéricas inseridas pelo usuário, você sempre deve instanciar 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 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 outra 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 no 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 configurações padrão en-US culturais, ela confunde o símbolo de vírgula com um separador de grupo e retorna um resultado incorreto.

using System;
using System.Globalization;

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

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

        try
        {
            Console.WriteLine($"{custCulture.Name} culture reflects user overrides: {custCulture.UseUserOverride}");
            Decimal amount = Decimal.Parse(value, custCulture);
            Console.WriteLine($"'{value}' --> {amount.ToString(CultureInfo.InvariantCulture)}");
        }
        catch (FormatException)
        {
            Console.WriteLine($"Unable to parse '{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

Serializar e desserializar dados numéricos

Quando os dados numéricos são serializados em 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 invariante. As operações de formatação e análise nunca devem refletir as convenções de uma cultura específica. Se forem utilizadas definiçõ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 da cultura são idênticas às do thread no qual ele foi serializado. Em alguns casos, isso significa que os dados não podem nem mesmo ser desserializados com êxito no mesmo sistema em que foram serializados.

O exemplo a seguir ilustra o que pode acontecer quando esse princípio é violado. Os valores de ponto flutuante em um array são convertidos em cadeias quando o thread atual usa as configurações específicas da cultura en-US. Os dados são então analisados por um thread que usa as configurações específicas da cultura do pt-BR. Nesse caso, embora cada operação de análise sintática seja bem-sucedida, os dados não conseguem ser transferidos corretamente de volta, e ocorre corrupção de dados. Em outros casos, uma operação de análise pode falhar e uma FormatException exceção pode ser lançada.

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

public class ParsePersistedEx
{
    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

Example

  The following example shows how to retrieve a <xref:System.Globalization.NumberFormatInfo> object for a corresponding <xref:System.Globalization.CultureInfo> object, and use the retrieved object to query number formatting information for the particular culture.

  :::code language="csharp" source="~/snippets/csharp/System.Globalization/NumberFormatInfo/Overview/NumberFormatInfo.cs" id="Snippet1":::
  :::code language="vb" source="~/snippets/visualbasic/System.Globalization/NumberFormatInfo/Overview/numberformatinfo.vb" id="Snippet1":::

Construtores

Name	Descrição
NumberFormatInfo()	Inicializa uma nova instância gravável da NumberFormatInfo classe que é independente da cultura (invariante).

Propriedades

Name	Descrição
CurrencyDecimalDigits	Obtém ou define o número de casas decimais a usar nos valores da moeda.
CurrencyDecimalSeparator	Obtém ou define a cadeia para ser usada como separador decimal nos valores da moeda.
CurrencyGroupSeparator	Obtém ou define a cadeia que separa grupos de dígitos à esquerda do decimal nos valores da moeda.
CurrencyGroupSizes	Obtém ou define o número de dígitos em cada grupo à esquerda do decimal nos valores da moeda.
CurrencyNegativePattern	Obtém ou define o padrão de formato para valores monetários negativos.
CurrencyPositivePattern	Obtém ou define o padrão de formato para valores monetários positivos.
CurrencySymbol	Recebe ou define a corda para usar como símbolo de moeda.
CurrentInfo	Recebe um modo somente NumberFormatInfo de leitura que formata os valores com base na cultura atual.
DigitSubstitution	Recebe ou define um valor que especifica como a interface gráfica do utilizador mostra a forma de um dígito.
InvariantInfo	Obtém um objeto apenas NumberFormatInfo de leitura que é independente da cultura (invariante).
IsReadOnly	Obtém um valor que indica se este NumberFormatInfo objeto é apenas leitura.
NaNSymbol	Recebe ou define a cadeia que representa o valor IEEE NaN (não um número).
NativeDigits	Obtém ou estabelece um array de cadeias de dígitos nativos equivalentes aos dígitos ocidentais de 0 a 9.
NegativeInfinitySymbol	Obtém ou define a cadeia que representa o infinito negativo.
NegativeSign	Obtém ou define a cadeia que indica que o número associado é negativo.
NumberDecimalDigits	Obtém ou define o número de casas decimais a usar nos valores numéricos.
NumberDecimalSeparator	Obtém ou define a cadeia para ser usada como separador decimal em valores numéricos.
NumberGroupSeparator	Obtém ou define a cadeia que separa grupos de dígitos à esquerda do 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 usar em valores percentuais.
PercentDecimalSeparator	Obtém ou define a cadeia para ser usada como separador decimal em valores percentuais.
PercentGroupSeparator	Obtém ou define a cadeia que separa grupos de dígitos à esquerda do decimal em valores percentuais.
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 para valores percentuais negativos.
PercentPositivePattern	Obtém ou define o padrão de formato para valores percentuais positivos.
PercentSymbol	Obtém ou define a cadeia para usar como símbolo percentual.
PerMilleSymbol	Obtém ou define a corda para usar como símbolo per mille.
PositiveInfinitySymbol	Obtém ou define a cadeia que representa o infinito positivo.
PositiveSign	Obtém ou define a cadeia que indica que o número associado é positivo.

Métodos

Name	Descrição
Clone()	Cria uma cópia superficial do NumberFormatInfo objeto.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetFormat(Type)	Recebe um objeto do tipo especificado que fornece um serviço de formatação numérica.
GetHashCode()	Serve como função de hash predefinida. (Herdado de Object)
GetInstance(IFormatProvider)	Obtém o NumberFormatInfo associado ao especificado IFormatProvider.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do atual Object. (Herdado de Object)
ReadOnly(NumberFormatInfo)	Devolve uma embalagem de apenas NumberFormatInfo leitura.
ToString()	Devolve uma cadeia que representa o objeto atual. (Herdado de Object)

Aplica-se a

Ver também

Comentários

Esta página foi útil?