NumberFormatInfo NumberFormatInfo NumberFormatInfo NumberFormatInfo Class

Definición

Proporciona información de formato específica de la referencia cultural y los valores numéricos de análisis.Provides culture-specific information for formatting and parsing numeric values.

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

Ejemplos

El ejemplo siguiente muestra cómo recuperar un NumberFormatInfo objeto correspondiente CultureInfo de objetos y usar el objeto recuperado a información para la referencia cultural concreta de formato de número de consultas.The following example shows how to retrieve a NumberFormatInfo object for a corresponding CultureInfo object, and use the retrieved object to query number formatting information for the particular culture.

using namespace System;
using namespace System::Globalization;
using namespace System::Text;

int main()
{
    StringBuilder^ builder = gcnew StringBuilder();

    // Loop through all the specific cultures known to the CLR.
    for each(CultureInfo^ culture in 
        CultureInfo::GetCultures (CultureTypes::SpecificCultures)) 
    {
        // Only show the currency symbols for cultures 
        // that speak English.
        if (culture->TwoLetterISOLanguageName == "en")
        {
            // Display the culture name and currency symbol.
            NumberFormatInfo^ numberFormat = culture->NumberFormat;
            builder->AppendFormat("The currency symbol for '{0}'"+
                "is '{1}'",culture->DisplayName,
                numberFormat->CurrencySymbol);
            builder->AppendLine();
        }
    }
    Console::WriteLine(builder);
}

// This code produces the following output.
//
// The currency symbol for 'English (United States)' is '$'
// The currency symbol for 'English (United Kingdom)' is 'Ј'
// The currency symbol for 'English (Australia)' is '$'
// The currency symbol for 'English (Canada)' is '$'
// The currency symbol for 'English (New Zealand)' is '$'
// The currency symbol for 'English (Ireland)' is '?'
// The currency symbol for 'English (South Africa)' is 'R'
// The currency symbol for 'English (Jamaica)' is 'J$'
// The currency symbol for 'English (Caribbean)' is '$'
// The currency symbol for 'English (Belize)' is 'BZ$'
// The currency symbol for 'English (Trinidad and Tobago)' is 'TT$'
// The currency symbol for 'English (Zimbabwe)' is 'Z$'
// The currency symbol for 'English (Republic of the Philippines)' is 'Php'
using System;
using System.Globalization;
using System.Text;

public sealed class App 
{
    static void Main() 
    {
        StringBuilder sb = new StringBuilder();

        // Loop through all the specific cultures known to the CLR.
        foreach (CultureInfo ci in CultureInfo.GetCultures(CultureTypes.SpecificCultures)) 
        {
            // Only show the currency symbols for cultures that speak English.
            if (ci.TwoLetterISOLanguageName != "en") continue;
             
            // Display the culture name and currency symbol.
            NumberFormatInfo nfi = ci.NumberFormat;
            sb.AppendFormat("The currency symbol for '{0}' is '{1}'",
                ci.DisplayName, nfi.CurrencySymbol);
            sb.AppendLine();
        }
        Console.WriteLine(sb.ToString());
    }
}

// This code produces the following output.
//
// The currency symbol for 'English (United States)' is '$'
// The currency symbol for 'English (United Kingdom)' is '�'
// The currency symbol for 'English (Australia)' is '$'
// The currency symbol for 'English (Canada)' is '$'
// The currency symbol for 'English (New Zealand)' is '$'
// The currency symbol for 'English (Ireland)' is '?'
// The currency symbol for 'English (South Africa)' is 'R'
// The currency symbol for 'English (Jamaica)' is 'J$'
// The currency symbol for 'English (Caribbean)' is '$'
// The currency symbol for 'English (Belize)' is 'BZ$'
// The currency symbol for 'English (Trinidad and Tobago)' is 'TT$'
// The currency symbol for 'English (Zimbabwe)' is 'Z$'
// The currency symbol for 'English (Republic of the Philippines)' is 'Php'
Imports System.Globalization
Imports System.Text

Public Module Example
   Public Sub Main() 
      Dim sb As New StringBuilder()

      ' Loop through all the specific cultures known to the CLR.
      For Each ci In CultureInfo.GetCultures(CultureTypes.SpecificCultures) 
         ' Only show the currency symbols for cultures that speak English.
         If ci.TwoLetterISOLanguageName <> "en" Then Continue For

         ' Display the culture name and currency symbol.
         Dim nfi As NumberFormatInfo = ci.NumberFormat
         sb.AppendFormat("The currency symbol for '{0}' is '{1}'",
                         ci.DisplayName, nfi.CurrencySymbol)
         sb.AppendLine()
      Next
      Console.WriteLine(sb.ToString())
   End Sub
End Module
' The example displays output like the following:
'       The currency symbol for 'English (United States)' is '$'
'       The currency symbol for 'English (United Kingdom)' is '�'
'       The currency symbol for 'English (Australia)' is '$'
'       The currency symbol for 'English (Canada)' is '$'
'       The currency symbol for 'English (New Zealand)' is '$'
'       The currency symbol for 'English (Ireland)' is '?'
'       The currency symbol for 'English (South Africa)' is 'R'
'       The currency symbol for 'English (Jamaica)' is 'J$'
'       The currency symbol for 'English (Caribbean)' is '$'
'       The currency symbol for 'English (Belize)' is 'BZ$'
'       The currency symbol for 'English (Trinidad and Tobago)' is 'TT$'
'       The currency symbol for 'English (Zimbabwe)' is 'Z$'
'       The currency symbol for 'English (Republic of the Philippines)' is 'Php'
'       The currency symbol for 'English (India)' is 'Rs.'
'       The currency symbol for 'English (Malaysia)' is 'RM'
'       The currency symbol for 'English (Singapore)' is '$'

Comentarios

La NumberFormatInfo clase contiene información específica de la referencia cultural que se utiliza al dar formato y analizar los valores numéricos.The NumberFormatInfo class contains culture-specific information that is used when you format and parse numeric values. Esta información incluye el símbolo de moneda, el símbolo decimal, el símbolo de separador de grupos y los símbolos en busca de indicios positivos y negativos.This information includes the currency symbol, the decimal symbol, the group separator symbol, and the symbols for positive and negative signs.

Instancias de un objeto NumberFormatInfoInstantiating a NumberFormatInfo object

Puede crear instancias de un NumberFormatInfo objeto que representa las convenciones de formato de la referencia cultural actual, la referencia cultural invariable, una referencia cultural específica o una referencia cultural neutra.You can instantiate a NumberFormatInfo object that represents the formatting conventions of the current culture, the invariant culture, a specific culture, or a neutral culture.

Instancias de un objeto NumberFormatInfo para la referencia cultural actualInstantiating a NumberFormatInfo object for the current culture

Puede crear instancias de un NumberFormatInfo objeto para la referencia cultural del subproceso actual en cualquiera de las maneras siguientes.You can instantiate a NumberFormatInfo object for the current thread culture in any of the following ways. En cada caso, el valor devuelto NumberFormatInfo objeto es de solo lectura.In each case, the returned NumberFormatInfo object is read-only.

El ejemplo siguiente utiliza estas tres maneras de crear NumberFormatInfo objetos que representan las convenciones de formato de la referencia cultural actual.The following example uses these three ways to create NumberFormatInfo objects that represent the formatting conventions of the current culture. También recupera el valor de la IsReadOnly propiedad para ilustrar que cada objeto es de solo lectura.It also retrieves the value of the IsReadOnly property to illustrate that each object is read-only.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo current1 = CultureInfo.CurrentCulture.NumberFormat;
      Console.WriteLine(current1.IsReadOnly);
      
      NumberFormatInfo current2 = NumberFormatInfo.CurrentInfo;
      Console.WriteLine(current2.IsReadOnly);
      
      NumberFormatInfo current3 = NumberFormatInfo.GetInstance(CultureInfo.CurrentCulture);
      Console.WriteLine(current3.IsReadOnly);
   }
}
// The example displays the following output:
//       True
//       True
//       True
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat
      Console.WriteLine(current1.IsReadOnly)
      
      Dim current2 As NumberFormatInfo = NumberFormatInfo.CurrentInfo
      Console.WriteLine(current2.IsReadOnly)
      
      Dim current3 As NumberFormatInfo = NumberFormatInfo.GetInstance(CultureInfo.CurrentCulture)
      Console.WriteLine(current3.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       True
'       True
'       True

Puede crear una escritura NumberFormatInfo objeto que representa las convenciones de la referencia cultural del subproceso actual en cualquiera de las maneras siguientes:You can create a writable NumberFormatInfo object that represents the conventions of the current thread culture in any of the following ways:

El ejemplo siguiente muestra estas dos maneras de crear instancias de un NumberFormatInfo de objetos y muestra el valor de su IsReadOnly propiedad para ilustrar que el objeto no es de solo lectura.The following example illustrates these two ways of instantiating a NumberFormatInfo object, and displays the value of its IsReadOnly property to illustrate that the object is not read-only.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo current1 = NumberFormatInfo.CurrentInfo;
      current1 = (NumberFormatInfo) current1.Clone();
      Console.WriteLine(current1.IsReadOnly);

      CultureInfo culture2 = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
      NumberFormatInfo current2 = culture2.NumberFormat;
      Console.WriteLine(current2.IsReadOnly);
   }
}
// The example displays the following output:
//       False
//       False
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As NumberFormatInfo = NumberFormatInfo.CurrentInfo
      current1 = CType(current1.Clone(), NumberFormatInfo)
      Console.WriteLine(current1.IsReadOnly)

      Dim culture2 As CultureInfo = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name)
      Dim current2 As NumberFormatInfo = culture2.NumberFormat
      Console.WriteLine(current2.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       False
'       False

Tenga en cuenta que el sistema operativo Windows permite al usuario reemplazar algunas de las NumberFormatInfo valores de propiedad usados en las operaciones a través de análisis y formato numérico el región e idioma elemento en el Panel de Control.Note that the Windows operating system allows the user to override some of the NumberFormatInfo property values used in numeric formatting and parsing operations through the Region and Language item in Control Panel. Por ejemplo, podría elegir un usuario cuya referencia cultural es inglés (Estados Unidos) mostrar los valores de moneda como 1.1 USD en lugar del predeterminado de $1.1.For example, a user whose culture is English (United States) might choose to display currency values as 1.1 USD instead of the default of $1.1. El NumberFormatInfo los objetos recuperados de las maneras en que se describe anteriormente reflejan todos estas invalidaciones del usuario.The NumberFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Si esto es indeseable, puede crear un NumberFormatInfo objeto que no refleje las invalidaciones del usuario (y que también es lectura/escritura en lugar de solo lectura) mediante una llamada a la CultureInfo.CultureInfo(String, Boolean) constructor y proporcionar un valor de false para el useUserOverride argumento.If this is undesirable, you can create a NumberFormatInfo object that does not reflect user overrides (and that is also read/write rather than read-only) by calling the CultureInfo.CultureInfo(String, Boolean) constructor and supplying a value of false for the useUserOverride argument. El ejemplo siguiente proporciona una ilustración de un sistema cuya referencia cultural actual es inglés (Estados Unidos) y cuyos símbolos de moneda se ha cambiado el valor predeterminado es $ a USD.The following example provides an illustration for a system whose current culture is English (United States) and whose currency symbol has been changed from the default of $ to USD.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture;
      NumberFormatInfo nfi;
      
      culture = CultureInfo.CurrentCulture;
      nfi = culture.NumberFormat;
      Console.WriteLine("Culture Name:    {0}", culture.Name);
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
      Console.WriteLine("Currency Symbol: {0}\n", culture.NumberFormat.CurrencySymbol);
            
      culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
      Console.WriteLine("Culture Name:    {0}", culture.Name);
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol);
   }
}
// The example displays the following output:
//       Culture Name:    en-US
//       User Overrides:  True
//       Currency Symbol: USD
//       
//       Culture Name:    en-US
//       User Overrides:  False
//       Currency Symbol: $
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim nfi As NumberFormatInfo
      
      culture = CultureInfo.CurrentCulture
      nfi = culture.NumberFormat
      Console.WriteLine("Culture Name:    {0}", culture.Name)
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride)
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol)
      Console.WriteLine()
            
      culture = New CultureInfo(CultureInfo.CurrentCulture.Name, False)
      Console.WriteLine("Culture Name:    {0}", culture.Name)
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride)
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol)
   End Sub
End Module
' The example displays the following output:
'       Culture Name:    en-US
'       User Overrides:  True
'       Currency Symbol: USD
'       
'       Culture Name:    en-US
'       User Overrides:  False
'       Currency Symbol: $

Si el CultureInfo.UseUserOverride propiedad está establecida en true, las propiedades CultureInfo.DateTimeFormat, CultureInfo.NumberFormat, y CultureInfo.TextInfo también se recuperan de la configuración del usuario.If the CultureInfo.UseUserOverride property is set to true, the properties CultureInfo.DateTimeFormat, CultureInfo.NumberFormat, and CultureInfo.TextInfo are also retrieved from the user settings. Si la configuración de usuario no es compatible con la referencia cultural asociada con el CultureInfo objeto (por ejemplo, si el calendario seleccionado no es uno de los calendarios enumerados por la OptionalCalendars propiedad), los resultados de los métodos y los valores de las propiedades son sin definir.If the user settings are incompatible with the culture associated with the CultureInfo object (for example, if the selected calendar is not one of the calendars listed by the OptionalCalendars property), the results of the methods and the values of the properties are undefined.

Instancias de un objeto NumberFormatInfo para la referencia culturalInstantiating a NumberFormatInfo object for the invariant culture

La referencia cultural invariable representa una referencia cultural que no tiene en cuenta la referencia cultural.The invariant culture represents a culture that is culture-insensitive. Se basa en el idioma inglés, pero no en cualquier angloparlante país o región determinados.It is based on the English language but not on any specific English-speaking country/region. Aunque los datos de referencias culturales específicas pueden ser dinámicos y se pueden cambiar para reflejar las convenciones culturales nuevo o las preferencias del usuario, no cambian los datos de la referencia cultural invariable.Although the data of specific cultures can be dynamic and can change to reflect new cultural conventions or user preferences, the data of the invariant culture does not change. Un NumberFormatInfo objeto que representa las convenciones de formato de la referencia cultural se puede usar para dar formato a las operaciones en el resultado de las cadenas no deberían variar según la referencia cultural.A NumberFormatInfo object that represents the formatting conventions of the invariant culture can be used for formatting operations in which result strings should not vary by culture.

Puede crear instancias de un NumberFormatInfo objeto que representa las convenciones de formato de la referencia cultural de las maneras siguientes:You can instantiate a NumberFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

El ejemplo siguiente usa cada uno de estos métodos para crear instancias de un NumberFormatInfo objeto que representa la referencia cultural invariable.The following example uses each of these methods to instantiate a NumberFormatInfo object that represents the invariant culture. A continuación, indica si el objeto es de solo lecturaIt then indicates whether the object is read-only,

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo nfi;
      
      nfi = System.Globalization.NumberFormatInfo.InvariantInfo;
      Console.WriteLine(nfi.IsReadOnly);               
      
      nfi = CultureInfo.InvariantCulture.NumberFormat;
      Console.WriteLine(nfi.IsReadOnly);               
      
      nfi = New NumberFormatInfo();
      Console.WriteLine(nfi.IsReadOnly);               
   }
}
// The example displays the following output:
//       True
//       True
//       False
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim nfi As NumberFormatInfo
      
      nfi = System.Globalization.NumberFormatInfo.InvariantInfo
      Console.WriteLine(nfi.IsReadOnly)               
      
      nfi = CultureInfo.InvariantCulture.NumberFormat
      Console.WriteLine(nfi.IsReadOnly)               
      
      nfi = New NumberFormatInfo()
      Console.WriteLine(nfi.IsReadOnly)               
   End Sub
End Module
' The example displays the following output:
'       True
'       True
'       False

Instancias de un objeto NumberFormatInfo para una referencia cultural específicaInstantiating a NumberFormatInfo object for a specific culture

Una referencia cultural específica representa el idioma que se habla en un determinado país o región.A specific culture represents a language that is spoken in a particular country/region. Por ejemplo, en-US es una referencia cultural que representa el idioma inglés de Estados Unidos y en-CA es una referencia cultural que representa el idioma inglés de Canadá.For example, en-US is a specific culture that represents the English language spoken in the United States, and en-CA is a specific culture that represents the English language spoken in Canada. Puede crear instancias de un NumberFormatInfo objeto que representa las convenciones de formato de una referencia cultural específica de las maneras siguientes:You can instantiate a NumberFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

