NumberFormatInfo Clase

  • Referencia

Definición

Espacio de nombres:
System.Globalization
Ensamblado:
System.Globalization.dll
Ensamblado:
System.Runtime.dll
Ensamblado:
netstandard.dll
Ensamblado:
mscorlib.dll

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
Object
NumberFormatInfo
Atributos
SerializableAttribute ComVisibleAttribute
Implementaciones
IFormatProvider ICloneable

Ejemplos

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

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 objeto que represente las convenciones de formato de la referencia cultural actual, la referencia cultural invariable, una referencia cultural específica o una NumberFormatInfo referencia cultural neutra.

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

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

En el ejemplo siguiente se usan estas 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

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 objeto y se muestra el valor de su propiedad para ilustrar que el objeto NumberFormatInfo no es de solo IsReadOnly 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 utilizados en las operaciones de formato numérico y análisis a través del elemento Región e NumberFormatInfo Idioma de 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 objetos recuperados de las formas que se han NumberFormatInfo analizado anteriormente reflejan estas invalidaciones de usuario. Si no quiere esto, puede crear un objeto que no refleje invalidaciones de usuario (y que también sea de lectura/escritura en lugar de solo lectura) llamando al constructor y suministrando un valor de para el argumento NumberFormatInfo CultureInfo.CultureInfo(String, Boolean) false useUserOverride . 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 en , las propiedades , y también se true CultureInfo.DateTimeFormat CultureInfo.NumberFormat CultureInfo.TextInfo recuperan de la configuración del usuario. Si la configuración del usuario no es compatible con la referencia cultural asociada al objeto (por ejemplo, si el calendario seleccionado no es uno de los calendarios enumerados por la propiedad ), los resultados de los métodos y los valores de las propiedades no están CultureInfo OptionalCalendars definidos.

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

La referencia cultural invariable representa una referencia cultural que no tiene en cuenta 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 las referencia culturales específicas pueden ser dinámicos y pueden cambiar para reflejar nuevas convenciones culturales o preferencias del usuario, los datos de la referencia cultural invariable no cambian. Un objeto que representa las convenciones de formato de la referencia cultural invariable se puede usar para las operaciones de formato en las que las cadenas de resultado no deben NumberFormatInfo variar según la referencia cultural.

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

En el ejemplo siguiente se usa 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 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 determinados. Por ejemplo, en-US es una referencia cultural específica que representa el idioma inglés que se habla en la 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 objeto que represente las convenciones de formato NumberFormatInfo de una referencia cultural específica de las maneras siguientes:

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

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 neutra representa una referencia cultural o un idioma que es independiente de un país o región. Suele ser el elemento primario de una o varias referencia 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 objeto que representa las convenciones de formato de una referencia cultural neutra de la misma manera que se crea un objeto que representa las convenciones de formato de NumberFormatInfo NumberFormatInfo una referencia cultural específica.

Nota

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

Sin embargo, dado que es independiente de un país o región específicos, una referencia cultural neutra carece de información de formato específica de la referencia cultural. En lugar de rellenar el objeto con valores genéricos, el .NET Framework devuelve un objeto que refleja las convenciones de formato de una referencia cultural específica que es un elemento secundario de la referencia NumberFormatInfo NumberFormatInfo cultural neutra. Por ejemplo, el objeto de la referencia cultural neutral en refleja las convenciones de formato de la referencia cultural en-US y el objeto de la referencia cultural fr refleja las convenciones de formato de la referencia cultural NumberFormatInfo NumberFormatInfo 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 clase son dinámicos, al igual que los NumberFormatInfo datos culturales proporcionados por la CultureInfo clase . No debe realizar ninguna suposición sobre la estabilidad de los valores de los NumberFormatInfo objetos asociados a objetos CultureInfo determinados. Solo los datos proporcionados por la referencia cultural invariable y su objeto NumberFormatInfo asociado 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 NumberFormatInfo de propiedad de una referencia cultural determinada.

  • Referencia cultural 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 que NumberFormatInfo 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 propiedad cambia a un objeto asociado a la referencia cultural CurrentInfo actual.

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

A partir de .NET Framework 2.0, todas las propiedades reemplazables por el usuario de un objeto se NumberFormatInfo 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 de usuario son atómicos y los valores pertinentes pueden cambiar durante la creación del objeto. Sin embargo, estas incoherencias deben ser muy poco frecuentes.

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 objeto e indica si el objeto resultante NumberFormatInfo refleja las invalidaciones de usuario.

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

A menos que haya una razón atractiva para hacer lo contrario, debe respetar las invalidaciones de usuario cuando use el objeto en las aplicaciones cliente para dar formato y analizar la entrada del usuario o para mostrar NumberFormatInfo datos numéricos. En el caso de las aplicaciones de servidor o desatendidas, no debe respetar las invalidaciones de usuario. Sin embargo, si usa el objeto de forma explícita o implícita para conservar los datos numéricos en forma de cadena, debe usar un 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 NumberFormatInfo NumberFormatInfo 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 al que se pasa Type un 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 , si null 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 implementación a un método de formato explícitamente, se usa un objeto devuelto por la propiedad que representa IFormatProvider CultureInfo la referencia cultural CultureInfo.CurrentCulture actual.

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

Cadenas de formato 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 método para convertir un valor en una serie de representaciones de cadena diferentes mediante las convenciones de formato de la referencia Decimal.ToString(IFormatProvider) Decimal 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 siguiente método llama al método predeterminado o sin parámetros, el valor de la instancia se formatee mediante el especificador de formato general ("G") y las convenciones de la referencia cultural actual, que en este caso es la referencia cultural Decimal.ToString() Decimal 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 utilizados 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 resultados definidos por NumberFormatInfo propiedades. En la tabla siguiente se enumeran los especificadores de formato numérico estándar y personalizado y sus propiedades NumberFormatInfo asociadas. Para cambiar la apariencia de la cadena de resultados de una referencia cultural determinada, vea la sección Modificar 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 grupos 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 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 separador decimal.

PercentGroupSeparator, para definir el símbolo 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 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 separador decimal) NumberDecimalSeparator, para definir el símbolo separador decimal.
"," (especificador de formato personalizado de 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.
""," (por especificador de formato personalizado de marcador de posición de marcador de posición) PerMilleSymbol, para definir el símbolo por cada uno.
"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 NumberFormatInfo que la clase incluye una propiedad que especifica los NativeDigits dígitos de base 10 usados por una referencia cultural específica. Sin embargo, la propiedad no se usa en 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 los valores y de , y , la cadena de resultado consta exclusivamente de los símbolos definidos por las propiedades Single Double , y , NaN PositiveInfinity NegativeInfinity NaNSymbol PositiveInfinitySymbol NegativeInfinitySymbol respectivamente.

Modificar propiedades NumberFormatInfo

Puede modificar las propiedades de un objeto para personalizar la cadena de NumberFormatInfo resultados producida 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, vea 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 propiedades para definir cadenas de resultados, vea la sección Formato de cadenas y NumberFormatInfo propiedades NumberFormatInfo.

  3. Use el objeto NumberFormatInfo personalizado como argumento en las llamadas a IFormatProvider 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 clase para definir una referencia cultural personalizada (una referencia cultural que tenga un nombre único y que complemente las existentes) o una referencia cultural de reemplazo (una que se use en lugar de una referencia cultural CultureAndRegionInfoBuilder específica).

En las secciones siguientes se proporcionan algunos ejemplos.

Modificación del símbolo y el patrón de moneda

En el ejemplo siguiente se modifica un objeto que representa las convenciones de formato NumberFormatInfo de la referencia cultural en-US. Asigna el símbolo de moneda ISO-4217 a la propiedad y define un patrón para los valores de moneda que consta del símbolo de moneda seguido de un espacio y un CurrencySymbol 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

Formato de un número de identificación nacional

Muchos números de identificación nacionales 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 la seguridad social de la Estados Unidos consta de 9 dígitos organizados de la siguiente manera: XXX-XX-XXXX . En el ejemplo siguiente se da por supuesto que los números de la seguridad social se almacenan como valores enteros y los formatea correctamente.

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 método convierte una cadena en un número, asigna el número a un argumento y devuelve un valor que indica si la conversión se ha hecho TryParse out Boolean correctamente.

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

Los métodos de análisis también usan implícita o explícitamente un objeto que define los símbolos y patrones específicos que pueden producirse en la cadena que se NumberFormatInfo va a analizar. Si no NumberFormatInfo se proporciona un objeto , el valor predeterminado es para la referencia cultural NumberFormatInfo actual. Para obtener más información sobre el análisis, vea los métodos de análisis individuales, como Int16.Parse(String) , , , , y Int32.Parse(String, NumberStyles) Int64.Parse(String, IFormatProvider) Decimal.Parse(String, NumberStyles, IFormatProvider) Double.TryParse(String, Double) BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger) .

En el ejemplo siguiente se muestra la naturaleza que tiene en cuenta la referencia cultural del análisis de cadenas. Intenta analizar una cadena que incluye separadores de miles mediante las convenciones de las referencia culturales en-US, fr-FR y 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 referencia culturales en-US y las referencia culturales 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 suele producirse en dos contextos:

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

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

En las secciones siguientes se de abordan estas dos operaciones con más detalle.

Análisis de cadenas de usuario

Al analizar la entrada de cadenas numéricas por parte del usuario, siempre debe crear una instancia de un objeto que refleje la configuración NumberFormatInfo cultural del usuario. Para obtener información sobre cómo crear instancias de un objeto que refleje las personalizaciones del usuario, vea la sección NumberFormatInfo 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. 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 en-US predeterminada. Cuando el usuario escribe una cadena que refleja la configuración del usuario y la cadena se analiza mediante un objeto que también refleja la configuración del usuario (invalidaciones), la operación de análisis devuelve un resultado NumberFormatInfo correcto. Sin embargo, cuando un objeto analiza la cadena que refleja la configuración cultural en-US estándar, comete un error en el símbolo de coma para un separador de grupo y devuelve un resultado NumberFormatInfo 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 deserializar 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 usa una configuración específica 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 serializa. En algunos casos, esto significa que los datos no se pueden deserializar correctamente en el mismo sistema en el que se serializaron.

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 en-US. A continuación, los datos se analizan mediante un subproceso que usa la configuración específica de la referencia cultural de pt-BR. En este caso, aunque cada operación de análisis se realiza correctamente, los datos no se completan correctamente 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 FormatException se podría producir una 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