Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase NumberFormatInfo

 

Publicado: octubre de 2016

Proporciona información de formato específica de la referencia cultural y los valores numéricos de análisis.

Espacio de nombres:   System.Globalization
Ensamblado:  mscorlib (en mscorlib.dll)

System.Object
  System.Globalization.NumberFormatInfo

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class NumberFormatInfo : ICloneable, IFormatProvider

NombreDescripción
System_CAPS_pubmethodNumberFormatInfo()

Inicializa una nueva instancia de la clase NumberFormatInfo en la que se puede escribir y que es independiente de la referencia cultural (invariable).

NombreDescripción
System_CAPS_pubpropertyCurrencyDecimalDigits

Obtiene o establece el número de posiciones decimales que se van a utilizar en valores de divisa.

System_CAPS_pubpropertyCurrencyDecimalSeparator

Obtiene o establece la cadena que se va a utilizar como separador decimal en valores de divisa.

System_CAPS_pubpropertyCurrencyGroupSeparator

Obtiene o establece la cadena que separa grupos de dígitos a la izquierda de la coma decimal en valores de divisa.

System_CAPS_pubpropertyCurrencyGroupSizes

Obtiene o establece el número de dígitos en cada grupo a la izquierda de la coma decimal en valores de divisa.

System_CAPS_pubpropertyCurrencyNegativePattern

Obtiene o establece el modelo de formato para los valores de divisa negativos.

System_CAPS_pubpropertyCurrencyPositivePattern

Obtiene o establece el modelo de formato para los valores de divisa positivos.

System_CAPS_pubpropertyCurrencySymbol

Obtiene o establece la cadena que se va a utilizar como símbolo de divisa.

System_CAPS_pubpropertySystem_CAPS_staticCurrentInfo

Obtiene un NumberFormatInfo de solo lectura que aplica formato a los valores basándose en la referencia cultural actual.

System_CAPS_pubpropertyDigitSubstitution

Obtiene o establece un valor que especifica cómo la interfaz gráfica de usuario muestra la forma de un dígito.

System_CAPS_pubpropertySystem_CAPS_staticInvariantInfo

Obtiene un objeto NumberFormatInfo de solo lectura que es independiente de la referencia cultural (invariable).

System_CAPS_pubpropertyIsReadOnly

Obtiene un valor que indica si este objeto NumberFormatInfo es de solo lectura.

System_CAPS_pubpropertyNaNSymbol

Obtiene o establece la cadena que representa el valor NaN (no un número) de IEEE.

System_CAPS_pubpropertyNativeDigits

Obtiene o establece una matriz de cadenas de dígitos nativos equivalentes a los dígitos occidentales del 0 al 9.

System_CAPS_pubpropertyNegativeInfinitySymbol

Obtiene o establece la cadena que representa un infinito negativo.

System_CAPS_pubpropertyNegativeSign

Obtiene o establece la cadena que denota que el número asociado es negativo.

System_CAPS_pubpropertyNumberDecimalDigits

Obtiene o establece el número de posiciones decimales que se van a utilizar en valores numéricos.

System_CAPS_pubpropertyNumberDecimalSeparator

Obtiene o establece la cadena que se va a utilizar como separador decimal en valores numéricos.

System_CAPS_pubpropertyNumberGroupSeparator

Obtiene o establece la cadena que separa grupos de dígitos a la izquierda de la coma decimal en valores numéricos.

System_CAPS_pubpropertyNumberGroupSizes

Obtiene o establece el número de dígitos en cada grupo a la izquierda de la coma decimal en valores numéricos.

System_CAPS_pubpropertyNumberNegativePattern

Obtiene o establece el modelo de formato para los valores numéricos negativos.

System_CAPS_pubpropertyPercentDecimalDigits

Obtiene o establece el número de posiciones decimales que se van a utilizar en valores de porcentaje.

System_CAPS_pubpropertyPercentDecimalSeparator

Obtiene o establece la cadena que se va a utilizar como separador decimal en valores de porcentaje.

System_CAPS_pubpropertyPercentGroupSeparator

Obtiene o establece la cadena que separa grupos de dígitos a la izquierda de la coma decimal en valores de porcentaje.

System_CAPS_pubpropertyPercentGroupSizes