El ejemplo siguiente utiliza estas cuatro formas de crear un NumberFormatInfo objeto que refleja las convenciones de formato de la referencia cultural Indonesio (Indonesia).The following example uses these four ways to create a NumberFormatInfo object that reflects the formatting conventions of the Indonesian (Indonesia) culture. También indica si cada objeto es de solo lectura.It also indicates whether each object is read-only.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture;
      NumberFormatInfo nfi;
      
      nfi = CultureInfo.GetCultureInfo("id-ID").NumberFormat;
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);
      
      culture = new CultureInfo("id-ID");
      nfi = NumberFormatInfo.GetInstance(culture);
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);
      
      culture = CultureInfo.CreateSpecificCulture("id-ID");
      nfi = culture.NumberFormat;
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);
      
      culture = new CultureInfo("id-ID");
      nfi = culture.NumberFormat;
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);
   }
}
// The example displays the following output:
//       Read-only: True
//       Read-only: False
//       Read-only: False
//       Read-only: False
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim nfi As NumberFormatInfo
      
      nfi = CultureInfo.GetCultureInfo("id-ID").NumberFormat
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly)
      
      culture = New CultureInfo("id-ID")
      nfi = NumberFormatInfo.GetInstance(culture)
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly)
      
      culture = CultureInfo.CreateSpecificCulture("id-ID")
      nfi = culture.NumberFormat
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly)
      
      culture = New CultureInfo("id-ID")
      nfi = culture.NumberFormat
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       Read-only: True
'       Read-only: False
'       Read-only: False
'       Read-only: False

Instancias de un objeto NumberFormatInfo para una referencia cultural neutraInstantiating a NumberFormatInfo object for a neutral culture

Una referencia cultural neutra representa una referencia cultural o idioma que es independiente de un país o región.A neutral culture represents a culture or language that is independent of a country/region. Suele ser el elemento primario de referencias culturales específicas de uno o más.It is typically the parent of one or more specific cultures. Por ejemplo, fr es una referencia cultural neutra para el idioma francés y el elemento primario de la referencia cultural fr-FR.For example, fr is a neutral culture for the French language and the parent of the fr-FR culture. Crear un NumberFormatInfo objeto que representa las convenciones de formato de una referencia cultural neutra de la misma manera que cree un NumberFormatInfo objeto que representa las convenciones de formato de una referencia cultural concreta.You create a NumberFormatInfo object that represents the formatting conventions of a neutral culture in the same way that you create a NumberFormatInfo object that represents the formatting conventions of a specific culture.

Nota

En el .NET Framework 3,5.NET Framework 3.5 y versiones anteriores, al intentar recuperar un NumberFormatInfo objeto que refleja las convenciones de formato de una referencia cultural neutra produce un NotSupportedException excepción.In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, trying to retrieve a NumberFormatInfo object that reflects the formatting conventions of a neutral culture throws a NotSupportedException exception.

Sin embargo, dado que es independiente de un país o región específico, una referencia cultural neutra carece de información de formato específica de la referencia cultural.However, because it is independent of a specific country/region, a neutral culture lacks culture-specific formatting information. En lugar de rellenar el NumberFormatInfo objeto con valores genéricos, .NET Framework devuelve un NumberFormatInfo que refleja las convenciones de formato de una determinada referencia cultural que es un elemento secundario de la referencia cultural neutra.Rather than populating the NumberFormatInfo object with generic values, the .NET Framework returns a NumberFormatInfo object that reflects the formatting conventions of a specific culture that is a child of the neutral culture. Por ejemplo, el NumberFormatInfo para la referencia cultural neutra en refleja las convenciones de formato de la referencia cultural en-US, de objeto y el NumberFormatInfo de objeto para la referencia cultural fr refleja las convenciones de formato de la referencia cultural fr-FR.For example, the NumberFormatInfo object for the neutral en culture reflects the formatting conventions of the en-US culture, and the NumberFormatInfo object for the fr culture reflects the formatting conventions of the fr-FR culture.

Puede usar código similar al siguiente para determinar las convenciones de formato de la referencia cultural concreta representa cada referencia cultural neutra.You can use code like the following to determine which specific culture's formatting conventions each neutral culture represents.

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

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

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

      foreach (var ci in cultures) {
         bool match = true;     
         // Get the NumberFormatInfo for a specific culture.
         NumberFormatInfo specificNfi = ci.NumberFormat;
         // Compare the property values of the two.
         foreach (var prop in properties) {
            // We're not interested in the value of IsReadOnly.     
            if (prop.Name == "IsReadOnly") continue;
            
            // For arrays, iterate the individual elements to see if they are the same.
            if (prop.PropertyType.IsArray) { 
               IList nList = (IList) prop.GetValue(nfi, null);
               IList sList = (IList) prop.GetValue(specificNfi, null);
               if (nList.Count != sList.Count) {
                  match = false;
                  break;
               } 

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

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

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

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

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

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

NumberFormatInfo y dinámico de datosNumberFormatInfo and dynamic data

Los datos específicos de referencias culturales para dar formato a valores numéricos proporcionados por el NumberFormatInfo clase es dinámica, al igual que los datos de referencia culturales proporcionados por el CultureInfo clase.The culture-specific data for formatting numeric values provided by the NumberFormatInfo class is dynamic, just like the cultural data provided by the CultureInfo class. No debe hacer ninguna suposición sobre la estabilidad de los valores de NumberFormatInfo objetos que están asociados a determinado CultureInfo objetos.You should not make any assumptions about the stability of values for NumberFormatInfo objects that are associated with particular CultureInfo objects. Solo los datos proporcionados por la referencia cultural y los correspondientes NumberFormatInfo objeto es estable.Only the data provided by the invariant culture and its associated NumberFormatInfo object is stable. Pueden cambiar a otros datos entre sesiones de aplicación, o incluso en una sola sesión, por las razones siguientes:Other data can change between application sessions, or even within a single session, for the following reasons:

  • Actualizaciones del sistema.System updates. Cambian las preferencias culturales, como el símbolo de moneda o los formatos de moneda con el tiempo.Cultural preferences such as the currency symbol or currency formats change over time. Cuando esto sucede, Windows Update incluye los cambios realizados en el NumberFormatInfo valor de propiedad para una referencia cultural determinada.When this happens, Windows Update includes changes to the NumberFormatInfo property value for a particular culture.

  • Referencias culturales de reemplazo.Replacement cultures. La CultureAndRegionInfoBuilder clase puede utilizarse para reemplazar los datos de una referencia cultural existente.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Cambios en cascada en los valores de propiedad.Cascading changes to property values. Pueden cambiar varias propiedades relacionadas con la referencia cultural en tiempo de ejecución, a su vez, lo que hace que NumberFormatInfo datos para cambiar.A number of culture-related properties can change at run time, which, in turn, causes NumberFormatInfo data to change. Por ejemplo, la referencia cultural actual se puede cambiar mediante programación o a través de la acción del usuario.For example, the current culture can be changed either programmatically or through user action. Cuando esto sucede, el NumberFormatInfo objeto devuelto por la CurrentInfo propiedad cambia a un objeto asociado a la referencia cultural actual.When this happens, the NumberFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture.

  • Preferencias del usuario.User preferences. Los usuarios de la aplicación podrían invalidar algunos de los valores asociados con la referencia cultural actual del sistema a través de las opciones de idioma y región en el Panel de Control.Users of your application might override some of the values associated with the current system culture through the region and language options in Control Panel. Por ejemplo, los usuarios podrían elegir otro símbolo de moneda o un símbolo de separador de decimales diferente.For example, users might choose a different currency symbol or a different decimal separator symbol. Si el CultureInfo.UseUserOverride propiedad está establecida en true (su valor predeterminado), las propiedades de la NumberFormatInfo objeto también se recuperan de la configuración del usuario.If the CultureInfo.UseUserOverride property is set to true (its default value), the properties of the NumberFormatInfo object are also retrieved from the user settings.

A partir de .NET Framework 2.0, todas las propiedades que se puede invalidar el usuario de un NumberFormatInfo objetos se inicializan cuando se crea el objeto.Starting with the .NET Framework 2.0, all user-overridable properties of a NumberFormatInfo object are initialized when the object is created. Hay una posibilidad de incoherencia, porque ninguna creación de objeto ni el proceso de reemplazo de usuario es atómico y pueden cambiar los valores pertinentes durante la creación del objeto.There is still a possibility of inconsistency, because neither object creation nor the user override process is atomic, and the relevant values may change during object creation. Sin embargo, estas incoherencias deben ser muy poco habitual.However, these inconsistencies should be extremely rare.

Puede controlar si las invalidaciones del usuario se reflejan en NumberFormatInfo objetos que representan la misma referencia cultural que la referencia cultural del subproceso actual.You can control whether user overrides are reflected in NumberFormatInfo objects that represent the same culture as the current thread culture. La tabla siguiente enumeran las formas en que un NumberFormatInfo objeto se pueden recuperar e indica si el objeto resultante refleja invalidaciones del usuario.The following table lists the ways in which a NumberFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Origen de un objeto CultureInfo y NumberFormatInfoSource of CultureInfo and NumberFormatInfo object Refleja las invalidaciones del usuarioReflects user overrides
PropiedadCultureInfo.CurrentCulture.NumberFormat CultureInfo.CurrentCulture.NumberFormat property Yes
PropiedadNumberFormatInfo.CurrentInfo NumberFormatInfo.CurrentInfo property Yes
Método CultureInfo.CreateSpecificCultureCultureInfo.CreateSpecificCulture method Yes
Método CultureInfo.GetCultureInfoCultureInfo.GetCultureInfo method NoNo
Constructor CultureInfo(String)CultureInfo(String) constructor Yes
Constructor CultureInfo.CultureInfo(String, Boolean)CultureInfo.CultureInfo(String, Boolean) constructor Depende de valor de useUserOverride parámetroDepends on value of useUserOverride parameter

A menos que haya una razón de peso para no hacerlo, debe respetar las invalidaciones del usuario cuando se usa el NumberFormatInfo objetos en las aplicaciones cliente para dar formato y analizar la entrada de usuario o para mostrar datos numéricos.Unless there is a compelling reason to do otherwise, you should respect user overrides when you use the NumberFormatInfo object in client applications to format and parse user input or to display numeric data. Para las aplicaciones de servidor o aplicaciones desatendidas, no debe respetar invalidaciones del usuario.For server applications or unattended applications, you should not respect user overrides. Sin embargo, si está utilizando el NumberFormatInfo objeto ya sea explícitamente o implícitamente para conservar datos numéricos en forma de cadena, debería usar un NumberFormatInfo debe especificar el objeto que refleja las convenciones de formato de la referencia cultural invariable, o bien un cadena de formato numérico personalizado que usa independientemente de la referencia cultural.However, if you are using the NumberFormatInfo object either explicitly or implicitly to persist numeric data in string form, you should either use a NumberFormatInfo object that reflects the formatting conventions of the invariant culture, or you should specify a custom numeric format string that you use regardless of culture.

IFormatProvider, NumberFormatInfo y el formato numéricoIFormatProvider, NumberFormatInfo, and numeric formatting

Un NumberFormatInfo objeto sirve implícita o explícitamente numérico todas las operaciones de formato.A NumberFormatInfo object is used implicitly or explicitly in all numeric formatting operations. Estos incluyen llamadas a los métodos siguientes:These include calls to the following methods:

Todas las operaciones de formato numéricas hacer uso de un IFormatProvider implementación.All numeric formatting operations make use of an IFormatProvider implementation. El IFormatProvider interfaz incluye un único método, GetFormat(Type).The IFormatProvider interface includes a single method, GetFormat(Type). Se trata de un método de devolución de llamada que se pasa un Type objeto que representa el tipo necesario para proporcionar información de formato.This is a callback method that is passed a Type object that represents the type needed to provide formatting information. El método es responsable de devolver una instancia de ese tipo o null, si no puede proporcionar una instancia del tipo.The method is responsible for returning either an instance of that type or null, if it cannot provide an instance of the type. .NET Framework proporciona dos IFormatProvider implementaciones para dar formato a números:The .NET Framework provides two IFormatProvider implementations for formatting numbers:

Si un IFormatProvider implementación no se proporciona a un método de formato de forma explícita, una CultureInfo objeto devuelto por la CultureInfo.CurrentCulture se utiliza la propiedad que representa la referencia cultural del subproceso actual.If an IFormatProvider implementation is not provided to a formatting method explicitly, a CultureInfo object returned by the CultureInfo.CurrentCulture property that represents the current thread culture is used.

El ejemplo siguiente ilustra la relación entre el IFormatProvider interfaz y la NumberFormatInfo clase para dar formato a las operaciones definiendo un personalizado IFormatProvider implementación.The following example illustrates the relationship between the IFormatProvider interface and the NumberFormatInfo class in formatting operations by defining a custom IFormatProvider implementation. Su GetFormat método muestra el nombre de tipo del objeto solicitado por la operación de formato.Its GetFormat method displays the type name of the object requested by the formatting operation. Si está solicitando la interfaz de un NumberFormatInfo objeto, este método proporciona la NumberFormatInfo objeto para la referencia cultural del subproceso actual.If the interface is requesting a NumberFormatInfo object, this method provides the NumberFormatInfo object for the current thread culture. Como la salida muestra el ejemplo, el Decimal.ToString(IFormatProvider) las solicitudes de métodos un NumberFormatInfo objeto para proporcionar información de formato, mientras que el String.Format(IFormatProvider, String, Object[]) las solicitudes de métodos NumberFormatInfo y DateTimeFormatInfo objetos, así como un ICustomFormatter implementación de.As the output from the example shows, the Decimal.ToString(IFormatProvider) method requests a NumberFormatInfo object to provide formatting information, whereas the String.Format(IFormatProvider, String, Object[]) method requests NumberFormatInfo and DateTimeFormatInfo objects as well as an ICustomFormatter implementation.

using System;
using System.Globalization;

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

public class Example
{
   public static void Main()
   {
      Decimal amount = 1203.541m;
      string value = amount.ToString("C2", new CurrentCultureFormatProvider());
      Console.WriteLine(value);
      Console.WriteLine();
      string composite = String.Format(new CurrentCultureFormatProvider(), 
                                       "Date: {0}   Amount: {1}   Description: {2}",
                                       DateTime.Now, 1264.03m, "Service Charge");
      Console.WriteLine(composite);
      Console.WriteLine();
   }
}
// The example displays output like the following:
//    Requesting an object of type NumberFormatInfo
//    $1,203.54
//    
//    Requesting an object of type ICustomFormatter
//    Requesting an object of type DateTimeFormatInfo
//    Requesting an object of type NumberFormatInfo
//    Date: 11/15/2012 2:00:01 PM   Amount: 1264.03   Description: Service Charge
Imports System.Globalization

Public Class CurrentCultureFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      Console.WriteLine("Requesting an object of type {0}", 
                        formatType.Name)
      If formatType Is GetType(NumberFormatInfo) Then
         Return NumberFormatInfo.CurrentInfo
      Else If formatType Is GetType(DateTimeFormatInfo) Then
         Return DateTimeFormatInfo.CurrentInfo
      Else
         Return Nothing
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim amount As Decimal = 1203.541d
      Dim value As String = amount.ToString("C2", New CurrentCultureFormatProvider())
      Console.WriteLine(value)
      Console.WriteLine()
      Dim composite As String = String.Format(New CurrentCultureFormatProvider, 
                                              "Date: {0}   Amount: {1}   Description: {2}",
                                              Date.Now, 1264.03d, "Service Charge")
      Console.WriteLine(composite)
      Console.WriteLine()
   End Sub
End Module
' The example displays output like the following:
'    Requesting an object of type NumberFormatInfo
'    $1,203.54
'    
'    Requesting an object of type ICustomFormatter
'    Requesting an object of type DateTimeFormatInfo
'    Requesting an object of type NumberFormatInfo
'    Date: 11/15/2012 2:00:01 PM   Amount: 1264.03   Description: Service Charge

Si un IFormatProvider implementación no se proporciona explícitamente en un llamada de método, las llamadas al método de formato numérico el CultureInfo.CurrentCulture.GetFormat método, que devuelve el NumberFormatInfo objeto que corresponde a la referencia cultural del subproceso actual.If an IFormatProvider implementation is not explicitly provided in a numeric formatting method call, the method calls the CultureInfo.CurrentCulture.GetFormat method, which returns the NumberFormatInfo object that corresponds to the current thread culture.

Cadenas de formato y propiedades NumberFormatInfoFormat strings and NumberFormatInfo properties

Cada operación de formato usa un estándar o una cadena de formato numérico personalizado para generar una cadena de resultado de un número.Every formatting operation uses either a standard or a custom numeric format string to produce a result string from a number. En algunos casos, el uso de una cadena de formato para generar una cadena de resultado es explícito, como en el ejemplo siguiente.In some cases, the use of a format string to produce a result string is explicit, as in the following example. Este código llama a la Decimal.ToString(IFormatProvider) método para convertir un Decimal valor con un número diferente de representaciones de cadena mediante el uso de las convenciones de formato de la referencia cultural en-US.This code calls the Decimal.ToString(IFormatProvider) method to convert a Decimal value to a number of different string representations by using the formatting conventions of the en-US culture.

using System;
using System.Globalization;

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

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

En otros casos, el uso de una cadena de formato está implícito.In other cases, the use of a format string is implicit. Por ejemplo, en las siguientes llamadas de método en el valor predeterminado o sin parámetros Decimal.ToString() método, el valor de la Decimal instancia esté formateada con el especificador de formato general ("G") y las convenciones de la referencia cultural actual, que en este caso es el referencia cultural en-US.For example, in the following method calls to the default or parameterless Decimal.ToString() method, the value of the Decimal instance is formatted by using the general ("G") format specifier and the conventions of the current culture, which in this case is the en-US culture.

using System;

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

Cada cadena de formato numérico estándar usa uno o varios NumberFormatInfo propiedades para determinar el patrón o los símbolos utilizados en la cadena de resultado.Each standard numeric format string uses one or more NumberFormatInfo properties to determine the pattern or the symbols used in the result string. De forma similar, cada especificador de formato numérico personalizado con la excepción "0" y "#" inserción símbolos en la cadena de resultado que se definen mediante NumberFormatInfo propiedades.Similarly, each custom numeric format specifier except "0" and "#" insert symbols in the result string that are defined by NumberFormatInfo properties. La siguiente tabla enumera el estándar y los especificadores de formato numérico personalizado y sus asociados NumberFormatInfo propiedades.The following table lists the standard and custom numeric format specifiers and their associated NumberFormatInfo properties. Para cambiar la apariencia de la cadena de resultado de una referencia cultural determinada, consulte el propiedades NumberFormatInfo modificar sección.To change the appearance of the result string for a particular culture, see the Modifying NumberFormatInfo properties section. Para obtener información detallada sobre el uso de estos especificadores de formato, vea cadenas de formato numérico estándar y cadenas con formato numérico personalizado.For details about the use of these format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

Especificador de formatoFormat specifier Propiedades asociadasAssociated properties
"C" o "c" (especificador de formato de moneda)"C" or "c" (currency format specifier) CurrencyDecimalDigits, para definir el número predeterminado de dígitos fraccionarios.CurrencyDecimalDigits, to define the default number of fractional digits.

CurrencyDecimalSeparator, para definir el símbolo del separador decimal.CurrencyDecimalSeparator, to define the decimal separator symbol.

CurrencyGroupSeparator, para definir el grupo o miles separador.CurrencyGroupSeparator, to define the group or thousands separator.

CurrencyGroupSizes, para definir los tamaños de grupos enteros.CurrencyGroupSizes, to define the sizes of integral groups.

CurrencyNegativePattern, para definir el modelo de valores de divisa negativos.CurrencyNegativePattern, to define the pattern of negative currency values.

CurrencyPositivePattern, para definir el modelo de valores de divisa positivos.CurrencyPositivePattern, to define the pattern of positive currency values.

CurrencySymbol, para definir el símbolo de moneda.CurrencySymbol, to define the currency symbol.

NegativeSign, para definir el símbolo de signo negativo.NegativeSign, to define the negative sign symbol.
"D" o "d" (especificador de formato decimal)"D" or "d" (decimal format specifier) NegativeSign, para definir el símbolo de signo negativo.NegativeSign, to define the negative sign symbol.
"E" o "e" (especificador de formato exponencial o científicos)"E" or "e" (exponential or scientific format specifier) NegativeSign, para definir el símbolo de signo negativo de la mantisa y el exponente.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

NumberDecimalSeparator, para definir el símbolo del separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, para definir el símbolo de signo positivo en el exponente.PositiveSign, to define the positive sign symbol in the exponent.
"F" o "f" (especificador de formato de punto fijo)"F" or "f" (fixed-point format specifier) NegativeSign, para definir el símbolo de signo negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, para definir el número predeterminado de dígitos fraccionarios.NumberDecimalDigits, to define the default number of fractional digits.

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

NumberDecimalSeparator, para definir el símbolo del separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, para definir el símbolo de signo positivo para cadenas de resultado en formato exponencial.PositiveSign, to define the positive sign symbol for result strings in exponential format.
"N" o "n" (especificador de formato number)"N" or "n" (number format specifier) NegativeSign, para definir el símbolo de signo negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, para definir el número predeterminado de dígitos fraccionarios.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, para definir el símbolo del separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.

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

NumberGroupSizes, para definir el número de dígitos enteros en un grupo.NumberGroupSizes, to define the number of integral digits in a group.

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

PercentDecimalDigits, para definir el número predeterminado de dígitos fraccionarios.PercentDecimalDigits, to define the default number of fractional digits.

PercentDecimalSeparator, para definir el símbolo del separador decimal.PercentDecimalSeparator, to define the decimal separator symbol.

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

PercentGroupSizes, para definir el número de dígitos enteros en un grupo.PercentGroupSizes, to define the number of integral digits in a group.

PercentNegativePattern, para definir la posición del símbolo de porcentaje y del símbolo negativo para los valores negativos.PercentNegativePattern, to define the placement of the percent symbol and the negative symbol for negative values.

PercentPositivePattern, para definir la posición del símbolo de porcentaje para los valores positivos.PercentPositivePattern, to define the placement of the percent symbol for positive values.

PercentSymbol, para definir el símbolo de porcentaje.PercentSymbol, to define the percent symbol.
"R" o "r" (especificador de formato de ida y vuelta)"R" or "r" (round-trip format specifier) NegativeSign, para definir el símbolo de signo negativo.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, para definir el símbolo del separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, para definir el símbolo de signo positivo en un exponente.PositiveSign, to define the positive sign symbol in an exponent.
"X" o "x" (especificador de formato hexadecimal)"X" or "x" (hexadecimal format specifier) Ninguno.None.
"." (especificador de formato personalizado del separador decimal)"." (decimal point custom format specifier) NumberDecimalSeparator, para definir el símbolo del separador decimal.NumberDecimalSeparator, to define the decimal separator symbol.
"," (especificador de formato personalizado del separador de grupo)"," (group separator custom format specifier) NumberGroupSeparator, para definir el símbolo de separador de grupos (miles).NumberGroupSeparator, to define the group (thousands) separator symbol.
"%" (especificador de formato personalizado de marcador de posición de porcentaje)"%" (percentage placeholder custom format specifier) PercentSymbol, para definir el símbolo de porcentaje.PercentSymbol, to define the percent symbol.
"‰" (por el especificador de formato personalizado de marcador de posición de millar)"‰" (per mille placeholder custom format specifier) PerMilleSymbol, para definir el símbolo de por mil.PerMilleSymbol, to define the per mille symbol.
"E" (especificador de formato personalizado de una notación exponencial)"E" (exponential notation custom format specifier) NegativeSign, para definir el símbolo de signo negativo de la mantisa y el exponente.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

PositiveSign, para definir el símbolo de signo positivo en el exponente.PositiveSign, to define the positive sign symbol in the exponent.

Tenga en cuenta que el NumberFormatInfo clase incluye un NativeDigits propiedad que especifica la bases 10 dígitos utilizados por una referencia cultural concreta.Note that the NumberFormatInfo class includes a NativeDigits property that specifies the base 10 digits used by a specific culture. Sin embargo, la propiedad no se utiliza para dar formato a las operaciones; solo los dígitos latinos básicos del 0 (u+0030) a través de 9 (u+0039) se usan en la cadena de resultado.However, the property is not used in formatting operations; only the Basic Latin digits 0 (U+0030) through 9 (U+0039) are used in the result string. Además, para Single y Double valores de NaN, PositiveInfinity, y NegativeInfinity, la cadena de resultado consta únicamente de los símbolos definidos por el NaNSymbol, PositiveInfinitySymbol, y NegativeInfinitySymbol propiedades , respectivamente.In addition, for Single and Double values of NaN, PositiveInfinity, and NegativeInfinity, the result string consists exclusively of the symbols defined by the NaNSymbol, PositiveInfinitySymbol, and NegativeInfinitySymbol properties, respectively.

Modificar propiedades NumberFormatInfoModifying NumberFormatInfo properties

Puede modificar las propiedades de un NumberFormatInfo objeto para personalizar la cadena de resultado generados en un operación de formato numérico.You can modify the properties of a NumberFormatInfo object to customize the result string produced in a numeric formatting operation. Para hacerlo:To do this:

  1. Crear una copia de lectura/escritura de un NumberFormatInfo objeto cuyas convenciones de formato que desea modificar.Create a read/write copy of a NumberFormatInfo object whose formatting conventions you want to modify. Para obtener más información, consulte el instancias de un objeto NumberFormatInfo sección.For more information, see the Instantiating a NumberFormatInfo object section.

  2. Modifique la propiedad o propiedades que se utilizan para generar la cadena de resultado deseado.Modify the property or properties that are used to produce the desired result string. Para obtener información sobre el uso de métodos de formato cómo NumberFormatInfo las propiedades para definir cadenas de resultado, consulte el cadenas de formato y propiedades NumberFormatInfo sección.For information about how formatting methods use NumberFormatInfo properties to define result strings, see the Format strings and NumberFormatInfo properties section.

  3. Usar personalizado NumberFormatInfo objeto como el IFormatProvider argumento en las llamadas a métodos de formato.Use the custom NumberFormatInfo object as the IFormatProvider argument in calls to formatting methods.

Nota

En lugar de modificar los valores de propiedad de la referencia cultural dinámicamente cada vez que se inicia una aplicación, puede usar el CultureAndRegionInfoBuilder clase para definir una referencia cultural personalizada (una referencia cultural que tiene un nombre único y que complementa referencias culturales existentes) o un reemplazo referencia cultural (uno que se utiliza en lugar de una referencia cultural específica).Instead of dynamically modifying a culture's property values each time an application is started, you can use the CultureAndRegionInfoBuilder class to define either a custom culture (a culture that has a unique name and that supplements existing cultures) or a replacement culture (one that is used instead of a specific culture).

Las secciones siguientes proporcionan algunos ejemplos.The following sections provide some examples.

Modificar el símbolo de moneda y el patrónModifying the currency symbol and pattern

En el ejemplo siguiente se modifica un NumberFormatInfo objeto que representa las convenciones de formato de la referencia cultural en-US.The following example modifies a NumberFormatInfo object that represents the formatting conventions of the en-US culture. Asigna el símbolo de divisa ISO 4217 para la CurrencySymbol propiedad y define un patrón para los valores de moneda que consta del símbolo de moneda seguido por un espacio y un valor numérico.It assigns the ISO-4217 currency symbol to the CurrencySymbol property and defines a pattern for currency values that consists of the currency symbol followed by a space and a numeric value.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Retrieve a writable NumberFormatInfo object.
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      NumberFormatInfo nfi = enUS.NumberFormat;

      // Use the ISO currency symbol instead of the native currency symbol.
      nfi.CurrencySymbol =  (new RegionInfo(enUS.Name)).ISOCurrencySymbol;
      // Change the positive currency pattern to <code><space><value>.
      nfi.CurrencyPositivePattern = 2;
      // Change the negative currency pattern to <code><space><sign><value>.     
      nfi.CurrencyNegativePattern = 12;
      
      // Produce the result strings by calling ToString.
      Decimal[] values = { 1065.23m, 19.89m, -.03m, -175902.32m };
      foreach (var value in values)
         Console.WriteLine(value.ToString("C", enUS));

      Console.WriteLine();
      
      // Produce the result strings by calling a composite formatting method.
      foreach (var value in values)
         Console.WriteLine(String.Format(enUS, "{0:C}", value));      
   }
}
// The example displays the following output:
//       USD 1,065.23
//       USD 19.89
//       USD -0.03
//       USD -175,902.32
//       
//       USD 1,065.23
//       USD 19.89
//       USD -0.03
//       USD -175,902.32
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Retrieve a writable NumberFormatInfo object.
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim nfi As NumberFormatInfo = enUS.NumberFormat

      ' Use the ISO currency symbol instead of the native currency symbol.
      nfi.CurrencySymbol =  (New RegionInfo(enUS.Name)).ISOCurrencySymbol
      ' Change the positive currency pattern to <code><space><value>.
      nfi.CurrencyPositivePattern = 2
      ' Change the negative currency pattern to <code><space><sign><value>.     
      nfi.CurrencyNegativePattern = 12
      
      ' Produce the result strings by calling ToString.
      Dim values() As Decimal = { 1065.23d, 19.89d, -.03d, -175902.32d }
      For Each value In values
         Console.WriteLine(value.ToString("C", enUS))
      Next      
      Console.WriteLine()
      
      ' Produce the result strings by calling a composite formatting method.
      For Each value In values
         Console.WriteLine(String.Format(enUS, "{0:C}", value))      
      Next
   End Sub
End Module
' The example displays the following output:
'       USD 1,065.23
'       USD 19.89
'       USD -0.03
'       USD -175,902.32
'       
'       USD 1,065.23
'       USD 19.89
'       USD -0.03
'       USD -175,902.32

Dar formato a un número de identificación nacionalFormatting a national identification number

Muchos de los números de identificación nacional constar únicamente de dígitos y por lo que fácilmente se puede dar formato mediante la modificación de las propiedades de un NumberFormatInfo objeto.Many national identification numbers consist exclusively of digits and so can easily be formatted by modifying the properties of a NumberFormatInfo object. Por ejemplo, un número de seguridad social de Estados Unidos consta de 9 dígitos que se organizan de esta forma: XXX-XX-XXXX.For example, a social security number in the United States consists of 9 digits arranged as follows: XXX-XX-XXXX. En el siguiente ejemplo se da por supuesto que los números del seguro social se almacenan como valores de entero y les da formato de forma adecuada.The following example assumes that social security numbers are stored as integer values and formats them appropriately.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Instantiate a read-only NumberFormatInfo object.
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      NumberFormatInfo nfi = enUS.NumberFormat;

      // Modify the relevant properties.
      nfi.NumberGroupSeparator = "-";
      nfi.NumberGroupSizes = new int[] { 3, 2, 4};
      nfi.NumberDecimalDigits = 0;
      
      int[] ids = { 111223333, 999776666 };
      
      // Produce the result string by calling ToString.
      foreach (var id in ids)
         Console.WriteLine(id.ToString("N", enUS));

      Console.WriteLine();
      
      // Produce the result string using composite formatting.
      foreach (var id in ids)
         Console.WriteLine(String.Format(enUS, "{0:N}", id));
   }
}
// The example displays the following output:
//       1112-23-333
//       9997-76-666
//       
//       1112-23-333
//       9997-76-666
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Instantiate a read-only NumberFormatInfo object.
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim nfi As NumberFormatInfo = enUS.NumberFormat

      ' Modify the relevant properties.
      nfi.NumberGroupSeparator = "-"
      nfi.NumberGroupSizes = { 3, 2, 4}
      nfi.NumberDecimalDigits = 0
      
      Dim ids() As Integer = { 111223333, 999776666 }
      
      ' Produce the result string by calling ToString.
      For Each id In ids
         Console.WriteLine(id.ToString("N", enUS))
      Next 
      Console.WriteLine()
      
      ' Produce the result string using composite formatting.
      For Each id In ids
         Console.WriteLine(String.Format(enUS, "{0:N}", id))
      Next
   End Sub
End Module
' The example displays the following output:
'       1112-23-333
'       9997-76-666
'       
'       1112-23-333
'       9997-76-666

Análisis de cadenas numéricasParsing numeric strings

Análisis implica convertir la representación de cadena de un número en un número.Parsing involves converting the string representation of a number to a number. Cada tipo numérico en .NET Framework incluye dos métodos sobrecargados de análisis: Parse y TryParse.Each numeric type in the .NET Framework includes two overloaded parsing methods: Parse and TryParse. El Parse método convierte una cadena en un número y produce una excepción si se produce un error en la conversión.The Parse method converts a string to a number and throws an exception if the conversion fails. El TryParse método convierte una cadena en un número, se asigna el número a un out argumento y devuelve un Boolean valor que indica si la conversión se realizó correctamente.The TryParse method converts a string to a number, assigns the number to an out argument, and returns a Boolean value that indicates whether the conversion succeeded.

Utilizan los métodos de análisis implícita o explícitamente un NumberStyles valor de enumeración para determinar qué elementos de estilo (como separadores de grupo, un separador decimal o un símbolo de moneda) pueden estar presentes en una cadena de la operación de análisis se realice correctamente.The parsing methods implicitly or explicitly use a NumberStyles enumeration value to determine what style elements (such as group separators, a decimal separator, or a currency symbol) can be present in a string if the parsing operation is to succeed. Si un NumberStyles valor no es se proporciona en la llamada al método, el valor predeterminado es un NumberStyles valor que incluye el Float y AllowThousands marcas, que especifica que la cadena analizada puede incluir los símbolos de grupo, un separador decimal, un signo negativo, y caracteres de espacio en blanco, o puede ser la representación de cadena de un número en notación exponencial.If a NumberStyles value is not provided in the method call, the default is a NumberStyles value that includes the Float and AllowThousands flags, which specifies that the parsed string can include group symbols, a decimal separator, a negative sign, and white-space characters, or it can be the string representation of a number in exponential notation.

Utilizan los métodos de análisis también implícita o explícitamente un NumberFormatInfo objeto que define los símbolos específicos y los patrones que puede aparecer en la cadena que se puede analizar.The parsing methods also implicitly or explicitly use a NumberFormatInfo object that defines the specific symbols and patterns that can occur in the string to be parsed. Si un NumberFormatInfo objeto no se proporciona, el valor predeterminado es el NumberFormatInfo para la referencia cultural del subproceso actual.If a NumberFormatInfo object is not provided, the default is the NumberFormatInfo for the current thread culture. Para obtener más información sobre el análisis, vea los métodos de análisis individuales, como Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double), y BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).For more information about parsing, see the individual parsing methods, such as Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double), and BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).

En el ejemplo siguiente se ilustra la naturaleza de la referencia cultural de análisis de cadenas.The following example illustrates the culture-sensitive nature of parsing strings. Se intenta analizar una cadena que incluye miles separadores mediante las convenciones de en-US, fr-FR y referencias culturales invariables.It tries to parse a string that include thousands separators by using the conventions of the en-US, fr-FR, and invariant cultures. No se puede analizar en el en-US y referencias culturales invariables una cadena que incluye la coma como separador de grupos y el período como un separador decimal no se puede analizar en la referencia cultural fr-FR y una cadena con white space como un separador de grupo y una coma como separador decimal.A string that includes the comma as a group separator and the period as a decimal separator fails to parse in the fr-FR culture, and a string with white space as a group separator and a comma as a decimal separator fails to parse in the en-US and invariant cultures.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] values = { "1,034,562.91", "9 532 978,07" };
      String[] cultureNames = { "en-US", "fr-FR", "" };
      
      foreach (var value in values) {
         foreach (var cultureName in cultureNames) {
            CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
            String name = culture.Name == "" ? "Invariant" : culture.Name;
            try {
               Decimal amount = Decimal.Parse(value, culture);
               Console.WriteLine("'{0}' --> {1} ({2})", value, amount, name);
            }
            catch (FormatException) {
               Console.WriteLine("'{0}': FormatException ({1})",
                                 value, name);
            }   
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       '1,034,562.91' --> 1034562.91 (en-US)
//       '1,034,562.91': FormatException (fr-FR)
//       '1,034,562.91' --> 1034562.91 (Invariant)
//       
//       '9 532 978,07': FormatException (en-US)
//       '9 532 978,07' --> 9532978.07 (fr-FR)
//       '9 532 978,07': FormatException (Invariant)
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { "1,034,562.91", "9 532 978,07" }
      Dim cultureNames() As String = { "en-US", "fr-FR", "" }
      
      For Each value In values
         For Each cultureName In cultureNames
            Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
            Dim name As String = If(culture.Name = "", "Invariant", culture.Name)
            Try
               Dim amount As Decimal = Decimal.Parse(value, culture)
               Console.WriteLine("'{0}' --> {1} ({2})", value, amount, name)
            Catch e As FormatException
               Console.WriteLine("'{0}': FormatException ({1})",
                                 value, name)
            End Try   
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       '1,034,562.91' --> 1034562.91 (en-US)
'       '1,034,562.91': FormatException (fr-FR)
'       '1,034,562.91' --> 1034562.91 (Invariant)
'       
'       '9 532 978,07': FormatException (en-US)
'       '9 532 978,07' --> 9532978.07 (fr-FR)
'       '9 532 978,07': FormatException (Invariant)

Análisis por lo general se produce en dos contextos:Parsing generally occurs in two contexts:

  • Como una operación que está diseñado para convertir la entrada de usuario en un valor numérico.As an operation that is designed to convert user input into a numeric value.

  • Como una operación que se ha diseñado para un valor numérico; de ida y vuelta es decir, para deserializar un valor numérico que anteriormente se serializó como una cadena.As an operation that is designed to round-trip a numeric value; that is, to deserialize a numeric value that was previously serialized as a string.

Las secciones siguientes tratan estas dos operaciones con mayor detalle.The following sections discuss these two operations in greater detail.

Analizar cadenas de usuarioParsing user strings

Cuando se va a analizar cadenas numéricas escritas por el usuario, siempre debe crear un NumberFormatInfo objeto que refleja la configuración cultural del usuario.When you are parsing numeric strings input by the user, you should always instantiate a NumberFormatInfo object that reflects the user's cultural settings. Para obtener información acerca de cómo crear una instancia de un NumberFormatInfo objeto que refleje las personalizaciones del usuario, consulte el NumberFormatInfo y dinámico de datos sección.For information about how to instantiate a NumberFormatInfo object that reflects user customizations, see the NumberFormatInfo and dynamic data section.

El ejemplo siguiente ilustra la diferencia entre una operación de análisis que refleja la configuración cultural del usuario y otra que no lo hace.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. En este caso, la referencia cultural predeterminada del sistema es en-US, pero el usuario ha definido "," como el símbolo de decimales y "." como separador de grupo en el Panel de Control, región e idioma.In this case, the default system culture is en-US, but the user has defined "," as the decimal symbol and "." as the group separator in Control Panel, Region and Language. Normalmente, estos símbolos se invierten en la referencia cultural en-US de forma predeterminada.Ordinarily, these symbols are reversed in the default en-US culture. Cuando el usuario escribe una cadena que refleja la configuración de usuario y la cadena se analiza un NumberFormatInfo objeto que también refleja la configuración de usuario (reemplazos), la operación de análisis devuelve un resultado correcto.When the user enters a string that reflects user settings, and the string is parsed by a NumberFormatInfo object that also reflects user settings (overrides), the parsing operation returns a correct result. Sin embargo, cuando se analiza la cadena mediante un NumberFormatInfo objeto que refleja la configuración de la referencia cultural en-US estándar, el símbolo de comas para un separador de grupos de errores y se devuelve un resultado incorrecto.However, when the string is parsed by a NumberFormatInfo object that reflects standard en-US cultural settings, it mistakes the comma symbol for a group separator and returns an incorrect result.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo stdCulture = CultureInfo.GetCultureInfo("en-US");
      CultureInfo custCulture = CultureInfo.CreateSpecificCulture("en-US"); 
            
      String value = "310,16";
      try {
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           stdCulture.Name, stdCulture.UseUserOverride);
         Decimal amount = Decimal.Parse(value, stdCulture);
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture));                                                                                        
      }
      catch (FormatException) {
         Console.WriteLine("Unable to parse '{0}'", value);
      }    
      Console.WriteLine();
                                            
      try {
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           custCulture.Name, custCulture.UseUserOverride);
         Decimal amount = Decimal.Parse(value, custCulture);
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture));                                                                                        
      }
      catch (FormatException) {
         Console.WriteLine("Unable to parse '{0}'", value);
      }   
   }
}
// The example displays the following output:
//       en-US culture reflects user overrides: False
//       '310,16' --> 31016
//       
//       en-US culture reflects user overrides: True
//       '310,16' --> 310.16
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim stdCulture As CultureInfo = CultureInfo.GetCultureInfo("en-US")
      Dim custCulture As CultureInfo = CultureInfo.CreateSpecificCulture("en-US") 
            
      Dim value As String = "310,16"
      Try
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           stdCulture.Name, stdCulture.UseUserOverride)
         Dim amount As Decimal = Decimal.Parse(value, stdCulture)
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture))                                                                                        
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}'", value)
      End Try   
      Console.WriteLine()
                                            
      Try
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           custCulture.Name, custCulture.UseUserOverride)
         Dim amount As Decimal = Decimal.Parse(value, custCulture)
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture))                                                                                        
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}'", value)
      End Try   
   End Sub
End Module
' The example displays the following output:
'       en-US culture reflects user overrides: False
'       '310,16' --> 31016
'       
'       en-US culture reflects user overrides: True
'       '310,16' --> 310.16

Serializar y deserializar datos numéricosSerializing and deserializing numeric data

Cuando los datos numéricos se serializa en formato de cadena y más adelante puede deserializar y analizan, las cadenas deben genera y se analizan mediante las convenciones de la referencia cultural invariable.When numeric data is serialized in string format and later deserialized and parsed, the strings should be generated and parsed by using the conventions of the invariant culture. Las operaciones de formato y análisis nunca deben reflejar las convenciones de una referencia cultural concreta.The formatting and parsing operations should never reflect the conventions of a specific culture. Si se usa la configuración de la referencia cultural específica, la portabilidad de los datos está estrictamente limitada; se puede deserializar correctamente sólo en un subproceso cuya configuración específicas de referencias culturales es idénticos a los del subproceso en el que se van a serializar.If culture-specific settings are used, the portability of the data is strictly limited; it can be successfully deserialized only on a thread whose culture-specific settings are identical to those of the thread on which it was serialized. En algunos casos, esto significa que los datos no se pueden incluso se puede deserializar correctamente en el mismo sistema en el que se van a serializar.In some cases, this means that the data cannot even be successfully deserialized on the same system on which it was serialized.

El ejemplo siguiente muestra lo que puede suceder cuando se infringe este principio.The following example illustrates what can happen when this principle is violated. En una matriz de valores de punto flotante se convierten en cadenas cuando el subproceso actual usa la configuración de la referencia cultural específica de la referencia cultural en-US.Floating-point values in an array are converted to strings when the current thread uses the culture-specific settings of the en-US culture. Un subproceso que usa la configuración cultural de la referencia cultural en-GB, a continuación, analiza los datos.The data is then parsed by a thread that uses the culture-specific settings of the en-GB culture. En este caso, aunque cada operación de análisis se realiza correctamente, los datos no ida y vuelta correctamente y se producen daños de datos.In this case, although each parsing operation succeeds, the data does not round-trip successfully and data corruption occurs. En otros casos, se producirá un error en una operación de análisis y un FormatException podría ser una excepción.In other cases, a parsing operation could fail and a FormatException exception could be thrown.

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

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

   private static void PersistData()
   {
      // Define an array of floating-point values.
      Double[] values = { 160325.972, 8631.16, 1.304e5, 98017554.385, 
                          8.5938287084321676e94 };
      Console.WriteLine("Original values: ");
      foreach (var value in values) 
         Console.WriteLine(value.ToString("R", CultureInfo.InvariantCulture));
         
      // Serialize an array of doubles to a file 
      StreamWriter sw = new StreamWriter(@".\NumericData.bin");
      for (int ctr = 0; ctr < values.Length; ctr++) {
         sw.Write(values[ctr].ToString("R"));
         if (ctr < values.Length - 1) sw.Write("|");
      }
      sw.Close();
      Console.WriteLine();
   }
   
   private static void RestoreData()
   {   
      // Deserialize the data
      StreamReader sr = new StreamReader(@".\NumericData.bin");
      String data = sr.ReadToEnd();
      sr.Close();
      
      String[] stringValues = data.Split('|');
      List<Double> newValueList = new List<Double>();
      
      foreach (var stringValue in stringValues) {
         try {
            newValueList.Add(Double.Parse(stringValue));
         }
         catch (FormatException) {
            newValueList.Add(Double.NaN);
         }   
      }                                   

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

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

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

Constructores

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

Inicializa una nueva instancia de la clase NumberFormatInfo en la que se puede escribir y que es independiente de la referencia cultural (invariable).Initializes a new writable instance of the NumberFormatInfo class that is culture-independent (invariant).

Propiedades

CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits

Obtiene o establece el número de posiciones decimales que se van a utilizar en valores de divisa.Gets or sets the number of decimal places to use in currency values.

CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator

Obtiene o establece la cadena que se va a utilizar como separador decimal en valores de divisa.Gets or sets the string to use as the decimal separator in currency values.

CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator

Obtiene o establece la cadena que separa grupos de dígitos a la izquierda de la coma decimal en valores de divisa.Gets or sets the string that separates groups of digits to the left of the decimal in currency values.

CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes

Obtiene o establece el número de dígitos en cada grupo a la izquierda de la coma decimal en valores de divisa.Gets or sets the number of digits in each group to the left of the decimal in currency values.

CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern

Obtiene o establece el modelo de formato para los valores de divisa negativos.Gets or sets the format pattern for negative currency values.

CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern

Obtiene o establece el modelo de formato para los valores de divisa positivos.Gets or sets the format pattern for positive currency values.

CurrencySymbol CurrencySymbol CurrencySymbol CurrencySymbol

Obtiene o establece la cadena que se va a utilizar como símbolo de divisa.Gets or sets the string to use as the currency symbol.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Obtiene un NumberFormatInfo de solo lectura que aplica formato a los valores basándose en la referencia cultural actual.Gets a read-only NumberFormatInfo that formats values based on the current culture.

DigitSubstitution DigitSubstitution DigitSubstitution DigitSubstitution

Obtiene o establece un valor que especifica cómo la interfaz gráfica de usuario muestra la forma de un dígito.Gets or sets a value that specifies how the graphical user interface displays the shape of a digit.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Obtiene un objeto NumberFormatInfo de solo lectura que es independiente de la referencia cultural (invariable).Gets a read-only NumberFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtiene un valor que indica si este objeto NumberFormatInfo es de solo lectura.Gets a value that indicates whether this NumberFormatInfo object is read-only.

NaNSymbol NaNSymbol NaNSymbol NaNSymbol

Obtiene o establece la cadena que representa el valor NaN (no un número) de IEEE.Gets or sets the string that represents the IEEE NaN (not a number) value.

NativeDigits NativeDigits NativeDigits NativeDigits

Obtiene o establece una matriz de cadenas de dígitos nativos equivalentes a los dígitos occidentales del 0 al 9.Gets or sets a string array of native digits equivalent to the Western digits 0 through 9.

NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol

Obtiene o establece la cadena que representa un infinito negativo.Gets or sets the string that represents negative infinity.

NegativeSign NegativeSign NegativeSign NegativeSign

Obtiene o establece la cadena que denota que el número asociado es negativo.Gets or sets the string that denotes that the associated number is negative.

NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits

Obtiene o establece el número de posiciones decimales que se van a utilizar en valores numéricos.Gets or sets the number of decimal places to use in numeric values.

NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator

Obtiene o establece la cadena que se va a utilizar como separador decimal en valores numéricos.Gets or sets the string to use as the decimal separator in numeric values.

NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator

Obtiene o establece la cadena que separa grupos de dígitos a la izquierda de la coma decimal en valores numéricos.Gets or sets the string that separates groups of digits to the left of the decimal in numeric values.

NumberGroupSizes NumberGroupSizes NumberGroupSizes NumberGroupSizes

Obtiene o establece el número de dígitos en cada grupo a la izquierda de la coma decimal en valores numéricos.Gets or sets the number of digits in each group to the left of the decimal in numeric values.

NumberNegativePattern NumberNegativePattern NumberNegativePattern NumberNegativePattern

Obtiene o establece el modelo de formato para los valores numéricos negativos.Gets or sets the format pattern for negative numeric values.

PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits

Obtiene o establece el número de posiciones decimales que se van a utilizar en valores de porcentaje.Gets or sets the number of decimal places to use in percent values.

PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator

Obtiene o establece la cadena que se va a utilizar como separador decimal en valores de porcentaje.Gets or sets the string to use as the decimal separator in percent values.

PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator

Obtiene o establece la cadena que separa grupos de dígitos a la izquierda de la coma decimal en valores de porcentaje.Gets or sets the string that separates groups of digits to the left of the decimal in percent values.

PercentGroupSizes PercentGroupSizes PercentGroupSizes PercentGroupSizes

Obtiene o establece el número de dígitos en cada grupo a la izquierda de la coma decimal en valores de porcentaje.Gets or sets the number of digits in each group to the left of the decimal in percent values.

PercentNegativePattern PercentNegativePattern PercentNegativePattern PercentNegativePattern

Obtiene o establece el modelo de formato para los valores de porcentaje negativos.Gets or sets the format pattern for negative percent values.

PercentPositivePattern PercentPositivePattern PercentPositivePattern PercentPositivePattern

Obtiene o establece el modelo de formato para los valores de porcentaje positivos.Gets or sets the format pattern for positive percent values.

PercentSymbol PercentSymbol PercentSymbol PercentSymbol

Obtiene o establece la cadena que se va a utilizar como símbolo de porcentaje.Gets or sets the string to use as the percent symbol.

PerMilleSymbol PerMilleSymbol PerMilleSymbol PerMilleSymbol

Obtiene o establece la cadena que se va a utilizar como símbolo de por mil.Gets or sets the string to use as the per mille symbol.

PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol

Obtiene o establece la cadena que representa un infinito positivo.Gets or sets the string that represents positive infinity.

PositiveSign PositiveSign PositiveSign PositiveSign

Obtiene o establece la cadena que denota que el número asociado es positivo.Gets or sets the string that denotes that the associated number is positive.

Métodos

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

Crea una copia superficial del objeto NumberFormatInfo.Creates a shallow copy of the NumberFormatInfo object.

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

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

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

Obtiene un objeto del tipo especificado que proporciona un servicio de formato numérico.Gets an object of the specified type that provides a number formatting service.

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

Sirve como la función hash predeterminada.Serves as the default hash function.

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

Obtiene el objeto NumberFormatInfo asociado al IFormatProvider especificado.Gets the NumberFormatInfo associated with the specified IFormatProvider.

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

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

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

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

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

Devuelve un contenedor de NumberFormatInfo de solo lectura.Returns a read-only NumberFormatInfo wrapper.

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

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)

Se aplica a

Consulte también: