NumberFormatInfo Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Fornece informações específicas da cultura para formatação e análise de valores numéricos.
public ref class NumberFormatInfo sealed : IFormatProviderpublic ref class NumberFormatInfo sealed : ICloneable, IFormatProviderpublic sealed class NumberFormatInfo : IFormatProviderpublic 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, IFormatProvidertype NumberFormatInfo = class
interface IFormatProvidertype 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 IFormatProviderPublic NotInheritable Class NumberFormatInfo
Implements IFormatProviderPublic 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 CultureInfo objeto correspondente 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ê formatar e analisar 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 insinuar um objeto que representa as convenções de formatação da cultura atual, a cultura invariável, uma cultura específica ou NumberFormatInfo uma cultura neutra.
Criando uma instância de um objeto NumberFormatInfo para a cultura atual
Você pode insinuar NumberFormatInfo um objeto para a cultura atual de qualquer uma das maneiras a seguir. Em cada caso, o objeto NumberFormatInfo retornado é somente leitura.
Recuperando um objeto que representa a cultura atual da propriedade e recuperando o CultureInfo CultureInfo.CurrentCulture objeto de sua CultureInfo CultureInfo.NumberFormat propriedade.
Recuperando o objeto retornado pela propriedade NumberFormatInfo
static( emSharedCurrentInfo Visual Basic).Chamando o GetInstance método com um objeto que representa a cultura CultureInfo atual.
O exemplo a seguir usa essas três maneiras de NumberFormatInfo criar objetos que representam as convenções de formatação da cultura atual. Ele também recupera o valor da propriedade IsReadOnly 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 que pode ser escrito que representa as convenções da NumberFormatInfo cultura atual de qualquer uma das seguintes maneiras:
Recuperando um objeto de qualquer uma das maneiras ilustradas no exemplo de código anterior e chamando o NumberFormatInfo Clone método no objeto NumberFormatInfo retornado. Isso cria uma cópia do objeto NumberFormatInfo original, exceto que sua IsReadOnly propriedade é
false.Chamando o CultureInfo.CreateSpecificCulture método para criar um objeto que representa a cultura atual e, em CultureInfo seguida, usando sua propriedade para recuperar o CultureInfo.NumberFormat NumberFormatInfo objeto.
O exemplo a seguir ilustra essas duas maneiras de inciar um objeto e exibe o valor de sua propriedade para ilustrar que o objeto não NumberFormatInfo IsReadOnly é 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 Windows sistema operacional do Windows permite que o usuário substitua alguns dos valores de propriedade usados em operações de formatação e análise numéricas por meio do item Região e Idioma no NumberFormatInfo 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 objeto que não reflita as substituições do usuário (e que também é leitura/gravação em vez de somente leitura) chamando o construtor e fornecendo um valor de para o argumento NumberFormatInfo CultureInfo.CultureInfo(String, Boolean) false useUserOverride . 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 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 for definida como , as propriedades , e também serão true CultureInfo.DateTimeFormat CultureInfo.NumberFormat CultureInfo.TextInfo recuperadas das configurações do usuário. Se as configurações do usuário forem incompatíveis com a cultura associada ao objeto (por exemplo, se o calendário selecionado não for um dos calendários listados pela propriedade ), os resultados dos métodos e os valores das propriedades serão CultureInfo OptionalCalendars indefinido.
Criando uma instância de um objeto NumberFormatInfo para a cultura invariável
A cultura invariável representa uma cultura insensível. Ele se baseia no idioma inglês, mas não em nenhum país/região específico que fale inglês. 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 invariável não mudam. Um 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 NumberFormatInfo por cultura.
Você pode insinuar um objeto que representa as convenções de formatação da cultura NumberFormatInfo invariável das seguintes maneiras:
Recuperando o valor da InvariantInfo propriedade. O objeto NumberFormatInfo retornado é somente leitura.
Recuperando o valor da propriedade CultureInfo.NumberFormat do objeto retornado pela propriedade CultureInfo CultureInfo.InvariantCulture . O objeto NumberFormatInfo retornado é somente leitura.
Chamando o construtor de NumberFormatInfo classe sem parâmetros. O objeto NumberFormatInfo retornado é leitura/gravação.
O exemplo a seguir usa cada um desses métodos para incorrer em um objeto que representa a NumberFormatInfo 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 que é falado em um país/região específico. Por exemplo, en-US é uma cultura específica que representa o idioma em inglês falado no Estados Unidos e en-CA é uma cultura específica que representa o idioma inglês falado no Canadá. Você pode insinuar um objeto que representa as convenções de NumberFormatInfo formatação de uma cultura específica das seguintes maneiras:
Chamando o CultureInfo.GetCultureInfo(String) método e recuperando o valor da propriedade do objeto CultureInfo NumberFormat retornado. O objeto NumberFormatInfo retornado é somente leitura.
Passando um CultureInfo objeto que representa a cultura cujo objeto você deseja recuperar para o método NumberFormatInfo GetInstance estático. O objeto NumberFormatInfo retornado é leitura/gravação.
Chamando o CultureInfo.CreateSpecificCulture método e recuperando o valor da propriedade do objeto CultureInfo NumberFormat retornado. O objeto NumberFormatInfo retornado é leitura/gravação.
Chamando um dos construtores de classe e recuperando o CultureInfo.CultureInfo valor da propriedade do objeto CultureInfo NumberFormat retornado. O objeto NumberFormatInfo retornado é leitura/gravação.
O exemplo a seguir usa essas quatro maneiras de criar um objeto que reflete as convenções de formatação da cultura NumberFormatInfo 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, ele é 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 objeto que representa as convenções de formatação de uma cultura neutra da mesma maneira que cria um objeto que representa as convenções de formatação de NumberFormatInfo NumberFormatInfo uma cultura específica.
Observação
No .NET Framework 3.5 e versões anteriores, tentar recuperar um objeto que reflete as convenções de formatação de uma cultura NumberFormatInfo neutra lança uma NotSupportedException exceção.
No entanto, como ele é independente de um país/região específico, uma cultura neutra não tem informações de formatação específicas da cultura. Em vez de popular o objeto com valores genéricos, o .NET Framework retorna um objeto que reflete as convenções de formatação de uma cultura específica que é um filho da NumberFormatInfo NumberFormatInfo cultura neutra. Por exemplo, o objeto para a cultura en neutra reflete as convenções de formatação da cultura en-US e o objeto para a cultura fr reflete as convenções de formatação da cultura NumberFormatInfo NumberFormatInfo fr-FR.
Você pode usar código como o seguinte para determinar quais convenções de formatação de cultura específicas 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 formatação de valores numéricos fornecidos pela classe são dinâmicos, assim como os NumberFormatInfo dados culturais fornecidos pela CultureInfo classe . Você não deve fazer suposições sobre a estabilidade de valores para objetos NumberFormatInfo associados a objetos CultureInfo específicos. Somente os dados fornecidos pela cultura invariável e seu objeto NumberFormatInfo associado são estáveis. Outros dados podem ser alternados entre sessões de aplicativo ou até mesmo em uma única sessão, pelos seguintes motivos:
Atualizações do sistema. Preferências culturais, como o símbolo de moeda ou formatos de moeda, mudam ao longo do tempo. Quando isso acontece, Windows Update inclui alterações no valor NumberFormatInfo da 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 em valores de propriedade. Várias propriedades relacionadas à cultura podem ser alteradas em tempo de executar, o que, por sua vez, faz NumberFormatInfo com que os dados mudem. Por exemplo, a cultura atual pode ser alterada programaticamente ou por meio da ação do usuário. Quando isso acontece, NumberFormatInfo o objeto retornado pela propriedade muda para um objeto associado à cultura CurrentInfo atual.
Preferências do usuário. 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 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 propriedade for definida como (seu valor padrão), as propriedades do objeto também CultureInfo.UseUserOverride
trueserão NumberFormatInfo recuperadas das configurações do usuário.
A partir do .NET Framework 2.0, todas as propriedades que o usuário substitui de um objeto são inicializadas NumberFormatInfo 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 mudar 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 NumberFormatInfo em objetos que representam a mesma cultura que a cultura atual. A tabela a seguir lista as maneiras pelas quais um objeto pode ser recuperado e indica se o objeto resultante reflete as NumberFormatInfo substituições do usuário.
| Fonte de objeto CultureInfo e NumberFormatInfo | Reflete as substituições do usuário |
|---|---|
Propriedade CultureInfo.CurrentCulture.NumberFormat |
Sim |
| Propriedade NumberFormatInfo.CurrentInfo | Sim |
| Método CultureInfo.CreateSpecificCulture | Sim |
| 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 para exibir dados numéricos. Para aplicativos de servidor ou aplicativos autônomos, você não deve respeitar as substituições de usuário. No entanto, se você estiver usando o NumberFormatInfo objeto explicitamente ou implicitamente para manter dados numéricos no formulário de cadeia de caracteres, deverá usar um NumberFormatInfo objeto que reflita as convenções de formatação da cultura invariável ou deve especificar uma cadeia de caracteres de formato numérico personalizado 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. Isso inclui chamadas para os seguintes métodos:
Todos os métodos de formatação numérica, como Int32.ToString , Double.ToString e Convert.ToString(Int32) .
O método de formatação composta principal, String.Format .
Outros métodos de formatação compostos, 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) . Esse é um método de retorno de chamada que é passado Type para um 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 ele não puder fornecer uma instância do tipo. o .NET Framework fornece duas IFormatProvider implementações para formatar números:
A CultureInfo classe, que representa uma cultura específica (ou uma linguagem específica em um país/região específico). Em uma operação de formatação numérica, o CultureInfo.GetFormat método retorna o NumberFormatInfo objeto associado à 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 explicitamente a um método de formatação, 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 IFormatProvider implementação personalizada. 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 a saída do exemplo mostra, 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 {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 um número de representações de cadeias 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 parâmetros Decimal.ToString() , 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 que são definidos por NumberFormatInfo Propriedades. A tabela a seguir lista os especificadores de formato numérico padrão e personalizado e suas NumberFormatInfo propriedades associadas. Para alterar a aparência da cadeia de caracteres de resultado para uma cultura específica, consulte a seção modificando as propriedades de 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 de separador decimal. CurrencyGroupSeparator, para definir o separador de grupo ou de milhares. CurrencyGroupSizes, para definir os tamanhos de grupos integrais. CurrencyNegativePattern, para definir o padrão de valores monetários negativos. CurrencyPositivePattern, para definir o padrão de valores monetários 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 no mantissa e no expoente. NumberDecimalSeparator, para definir o símbolo de 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 de separador decimal. |
| "G" ou "g" (especificador de formato geral) | NegativeSign, para definir o símbolo de sinal negativo. NumberDecimalSeparator, para definir o símbolo de separador decimal. PositiveSign, para definir o símbolo de sinal positivo para cadeias de caracteres de resultado em 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 de separador decimal. NumberGroupSeparator, para definir o símbolo de 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 PERCENT) | 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 de 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 de 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 de separador decimal. |
| "," (especificador de formato personalizado do separador de grupo) | NumberGroupSeparator, para definir o símbolo de separador de grupo (milhares). |
| "%" (o especificador de formato personalizado de espaço reservado de percentual) | PercentSymbol, para definir o símbolo de porcentagem. |
| "‰" (por especificador de formato personalizado de espaço reservado 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 no mantissa e no expoente. PositiveSign, para definir o símbolo de sinal positivo no expoente. |
Observe que a NumberFormatInfo classe inclui uma NativeDigits propriedade que especifica os dígitos de base 10 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 os Double valores de NaN , PositiveInfinity e NegativeInfinity , a cadeia de caracteres de resultado consiste exclusivamente nos símbolos definidos pelas NaNSymbol Propriedades, PositiveInfinitySymbol e NegativeInfinitySymbol , 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:
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 .
Modifique a propriedade ou as propriedades que são usadas para produzir a cadeia de caracteres de resultado desejada. Para obter informações sobre como os métodos NumberFormatInfo de formatação usam propriedades para definir cadeias de caracteres de resultado, consulte a seção Format Strings and NumberFormatInfo Properties .
Use o NumberFormatInfo objeto personalizado como o IFormatProvider argumento em chamadas para métodos de formatação.
Observação
Em vez de modificar dinamicamente os valores de propriedade de uma cultura cada vez 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 as culturas existentes) ou uma cultura substituta (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 consistem 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 de dígitos e, portanto, podem ser facilmente formatados modificando as propriedades de um NumberFormatInfo objeto. Por exemplo, um número de seguro 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 uma cadeia de caracteres de um número em um número. cada tipo numérico na .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 implicitamente ou explicitamente usam 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 sucedido. Se um NumberStyles valor não for fornecido na chamada de método, o padrão será um NumberStyles valor que inclui os Float AllowThousands sinalizadores e, 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á o NumberFormatInfo para a cultura atual. Para obter mais informações sobre a 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 de analisar cadeias de caracteres. Ele tenta analisar uma cadeia de caracteres que inclui separadores de milhar usando as convenções das culturas en-US, fr-FR e invariáveis. Uma cadeia de caracteres que inclui a vírgula como um separador de grupo e o período como um separador decimal não analisa 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 não é analisada nas culturas en-US e invariável.
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 que é projetada para converter a entrada do usuário em um valor numérico.
Como uma operação que é projetada para fazer ida e volta de um valor numérico; ou seja, para desserializar um valor numérico que foi previamente serializado 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 deve criar uma instância de um NumberFormatInfo objeto que reflita as configurações culturais do usuário. Para obter informações sobre como criar uma instância de 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 faz isso. Nesse caso, a cultura de sistema padrão é 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 revertidos na cultura en-US padrão. 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 en-US padrão, ela inconsiste em um 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 forem usadas configurações específicas de cultura, a portabilidade dos dados será estritamente limitada; Ele pode ser desserializado com êxito apenas 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 nem ser desserializados com êxito no mesmo sistema em que foi serializado.
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 de cultura da cultura en-US. Os dados são então analisados por um thread que usa as configurações específicas de cultura da cultura pt-BR. Nesse caso, embora cada operação de análise tenha êxito, os dados não viajam com êxito e a corrupção de dados ocorre. 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) |