Obtiene o establece el número de dígitos en cada grupo a la izquierda de la coma decimal en valores de porcentaje.

System_CAPS_pubpropertyPercentNegativePattern

Obtiene o establece el modelo de formato para los valores de porcentaje negativos.

System_CAPS_pubpropertyPercentPositivePattern

Obtiene o establece el modelo de formato para los valores de porcentaje positivos.

System_CAPS_pubpropertyPercentSymbol

Obtiene o establece la cadena que se va a utilizar como símbolo de porcentaje.

System_CAPS_pubpropertyPerMilleSymbol

Obtiene o establece la cadena que se va a utilizar como símbolo de por mil.

System_CAPS_pubpropertyPositiveInfinitySymbol

Obtiene o establece la cadena que representa un infinito positivo.

System_CAPS_pubpropertyPositiveSign

Obtiene o establece la cadena que denota que el número asociado es positivo.

NombreDescripción
System_CAPS_pubmethodClone()

Crea una copia superficial del objeto NumberFormatInfo.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_pubmethodGetFormat(Type)

Obtiene un objeto del tipo especificado que proporciona un servicio de formato numérico.

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodSystem_CAPS_staticGetInstance(IFormatProvider)

Obtiene el objeto NumberFormatInfo asociado al IFormatProvider especificado.

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodSystem_CAPS_staticReadOnly(NumberFormatInfo)

Devuelve un contenedor de NumberFormatInfo de solo lectura.

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de 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.

Puede crear instancias de un NumberFormatInfo objeto para la referencia cultural del subproceso actual en cualquiera de las maneras siguientes. En cada caso, el valor devuelto NumberFormatInfo objeto es de solo lectura.

En el ejemplo siguiente se utiliza tres maneras de crear NumberFormatInfo objetos que representan las convenciones de formato de la referencia cultural actual. También recupera el valor de la IsReadOnly propiedad para ilustrar que cada objeto es de solo lectura.

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

Puede crear una escritura NumberFormatInfo objeto que representa las convenciones de la referencia cultural del subproceso actual en cualquiera de las maneras siguientes:

  • Recuperando una NumberFormatInfo objeto en cualquiera de las maneras en que se muestra en el ejemplo de código anterior y llamar a la Clone método devuelto NumberFormatInfo objeto. Esto crea una copia del original NumberFormatInfo objeto, salvo que su IsReadOnly propiedad es false.

  • Llamando a la CultureInfo.CreateSpecificCulture método para crear un CultureInfo que representa la referencia cultural actual del objeto y, a continuación, usar su CultureInfo.NumberFormat propiedad para recuperar la NumberFormatInfo objeto.

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 sólo lectura.

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

Tenga en cuenta que el sistema operativo Windows permite al usuario reemplazar algunos de los NumberFormatInfo valores de propiedad que se usa en formato numéricas y las operaciones a través de análisis el región e idioma elemento Panel de Control. Por ejemplo, un usuario cuya referencia cultural es inglés (Estados Unidos) puede mostrar los valores de moneda como 1.1 USD en lugar del predeterminado de $1.1. El NumberFormatInfo objetos recuperados de las maneras en que se describe anteriormente reflejan todos estas invalidaciones del usuario. Si esto es indeseable, puede crear un NumberFormatInfo objeto que no refleje las invalidaciones del usuario (y que también es de lectura y escritura en lugar de solo lectura) llamando a la CultureInfo.CultureInfo(String, Boolean) constructor y proporcionar un valor de false para el useUserOverride argumento. En el ejemplo siguiente se proporciona una ilustración de un sistema cuya referencia cultural actual es inglés (Estados Unidos) y cuyos símbolos de moneda se cambió el valor predeterminado de $ a 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: $

Si el CultureInfo.UseUserOverride propiedad se establece en true, las propiedades CultureInfo.DateTimeFormat, CultureInfo.NumberFormat, y CultureInfo.TextInfo también se recuperan desde la configuración del usuario. Si la configuración de usuario es incompatible 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 no están definidos.

La referencia cultural invariable representa una referencia cultural de la referencia cultural. Se basa en el idioma inglés, pero no en cualquier angloparlante país o región determinados. Aunque los datos de referencias culturales específicas pueden ser dinámicos y se pueden cambiar para reflejar nuevas convenciones culturales o las preferencias del usuario, no cambian los datos de la referencia cultural invariable. Un NumberFormatInfo objeto que representa las convenciones de formato de la referencia cultural se puede usar para operaciones en los resultados no deberían variar en cadenas de formato según la referencia cultural.

Puede crear instancias de un NumberFormatInfo objeto que representa las convenciones de formato de la referencia cultural de las maneras siguientes:

  • Recuperando el valor de la InvariantInfo propiedad. El valor devuelto NumberFormatInfo objeto es de solo lectura.

  • Recuperando el valor de la CultureInfo.NumberFormat propiedad desde la CultureInfo objeto devuelto por la CultureInfo.InvariantCulture propiedad. El valor devuelto NumberFormatInfo objeto es de solo lectura.

  • Llamando al método sin parámetros NumberFormatInfo constructor de clase. El valor devuelto NumberFormatInfo objeto es de lectura y escritura.

El ejemplo siguiente utiliza cada uno de estos métodos para crear instancias de un NumberFormatInfo objeto que representa la referencia cultural invariable. A continuación, indica si el objeto es de sólo lectura

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

Una referencia cultural concreta representa el idioma que se habla en un determinado país o región. Por ejemplo, en-US es una referencia cultural específica que representa el idioma inglés hablado en Estados Unidos y en-CA es una referencia cultural específica que representa el idioma inglés que se habla en Canadá. Puede crear instancias de un NumberFormatInfo objeto que representa las convenciones de formato de una referencia cultural específica de las maneras siguientes:

El ejemplo siguiente utiliza estos cuatro formas de crear un NumberFormatInfo objeto que refleja las convenciones de formato de la referencia cultural Indonesio (Indonesia). También indica si cada objeto es de solo lectura.

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

Una referencia cultural neutra representa una referencia cultural o idioma que es independiente de un país o región. Normalmente, es el elemento primario de uno o más de referencias culturales específicas. Por ejemplo, fr es una referencia cultural neutra para francés y el elemento primario de la referencia cultural fr-FR. 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.

System_CAPS_noteNota

En el .NET Framework 3.5 y versiones anteriores, intentar recuperar un NumberFormatInfo objeto que refleja las convenciones de formato de una referencia cultural neutra produce un NotSupportedException excepción.

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. En lugar de rellenar el NumberFormatInfo de 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. Por ejemplo, el NumberFormatInfo de objeto para la referencia cultural neutra en refleja las convenciones de formato de la referencia cultural en-US y el NumberFormatInfo de objeto para la referencia cultural fr refleja las convenciones de formato de la referencia cultural fr-FR.

Puede utilizar código similar al siguiente para determinar las convenciones de formato de la referencia cultural concreta representa cada referencia cultural neutra.

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();
   }
}

Los datos específicos de la referencia cultural para dar formato a valores numéricos proporcionados por el NumberFormatInfo clase es dinámica, como los datos de referencia culturales proporcionados por el CultureInfo clase. No debe hacer ninguna suposición sobre la estabilidad de los valores de NumberFormatInfo objetos que están asociados a determinado CultureInfo objetos. Sólo los datos proporcionados por la referencia cultural y su NumberFormatInfo objeto es estable. Otros datos pueden cambiar entre sesiones de aplicación o incluso dentro de una sola sesión, por los motivos siguientes:

  • Actualizaciones del sistema. Las preferencias culturales, como el símbolo de moneda o los formatos de moneda cambian con el tiempo. Cuando esto sucede, Windows Update incluye cambios en la NumberFormatInfo valor de propiedad para una referencia cultural determinada.

  • Referencias culturales de reemplazo. La CultureAndRegionInfoBuilder clase puede utilizarse para reemplazar los datos de una referencia cultural existente.

  • Cambios en cascada a valores de propiedad. Pueden cambiar varias propiedades relacionadas con la referencia cultural en tiempo de ejecución, a su vez, lo que hace que NumberFormatInfo datos a cambiar. Por ejemplo, la referencia cultural actual puede cambiarse mediante programación o a través de la acción del usuario. Cuando esto sucede, la NumberFormatInfo objeto devuelto por la CurrentInfo propiedad cambia a un objeto asociado a la referencia cultural actual.

  • Preferencias del usuario. Los usuarios de la aplicación pueden invalidar algunos de los valores asociados a la referencia cultural del sistema actual a través de las opciones de idioma y región en el Panel de Control. Por ejemplo, los usuarios pueden optar a un símbolo de moneda diferente o un símbolo de separador de decimales diferente. Si el CultureInfo.UseUserOverride propiedad se establece en true (su valor predeterminado), las propiedades de la NumberFormatInfo objeto también se recuperan desde la configuración del usuario.

A partir de .NET Framework 2.0, todas las propiedades reemplazable por el usuario de un NumberFormatInfo objeto se inicializan cuando se crea el objeto. No hay todavía posibilidad de incoherencia, porque ni la creación de objetos ni el proceso de reemplazo de usuario es atómico y los valores correspondientes pueden cambiar durante la creación de objetos. Sin embargo, estas incoherencias deben ser muy poco habitual.

Puede controlar si los reemplazos se reflejan en NumberFormatInfo objetos que representan la misma referencia cultural que la referencia cultural del subproceso actual. La tabla siguiente enumeran las formas en que un NumberFormatInfo objeto se puede recuperar e indica si el objeto resultante refleja invalidaciones del usuario.

Origen de objeto CultureInfo y NumberFormatInfo

Refleja las invalidaciones de usuario

Propiedad CultureInfo.CurrentCulture.NumberFormat

Si

Propiedad NumberFormatInfo.CurrentInfo

Si

Método CultureInfo.CreateSpecificCulture

Si

Método CultureInfo.GetCultureInfo

No

Constructor CultureInfo(String)

Si

Constructor CultureInfo.CultureInfo(String, Boolean)

En función de valor de useUserOverride parámetro

A menos que haya una razón de peso para no hacerlo, debe respetar las invalidaciones del usuario cuando se utiliza la NumberFormatInfo objeto en aplicaciones de cliente para dar formato y analizar la entrada del usuario o para mostrar datos numéricos. Para las aplicaciones de servidor o desatendida, no debe respetar invalidaciones del usuario. Sin embargo, si está utilizando la NumberFormatInfo objeto ya sea explícitamente o implícitamente para conservar datos numéricos en forma de cadena, debería usar un NumberFormatInfo objeto que refleja las convenciones de formato de la referencia cultural invariable, o bien debe especificar una cadena de formato numérico personalizado que utilice, independientemente de la referencia cultural.

Un NumberFormatInfo objeto se usa implícita o explícitamente en numérico todas las operaciones de formato. Estos incluyen llamadas a los métodos siguientes:

Todas las operaciones de formato numéricas hacer uso de un IFormatProvider implementación. El IFormatProvider interfaz incluye un único método, 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. El método es responsable de devolver una instancia de ese tipo o null, si no puede proporcionar una instancia del tipo. .NET Framework proporciona dos IFormatProvider implementaciones para dar formato a números:

  • La CultureInfo clase, que representa una referencia cultural concreta (o en un idioma específico en un país o región específico). En la operación de formato numérico el CultureInfo.GetFormat método devuelve el NumberFormatInfo objeto asociado con su CultureInfo.NumberFormat propiedad.

  • La NumberFormatInfo clase, que proporciona información sobre las convenciones de formato de la referencia cultural asociada. El NumberFormatInfo.GetFormat método devuelve una instancia de sí mismo.

Si un IFormatProvider implementación no se proporciona explícitamente, a un método de formato un CultureInfo objeto devuelto por la CultureInfo.CurrentCulture se utiliza la propiedad que representa la referencia cultural del subproceso actual.

En el ejemplo siguiente se ilustra la relación entre el IFormatProvider interfaz y la NumberFormatInfo clase en operaciones de formato definiendo un personalizado IFormatProvider implementación. Su GetFormat método muestra el nombre de tipo del objeto solicitado por la operación de formato. Si la interfaz está solicitando un NumberFormatInfo de objeto, este método proporciona la NumberFormatInfo objeto para la referencia cultural del subproceso actual. Como la salida de muestra en el ejemplo, el Decimal.ToString(IFormatProvider) de solicitudes de método un NumberFormatInfo objeto para proporcionar información de formato, mientras que la String.Format(IFormatProvider, String, Object[]) de solicitudes de método NumberFormatInfo y DateTimeFormatInfo objetos así como un ICustomFormatter implementación.

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

Si un IFormatProvider implementación no se proporciona explícitamente en la 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.

Cada operación de formato utiliza un estándar o una cadena de formato numérico personalizado para generar una cadena de resultado de un número. En algunos casos, el uso de una cadena de formato para generar una cadena de resultado es explícito, como en el ejemplo siguiente. Este código llama el Decimal.ToString(IFormatProvider) método para convertir un Decimal valor a un número de representaciones de cadena diferentes usando las convenciones de formato de la referencia cultural en-US.

using System;
using System.Globalization;

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

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

En otros casos, el uso de una cadena de formato está implícito. Por ejemplo, en las siguientes llamadas al método predeterminado o sin parámetros Decimal.ToString() (método), el valor de la Decimal instancia se le aplica formato mediante el especificador de formato general ("G") y las convenciones de la referencia cultural actual, que en este caso es la referencia cultural en-US.

using System;

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

      foreach (var value in values) {
         string resultString = value.ToString();
         Console.WriteLine(resultString);
         Console.WriteLine();      
      }   
   }
}
// The example displays the following output:
//       1345.6538
//       
//       1921651.16

Cada cadena de formato numérico estándar utiliza uno o más NumberFormatInfo Propiedades para determinar el patrón o los símbolos utilizados en la cadena de resultado. De forma similar, cada especificador de formato numérico personalizado excepto "0" y "#" inserción símbolos en la cadena de resultado que se definen mediante NumberFormatInfo Propiedades. La siguiente tabla enumera el estándar y los especificadores de formato numérico personalizado y sus asociados NumberFormatInfo Propiedades. Para cambiar la apariencia de la cadena de resultado de una referencia cultural determinada, consulte el Propiedades NumberFormatInfo modificar sección. Para obtener más información sobre el uso de estos especificadores de formato, consulte Cadenas con formato numérico estándar y Cadenas con formato numérico personalizado.

Especificador de formato

Propiedades asociadas

"C" o "c" (especificador de formato de moneda)

CurrencyDecimalDigits, para definir el número predeterminado de dígitos fraccionarios.

CurrencyDecimalSeparator, para definir el símbolo de separador decimal.

CurrencyGroupSeparator, para definir el grupo o miles separador.

CurrencyGroupSizes, para definir los tamaños de grupos enteros.

CurrencyNegativePattern, para definir el modelo de valores de divisa negativos.

CurrencyPositivePattern, para definir el modelo de valores de divisa positivos.

CurrencySymbol, para definir el símbolo de moneda.

NegativeSign, para definir el símbolo de signo negativo.

"D" o "d" (especificador de formato decimal)

NegativeSign, para definir el símbolo de signo negativo.

"E" o "e" (especificador de formato exponencial o científicos)

NegativeSign, para definir el símbolo de signo negativo en la mantisa y el exponente.

NumberDecimalSeparator, para definir el símbolo de separador decimal.

PositiveSign, para definir el símbolo de signo positivo en el exponente.

"F" o "f" (especificador de formato de punto fijo)

NegativeSign, para definir el símbolo de signo negativo.

NumberDecimalDigits, para definir el número predeterminado de dígitos fraccionarios.

NumberDecimalSeparator, para definir el símbolo de separador decimal.

"G" o "g" (especificador de formato general)

NegativeSign, para definir el símbolo de signo negativo.

NumberDecimalSeparator, para definir el símbolo de separador decimal.

PositiveSign, para definir el símbolo de signo positivo para cadenas de resultado en formato exponencial.

"N" o "n" (especificador de formato numérico)

NegativeSign, para definir el símbolo de signo negativo.

NumberDecimalDigits, para definir el número predeterminado de dígitos fraccionarios.

NumberDecimalSeparator, para definir el símbolo de separador decimal.

NumberGroupSeparator, para definir el símbolo de separador (miles) de grupo.

NumberGroupSizes, para definir el número de dígitos enteros de un grupo.

NumberNegativePattern, para definir el formato de los valores negativos.

"P" o "p" (especificador de formato de porcentaje)

NegativeSign, para definir el símbolo de signo negativo.

PercentDecimalDigits, para definir el número predeterminado de dígitos fraccionarios.

PercentDecimalSeparator, para definir el símbolo de separador decimal.

PercentGroupSeparator, para definir el símbolo de separador de grupo.

PercentGroupSizes, para definir el número de dígitos enteros de un grupo.

PercentNegativePattern, para definir la posición del símbolo de porcentaje y del símbolo negativo para los valores negativos.

PercentPositivePattern, para definir la ubicación del símbolo de porcentaje para los valores positivos.

PercentSymbol, para definir el símbolo de porcentaje.

"R" o "r" (especificador de formato de ida y vuelta)

NegativeSign, para definir el símbolo de signo negativo.

NumberDecimalSeparator, para definir el símbolo de separador decimal.

PositiveSign, para definir el símbolo de signo positivo de un exponente.

"X" o "x" (especificador de formato hexadecimal)

Ninguno.

"." (especificador de formato personalizado de punto decimal)

NumberDecimalSeparator, para definir el símbolo de separador decimal.

"," (especificador de formato personalizado de separador de grupo)

NumberGroupSeparator, para definir el símbolo de separador de grupos (miles).

"%" (especificador de formato personalizado de marcador de posición de porcentaje)

PercentSymbol, para definir el símbolo de porcentaje.

"‰" (por el especificador de formato personalizado de marcador de posición de mil)

PerMilleSymbol, para definir el símbolo de por mil.

"E" (especificador de formato personalizado de notación exponencial)

NegativeSign, para definir el símbolo de signo negativo en la mantisa y el exponente.

PositiveSign, para definir el símbolo de signo positivo en el exponente.

Tenga en cuenta que la NumberFormatInfo clase incluye un NativeDigits propiedad que especifica los dígitos de base 10 de una referencia cultural específica. Sin embargo, la propiedad no se utiliza en el formato de las operaciones; solo los dígitos Latín básico 0 (u+0030) y 9 (u+0039) se utilizan en la cadena de resultado. 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.

Puede modificar las propiedades de un NumberFormatInfo objeto para personalizar la cadena de resultado producida en la operación de formato numérico. Para hacerlo:

  1. Crear una copia de lectura y escritura de un NumberFormatInfo objeto cuyas convenciones de formato que desee modificar. Para obtener más información, consulte el instancias de un objeto NumberFormatInfo sección.

  2. Modifique la propiedad o propiedades que se utilizan para generar la cadena de resultado deseado. Para obtener información sobre el uso de métodos de formato cómo NumberFormatInfo las propiedades para definir cadenas de resultado, consulte el dar formato a cadenas y propiedades NumberFormatInfo sección.

  3. Utilice personalizado NumberFormatInfo objeto como el IFormatProvider argumentos en las llamadas a métodos de formato.

System_CAPS_noteNota

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 (las referencias culturales de una referencia cultural que tiene un nombre único y que complementa existente) o una referencia cultural de reemplazo (uno que se utiliza en lugar de una referencia cultural específica).

Las secciones siguientes proporcionan algunos ejemplos.

En el ejemplo siguiente se modifica un NumberFormatInfo objeto que representa las convenciones de formato de la referencia cultural en-US. Asigna el símbolo de moneda ISO 4217 a la CurrencySymbol propiedad y define un modelo para los valores de divisa que consta del símbolo de moneda seguido de un espacio y un valor numérico.

using System;
using System.Globalization;

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

      // Use the ISO currency symbol instead of the native currency symbol.
      nfi.CurrencySymbol =  (new RegionInfo(enUS.Name)).ISOCurrencySymbol;
      // Change the positive currency pattern to <code><space><value>.
      nfi.CurrencyPositivePattern = 2;
      // Change the negative currency pattern to <code><space><sign><value>.     
      nfi.CurrencyNegativePattern = 12;

      // Produce the result strings by calling ToString.
      Decimal[] values = { 1065.23m, 19.89m, -.03m, -175902.32m };
      foreach (var value in values)
         Console.WriteLine(value.ToString("C", enUS));

      Console.WriteLine();

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

Muchos de los números de identificación nacional consistir exclusivamente en dígitos y así que fácilmente se puede aplicar formato al modificar las propiedades de un NumberFormatInfo objeto. Por ejemplo, un número de seguridad social en los Estados Unidos consta de 9 dígitos que se organizan de esta forma: XXX-XX-XXXX. En el siguiente ejemplo se supone que los números de seguridad social se almacenan como valores de entero y formatos de forma adecuada.

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

El análisis implica convertir la representación de cadena de un número en un número. Cada tipo numérico en .NET Framework incluye dos métodos sobrecargados de análisis: Parse y 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. El TryParse método convierte una cadena en un número, se asigna el número a una out argumento y devuelve un Boolean valor que indica si la conversión se realizó correctamente.

Utilizan los métodos de análisis implícita o explícitamente una NumberStyles el 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. Si un NumberStyles valor no es proporcionado en la llamada de método, el valor predeterminado es una NumberStyles valor que incluye el Float y AllowThousands marcadores, que especifica que la cadena analizada puede incluir símbolos de grupo, un separador de decimales, 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.

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 producirse en la cadena que se va a analizar. Si un NumberFormatInfo objeto no se proporciona, el valor predeterminado es el NumberFormatInfo para la referencia cultural del subproceso actual. Para obtener más información acerca del 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).

En el ejemplo siguiente se muestra la naturaleza de la referencia cultural de análisis de cadenas. Intenta analizar una cadena que incluye miles separadores usando las convenciones de en-US, fr-FR 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 separador de grupos y una coma como separador decimal no analiza en las referencias culturales invariables y en-US.

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)

Análisis generalmente se realiza en dos contextos:

  • Como una operación que está diseñado para convertir la entrada de usuario en un valor numérico.

  • Como una operación que se ha diseñado para unificar un valor numérico; es decir, al deserializar un valor numérico que previamente se ha serializado como una cadena.

Las secciones siguientes tratan estas dos operaciones con mayor detalle.

Cuando se analiza la entrada de cadenas numéricas por el usuario, siempre debe crear un NumberFormatInfo objeto que refleja la configuración de la referencia cultural del usuario. Para obtener información acerca de cómo crear una instancia de un NumberFormatInfo objeto que refleje las personalizaciones de usuario, consulte el NumberFormatInfo y datos dinámicos sección.

En el ejemplo siguiente se ilustra la diferencia entre una operación de análisis que refleja la configuración de referencia cultural del usuario y otro que no. 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, idioma y región. Normalmente, estos símbolos se invierten en la referencia cultural en-US de forma predeterminada. Cuando el usuario escribe una cadena que refleja la configuración de usuario y la cadena se analiza una NumberFormatInfo objeto que también refleja la configuración de usuario (reemplazos), la operación de análisis devuelve un resultado correcto. Sin embargo, cuando la cadena se analiza una NumberFormatInfo objeto que refleja la configuración de la referencia cultural en-US estándar, el símbolo de coma de separador de grupos de errores y se devuelve un resultado incorrecto.

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

Cuando datos numéricos se serializa en formato de cadena y posteriormente deserializa y se analiza, las cadenas deben generadas y se analiza usando las convenciones de la referencia cultural invariable. Las operaciones de formato y análisis nunca deben reflejar las convenciones de una referencia cultural concreta. Si se utiliza 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 de referencia cultural es idénticos a los del subproceso en el que se serializó. En algunos casos, esto significa que los datos no se puede deserializar correctamente en el mismo sistema en el que se serializó.

En el ejemplo siguiente se muestra lo que puede suceder cuando se infringe este principio. En una matriz de valores de punto flotante se convierten en cadenas cuando el subproceso actual utiliza la configuración de la referencia cultural específica de la referencia cultural en-US. A continuación, se analizan los datos de un subproceso que usa la configuración específica de la referencia cultural de la referencia cultural en-GB. 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 en los datos. En otros casos, se producirá un error en una operación de análisis y un FormatException se podría producir la excepción.

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

En el ejemplo siguiente se muestra cómo recuperar un NumberFormatInfo objeto correspondiente CultureInfo y utilice el objeto recuperado a información de la referencia cultural concreta de formato de número de consulta.

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'

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: