NumberFormatInfo Clase

Definición

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

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

Ejemplos

En el ejemplo siguiente se muestra cómo recuperar un NumberFormatInfo objeto para un objeto correspondiente CultureInfo y usar el objeto recuperado para consultar la información de formato de números para la referencia cultural concreta.

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 usa al dar formato y analizar valores numéricos. Esta información incluye el símbolo de moneda, el símbolo decimal, el símbolo separador de grupo y los símbolos para signos positivos y negativos.

Creación de instancias de un objeto NumberFormatInfo

Puede crear instancias de un NumberFormatInfo objeto que represente las convenciones de formato de la referencia cultural actual, la referencia cultural invariable, una referencia cultural específica o una referencia cultural neutra.

Creación de instancias de un objeto NumberFormatInfo para la referencia cultural actual

Puede crear una instancia de un NumberFormatInfo objeto para la referencia cultural actual de cualquiera de las maneras siguientes. En cada caso, el objeto devuelto NumberFormatInfo es de solo lectura.

En el ejemplo siguiente se usan estas tres formas 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
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 un objeto grabable NumberFormatInfo que represente las convenciones de la referencia cultural actual de cualquiera de las maneras siguientes:

En el ejemplo siguiente se muestran estas dos formas de crear instancias de un NumberFormatInfo objeto y se muestra el valor de su IsReadOnly propiedad para ilustrar que el objeto no es de solo 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
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 invalidar algunos de los valores de propiedad usados en las NumberFormatInfo operaciones de formato numérico y análisis a través del elemento Región y Idioma en Panel de control. Por ejemplo, un usuario cuya referencia cultural es inglés (Estados Unidos) podría optar por mostrar valores de moneda como 1,1 USD en lugar del valor predeterminado de 1,1 USD. Los NumberFormatInfo objetos recuperados de las maneras descritas anteriormente reflejan estas invalidaciones de usuario. Si esto no es deseable, puede crear un NumberFormatInfo objeto que no refleje las invalidaciones de usuario (y que también es de lectura y escritura en lugar de solo lectura) llamando al CultureInfo.CultureInfo(String, Boolean) constructor y proporcionando un valor de false para el useUserOverride argumento. En el ejemplo siguiente se proporciona una ilustración para un sistema cuya referencia cultural actual es inglés (Estados Unidos) y cuyo símbolo de moneda se ha cambiado del 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: $
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 la CultureInfo.UseUserOverride propiedad se establece trueen , las propiedades CultureInfo.DateTimeFormat, CultureInfo.NumberFormaty CultureInfo.TextInfo también se recuperan de la configuración del usuario. Si la configuración de usuario no es compatible con la referencia cultural asociada al 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.

Creación de instancias de un objeto NumberFormatInfo para la referencia cultural invariable

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

Puede crear una instancia de un NumberFormatInfo objeto que represente las convenciones de formato de la referencia cultural invariable de las maneras siguientes:

En el ejemplo siguiente se usa cada uno de estos métodos para crear una instancia de un NumberFormatInfo objeto que representa la referencia cultural invariable. A continuación, indica si el objeto es de solo 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
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

Creación de instancias de un objeto NumberFormatInfo para una referencia cultural específica

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

En el ejemplo siguiente se usan estas cuatro formas de crear un NumberFormatInfo objeto que refleje las convenciones de formato de la referencia cultural indonesia (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
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

Creación de instancias de un objeto NumberFormatInfo para una referencia cultural neutra

Una referencia cultural neutral representa una referencia cultural o un idioma que es independiente de un país o región. Normalmente es el elemento primario de una o varias referencias culturales específicas. Por ejemplo, fr es una referencia cultural neutra para el idioma francés y el elemento primario de la referencia cultural fr-FR. Se crea un NumberFormatInfo objeto que representa las convenciones de formato de una referencia cultural neutra de la misma manera que se crea un NumberFormatInfo objeto que representa las convenciones de formato de una referencia cultural específica.

Nota

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

Sin embargo, dado que es independiente de un país o región específico, una referencia cultural neutral carece de información de formato específica de la referencia cultural. En lugar de rellenar el NumberFormatInfo objeto con valores genéricos, el .NET Framework devuelve un NumberFormatInfo objeto que refleja las convenciones de formato de una referencia cultural específica que es un elemento secundario de la referencia cultural neutra. Por ejemplo, el NumberFormatInfo objeto de la referencia cultural neutra refleja las convenciones de formato de la referencia cultural en-US y el NumberFormatInfo objeto de la referencia cultural fr refleja las convenciones de formato de la referencia cultural fr-FR.

Puede usar código como el siguiente para determinar qué convenciones de formato de referencia cultural específicas 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();
   }
}
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 datos dinámicos

Los datos específicos de la referencia cultural para dar formato a los valores numéricos proporcionados por la NumberFormatInfo clase son dinámicos, al igual que los datos culturales proporcionados por la CultureInfo clase. No debe realizar ninguna suposición sobre la estabilidad de los valores de NumberFormatInfo los objetos asociados a objetos concretos CultureInfo . Solo los datos proporcionados por la referencia cultural invariable y su objeto asociado NumberFormatInfo son estables. Otros datos pueden cambiar entre sesiones de aplicación, o incluso dentro de una sola sesión, por los siguientes motivos:

  • 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 el valor de propiedad NumberFormatInfo de una referencia cultural determinada.

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

  • Cambios en cascada en los valores de propiedad. Varias propiedades relacionadas con la referencia cultural pueden cambiar en tiempo de ejecución, lo que, a su vez, hace NumberFormatInfo que los datos cambien. Por ejemplo, la referencia cultural actual se puede cambiar mediante programación o a través de la acción del usuario. Cuando esto sucede, el 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 Panel de control. Por ejemplo, los usuarios pueden elegir un símbolo de moneda diferente o un símbolo separador decimal diferente. Si la CultureInfo.UseUserOverride propiedad se establece true en (su valor predeterminado), las propiedades del NumberFormatInfo objeto también se recuperan de la configuración del usuario.

A partir de la .NET Framework 2.0, todas las propiedades reemplazables por el usuario de un NumberFormatInfo objeto se inicializan cuando se crea el objeto. Todavía existe la posibilidad de incoherencia, ya que ni la creación de objetos ni el proceso de invalidación del usuario son atómicas, y los valores pertinentes pueden cambiar durante la creación del objeto. Sin embargo, estas incoherencias deben ser extremadamente raras.

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

Origen del objeto CultureInfo y NumberFormatInfo Refleja las invalidaciones de usuario
PropiedadCultureInfo.CurrentCulture.NumberFormat
PropiedadNumberFormatInfo.CurrentInfo
Método CultureInfo.CreateSpecificCulture
Método CultureInfo.GetCultureInfo No
Constructor CultureInfo(String)
Constructor CultureInfo.CultureInfo(String, Boolean) Depende del valor del useUserOverride parámetro

A menos que haya un motivo atractivo para hacerlo, debe respetar las invalidaciones de usuario al usar el NumberFormatInfo objeto en las aplicaciones cliente para dar formato y analizar la entrada del usuario o para mostrar datos numéricos. En el caso de las aplicaciones de servidor o las aplicaciones desatendidas, no debe respetar las invalidaciones de usuario. Sin embargo, si usa el NumberFormatInfo objeto explícita o implícitamente para conservar datos numéricos en forma de cadena, debe usar un NumberFormatInfo objeto que refleje las convenciones de formato de la referencia cultural invariable, o bien debe especificar una cadena de formato numérico personalizado que use independientemente de la referencia cultural.

IFormatProvider, NumberFormatInfo y formato numérico

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

Todas las operaciones de formato numérico usan una IFormatProvider implementación. La IFormatProvider interfaz incluye un único método, GetFormat(Type). Se trata de un método de devolución de llamada que se pasa a 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 . El .NET Framework proporciona dos IFormatProvider implementaciones para dar formato a los números:

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

En el ejemplo siguiente se muestra la relación entre la IFormatProvider interfaz y la NumberFormatInfo clase en las operaciones de formato mediante la definición de una implementación personalizada IFormatProvider . Su GetFormat método muestra el nombre de tipo del objeto solicitado por la operación de formato. Si la interfaz solicita un NumberFormatInfo objeto , este método proporciona el NumberFormatInfo objeto para la referencia cultural actual. Como se muestra en la salida del ejemplo, el Decimal.ToString(IFormatProvider) método solicita un NumberFormatInfo objeto para proporcionar información de formato, mientras que el String.Format(IFormatProvider, String, Object[]) método solicita NumberFormatInfo y DateTimeFormatInfo objetos, así como una 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
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 una IFormatProvider implementación no se proporciona explícitamente en una llamada a método de formato numérico, el método llama al CultureInfo.CurrentCulture.GetFormat método , que devuelve el NumberFormatInfo objeto que corresponde a la referencia cultural actual.

Formato de cadenas y propiedades NumberFormatInfo

Cada operación de formato usa una cadena de formato numérico estándar o personalizada para generar una cadena de resultado a partir 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 al Decimal.ToString(IFormatProvider) método para convertir un Decimal valor en una serie de representaciones de cadena diferentes mediante 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
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 es implícito. Por ejemplo, en el método siguiente se llama al método predeterminado o sin Decimal.ToString() parámetros, el valor de la Decimal instancia tiene 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
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 una o varias NumberFormatInfo propiedades para determinar el patrón o los símbolos usados en la cadena de resultado. De forma similar, cada especificador de formato numérico personalizado excepto "0" y "#" inserta símbolos en la cadena de resultado definida por NumberFormatInfo las propiedades. En la tabla siguiente se enumeran los especificadores de formato numérico estándar y personalizado y sus propiedades asociadas NumberFormatInfo . Para cambiar la apariencia de la cadena de resultado de una referencia cultural determinada, consulte la sección Modificación de las propiedades NumberFormatInfo . Para obtener más información sobre el uso de estos especificadores de formato, vea Cadenas de formato numérico estándar y Cadenas de 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 separador decimal.

CurrencyGroupSeparator, para definir el separador de grupo o miles.

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

CurrencyNegativePattern, para definir el patrón de valores de moneda negativos.

CurrencyPositivePattern, para definir el patrón de valores de moneda 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ífico) NegativeSign, para definir el símbolo de signo negativo en la mantisa y el exponente.

NumberDecimalSeparator, para definir el símbolo 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 separador decimal.
"G" o "g" (especificador de formato general) NegativeSign, para definir el símbolo de signo negativo.

NumberDecimalSeparator, para definir el símbolo separador decimal.

PositiveSign, para definir el símbolo de signo positivo para las cadenas de resultado en formato exponencial.
"N" o "n" (especificador de formato de número) 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 separador decimal.

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

NumberGroupSizes, para definir el número de dígitos enteros en 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 separador decimal.

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

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

PercentNegativePattern, para definir la ubicación del símbolo de porcentaje y el 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 separador decimal.

PositiveSign, para definir el símbolo de signo positivo en un exponente.
"X" o "x" (especificador de formato hexadecimal) Ninguno.
"." (especificador de formato personalizado de punto decimal) NumberDecimalSeparator, para definir el símbolo separador decimal.
"," (especificador de formato personalizado separador de grupo) NumberGroupSeparator, para definir el símbolo separador de grupo (miles).
"%" (especificador de formato personalizado de marcador de posición de porcentaje) PercentSymbol, para definir el símbolo de porcentaje.
"}" (especificador de formato personalizado de marcador de posición per mille) PerMilleSymbol, para definir el símbolo 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 una NativeDigits propiedad que especifica los 10 dígitos base usados por una referencia cultural específica. Sin embargo, la propiedad no se usa en las operaciones de formato; solo se usan los dígitos latinos básicos 0 (U+0030) a 9 (U+0039) en la cadena de resultado. Además, para Single los valores y Double de NaN, PositiveInfinityy NegativeInfinity, la cadena de resultado consta exclusivamente de los símbolos definidos por las NaNSymbolpropiedades , PositiveInfinitySymboly NegativeInfinitySymbol , respectivamente.

Modificación de las propiedades NumberFormatInfo

Puede modificar las propiedades de un NumberFormatInfo objeto para personalizar la cadena de resultado generada en una operación de formato numérico. Para ello, siga estos pasos:

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

  2. Modifique la propiedad o las propiedades que se usan para generar la cadena de resultado deseada. Para obtener información sobre cómo los métodos de formato usan NumberFormatInfo propiedades para definir cadenas de resultado, vea la sección Cadenas de formato y Propiedades NumberFormatInfo .

  3. Use el objeto personalizado NumberFormatInfo como IFormatProvider argumento en llamadas a métodos de formato.

Nota

En lugar de modificar dinámicamente los valores de propiedad de una referencia cultural cada vez que se inicia una aplicación, puede usar la CultureAndRegionInfoBuilder clase para definir una referencia cultural personalizada (una referencia cultural que tiene un nombre único y que complementa las referencias culturales existentes) o una referencia cultural de reemplazo (una que se usa en lugar de una referencia cultural específica).

En las secciones siguientes se proporcionan algunos ejemplos.

Modificar el símbolo de moneda y el patrón

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 patrón para los valores de moneda que constan 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
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

Aplicar formato a un número de identificación nacional

Muchos números de identificación nacional constan exclusivamente de dígitos, por lo que se puede dar formato fácilmente modificando las propiedades de un NumberFormatInfo objeto. Por ejemplo, un número de seguro social del Estados Unidos consta de 9 dígitos organizados de la siguiente manera: XXX-XX-XXXX. En el ejemplo siguiente se supone que los números de seguridad social se almacenan como valores enteros y los da formato adecuadamente.

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

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

Los métodos de análisis usan implícita o explícitamente un NumberStyles valor de enumeración para determinar qué elementos de estilo (como separadores de grupo, separadores decimales o símbolos de moneda) pueden estar presentes en una cadena si la operación de análisis es correcta. Si no se proporciona un NumberStyles valor en la llamada al método, el valor predeterminado es un NumberStyles valor que incluye las Float marcas y AllowThousands , que especifica que la cadena analizada puede incluir 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.

Los métodos de análisis también usan implícita o explícitamente un NumberFormatInfo objeto que define los símbolos y patrones específicos que se pueden producir en la cadena que se van a analizar. Si no se proporciona un NumberFormatInfo objeto, el valor predeterminado es para NumberFormatInfo la referencia cultural actual. 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).

En el ejemplo siguiente se muestra la naturaleza sensible a la referencia cultural de analizar cadenas. Intenta analizar una cadena que incluya separadores de miles mediante las convenciones de las referencias culturales en-US, fr-FR e invariables. Una cadena que incluye la coma como separador de grupo y el punto como separador decimal no se puede analizar en la referencia cultural fr-FR y una cadena con espacio en blanco como separador de grupo y una coma como separador decimal no se puede analizar en las referencias culturales en-US y invariables.

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)

El análisis generalmente se produce en dos contextos:

  • Como operación diseñada para convertir la entrada del usuario en un valor numérico.

  • Como una operación diseñada para realizar un recorrido de ida y vuelta, un valor numérico; es decir, para deserializar un valor numérico que se serializó previamente como una cadena.

En las secciones siguientes se describen estas dos operaciones con mayor detalle.

Análisis de cadenas de usuario

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

En el ejemplo siguiente se muestra la diferencia entre una operación de análisis que refleja la configuración cultural del usuario y otra que no lo hace. En este caso, la referencia cultural predeterminada del sistema es en-US, pero el usuario ha definido "," como símbolo decimal y "." como separador de grupo en Panel de control, Región e Idioma. Normalmente, estos símbolos se invierten en la referencia cultural predeterminada en-US. Cuando el usuario escribe una cadena que refleja la configuración del usuario y un NumberFormatInfo objeto que también refleja la configuración del usuario (invalidaciones), la operación de análisis devuelve un resultado correcto. Sin embargo, cuando un NumberFormatInfo objeto que refleja la configuración cultural estándar en-US analiza la cadena, se equivoca el símbolo de coma de un separador de grupo y 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
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

Serialización y deserialización de datos numéricos

Cuando los datos numéricos se serializan en formato de cadena y posteriormente se deserializan y analizan, las cadenas se deben generar y analizar mediante las convenciones de la referencia cultural invariable. Las operaciones de formato y análisis nunca deben reflejar las convenciones de una referencia cultural específica. Si se usan configuraciones específicas de la referencia cultural, la portabilidad de los datos es estrictamente limitada; solo se puede deserializar correctamente en un subproceso cuya configuración específica de la referencia cultural sea idéntica a la del subproceso en el que se serializó. En algunos casos, esto significa que los datos ni siquiera se pueden deserializar correctamente en el mismo sistema en el que se serializó.

En el ejemplo siguiente se muestra lo que puede ocurrir cuando se infringe este principio. Los valores de punto flotante de una matriz se convierten en cadenas cuando el subproceso actual usa la configuración específica de la referencia cultural de la referencia cultural en-US. A continuación, los datos se analizan mediante un subproceso que usa la configuración específica de la referencia cultural de la referencia cultural pt-BR. En este caso, aunque cada operación de análisis se realiza correctamente, los datos no realizan un recorrido de ida y vuelta y se producen daños en los datos. En otros casos, se podría producir un error en una operación de análisis y se podría producir una FormatException excepción.

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

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

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

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

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

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

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

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

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

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

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

Constructores

NumberFormatInfo()

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

Propiedades

CurrencyDecimalDigits

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

CurrencyDecimalSeparator

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

CurrencyGroupSeparator

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

CurrencyGroupSizes

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

CurrencyNegativePattern

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

CurrencyPositivePattern

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

CurrencySymbol

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

CurrentInfo

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

DigitSubstitution

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

InvariantInfo

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

IsReadOnly

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

NaNSymbol

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

NativeDigits

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

NegativeInfinitySymbol

Obtiene o establece la cadena que representa un infinito negativo.

NegativeSign

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

NumberDecimalDigits

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

NumberDecimalSeparator

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

NumberGroupSeparator

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

NumberGroupSizes

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

NumberNegativePattern

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

PercentDecimalDigits

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

PercentDecimalSeparator

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

PercentGroupSeparator

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

PercentGroupSizes

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

PercentNegativePattern

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

PercentPositivePattern

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

PercentSymbol

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

PerMilleSymbol

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

PositiveInfinitySymbol

Obtiene o establece la cadena que representa un infinito positivo.

PositiveSign

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

Métodos

Clone()

Crea una copia superficial del objeto NumberFormatInfo.

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
GetFormat(Type)

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

GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetInstance(IFormatProvider)

Obtiene el objeto NumberFormatInfo asociado al IFormatProvider especificado.

GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.

(Heredado de Object)
ReadOnly(NumberFormatInfo)

Devuelve un contenedor de NumberFormatInfo de solo lectura.

ToString()

Devuelve una cadena que representa el objeto actual.

(Heredado de Object)

Se aplica a

Consulte también