Cadenas con formato numérico estándar

 

Las cadenas de formato numérico estándar se utilizan para dar formato a tipos numéricos comunes. La forma de una cadena de formato numérico estándar es Axx, donde:

  • A es un carácter alfabético único denominado especificador de formato. Cualquier cadena de formato numérico que contenga más de un carácter alfabético, incluido el espacio en blanco, se interpreta como una cadena de formato numérico personalizado. Para obtener más información, consulta Cadenas con formato numérico personalizado.

  • xx es un entero opcional denominado especificador de precisión. El especificador de precisión está comprendido entre el 0 y el 99 y afecta al número de dígitos del resultado. Observe que el especificador de precisión controla el número de dígitos en la representación de cadena de un número. No redondea el número en sí. Para realizar una operación de redondeo, use el método Math.Ceiling, Math.Floor o Math.Round.

    Cuando el especificador de precisión controla el número de dígitos fraccionarios en la cadena de resultado, las cadenas de resultado reflejan números que se redondean alejándose de cero (es decir, usando MidpointRounding.AwayFromZero).

Algunas sobrecargas del método ToString de todos los tipos numéricos admiten las cadenas de formato numérico estándar. Por ejemplo, se puede proporcionar una cadena de formato numérico a los métodos ToString(String) y ToString(String, IFormatProvider) del tipo Int32. La característica de formato compuesto de .NET Framework, que utilizan algunos métodos Write y WriteLine de las clases Console y StreamWriter, el método String.Format y el método StringBuilder.AppendFormat, admite también cadenas de formato numérico estándar. La característica de formato compuesto permite incluir la representación de varios elementos de datos en una sola cadena a fin de especificar el ancho de campo y alinear números en un campo. Para obtener más información, consulta Formatos compuestos.

System_CAPS_ICON_tip.jpg Sugerencia

Puede descargar la Utilidad de formato, que es una aplicación que permite aplicar cadenas de formato a valores numéricos o de fecha y hora, y que muestra la cadena de resultado.

En la tabla siguiente se describen los especificadores de formato numérico estándar y se muestran los resultados de ejemplo generados por cada especificador de formato. Vea la sección Notas para obtener información adicional sobre cómo usar las cadenas de formato numérico estándar y la sección Ejemplo para ver una ilustración completa de su uso.

Especificador de formatoNameDescripciónEjemplos
"C" o "c"MonedaResultado: un valor de divisa.

Compatible con: todos los tipos numéricos.

Especificador de precisión: número de dígitos decimales.

Especificador de precisión predeterminado: definido por NumberFormatInfo.CurrencyDecimalDigits.

Más información: Especificador de formato de divisa ("C").
123.456 ("C", en-US) -> $123.46

123.456 ("C", fr-FR) -> 123,46 €

123.456 ("C", ja-JP) -> ¥123

-123.456 ("C3", en-US) -> ($123.456)

-123.456 ("C3", fr-FR) -> -123,456 €

-123.456 ("C3", ja-JP) -> -¥123.456
"D" o "d"DecimalResultado: dígitos enteros con signo negativo opcional.

Compatible con: solo tipos enteros.

Especificador de precisión: número mínimo de dígitos.

Especificador de precisión predeterminado: número mínimo de dígitos necesarios.

Más información: Especificador de formato decimal ("D").
1234 ("D") -> 1234

-1234 ("D6") -> -001234
"E" o "e"Exponencial (científico)Resultado: notación exponencial.

Compatible con: todos los tipos numéricos.

Especificador de precisión: número de dígitos decimales.

Especificador de precisión predeterminado: 6.

Más información: Especificador de formato exponencial ("E").
1052.0329112756 ("E", en-US) -> 1.052033E+003

1052.0329112756 ("e", fr-FR) -> 1,052033e+003

-1052.0329112756 ("e2", en-US) -> -1.05e+003

-1052.0329112756 ("E2", fr_FR) -> -1,05E+003
"F" o "f"Punto fijoResultado: dígitos integrales y decimales con signo negativo opcional.

Compatible con: todos los tipos numéricos.

Especificador de precisión: número de dígitos decimales.

Especificador de precisión predeterminado: definido por NumberFormatInfo.NumberDecimalDigits.

Más información: Especificador de formato de punto fijo ("F").
1234.567 ("F", en-US) -> 1234.57

1234.567 ("F", de-DE) -> 1234,57

1234 ("F1", en-US) -> 1234.0

1234 ("F1", de-DE) -> 1234,0

-1234.56 ("F4", en-US) -> -1234.5600

-1234.56 ("F4", de-DE) -> -1234,5600
"G" o "g"GeneralResultado: notación de punto fijo o científica, la que sea más compacta.

Compatible con: todos los tipos numéricos.

Especificador de precisión: número de dígitos significativos.

Especificador de precisión predeterminado: depende del tipo numérico.

Más información: Especificador de formato general ("G").
-123.456 ("G", en-US) -> -123.456

-123.456 ("G", sv-SE) -> -123,456

123.4546 ("G4", en-US) -> 123.5

123.4546 ("G4", sv-SE) -> 123,5

-1.234567890e-25 ("G", en-US) -> -1.23456789E-25

-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25
"N" o "n"NúmeroResultado: dígitos integrales y decimales, separadores de grupos y un separador decimal con signo negativo opcional.

Compatible con: todos los tipos numéricos.

Especificador de precisión: número deseado de decimales.

Especificador de precisión predeterminado: definido por NumberFormatInfo.NumberDecimalDigits.

Más información: Especificador de formato numérico ("N").
1234.567 ("N", en-US) -> 1,234.57

1234.567 ("N", ru-RU) -> 1 234,57

1234 ("N1", en-US) -> 1,234.0

1234 ("N1", ru-RU) -> 1 234,0

-1234.56 ("N3", en-US) -> -1,234.560

-1234.56 ("N3", ru-RU) -> -1 234,560
"P" o "p"PorcentajeResultado: número multiplicado por 100 y mostrado con un símbolo de porcentaje.

Compatible con: todos los tipos numéricos.

Especificador de precisión: número deseado de decimales.

Especificador de precisión predeterminado: definido por NumberFormatInfo.PercentDecimalDigits.

Más información: Especificador de formato de porcentaje ("P").
1 ("P", en-US) -> 100.00 %

1 ("P", fr-FR) -> 100,00 %

-0.39678 ("P1", en-US) -> -39.7 %

-0.39678 ("P1", fr-FR) -> -39,7 %
"R" o "r"Acción de ida y vueltaResultado: cadena que puede aplicar acciones de ida y vuelta (round-trip) a un número idéntico.

Compatible con: Single, Double y BigInteger.

Especificador de precisión: se omite.

Más información: Especificador de formato de operación de ida y vuelta ("R").
123456789.12345678 ("R") -> 123456789.12345678

-1234567890.12345678 ("R") -> -1234567890.1234567
"X" o "x"HexadecimalResultado: cadena hexadecimal.

Compatible con: solo tipos enteros.

Especificador de precisión: número de dígitos en la cadena de resultado.

Más información: Especificador de formato hexadecimal ("X").
255 ("X") -> FF

-1 ("x") -> ff

255 ("x4") -> 00ff

-1 ("X4") -> 00FF
Cualquier otro carácter únicoEspecificador desconocidoResultado: Produce FormatException en tiempo de ejecución.

Una cadena de formato numérico estándar se puede usar para definir el formato de un valor numérico de una de dos maneras:

  • Se puede pasar a una sobrecarga del método ToString que tiene un parámetro format. En el ejemplo siguiente se da formato a un valor numérico como una cadena de divisa en la referencia cultural actual (en este caso, en-US).

          decimal value = 123.456m;
          Console.WriteLine(value.ToString("C2"));
          // Displays $123.46
    

  • Se puede proporcionar como el argumento formatString de un elemento de formato usado con métodos como String.Format, Console.WriteLine y StringBuilder.AppendFormat. Para obtener más información, consulta Formatos compuestos. En el ejemplo siguiente se usa un elemento de formato para insertar un valor de divisa en una cadena.

          decimal value = 123.456m;
          Console.WriteLine("Your account balance is {0:C2}.", value);
          // Displays "Your account balance is $123.46."
    

    Opcionalmente, puede facilitar un argumento alignment para especificar el ancho del campo numérico y si su valor está alineado a izquierda o derecha. En el ejemplo siguiente se alinea a la izquierda un valor de moneda en un campo de 28 caracteres y se alinea a la derecha un valor de moneda en un campo de 14 caracteres.

          decimal[] amounts = { 16305.32m, 18794.16m };
          Console.WriteLine("   Beginning Balance           Ending Balance");
          Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
          // Displays:
          //        Beginning Balance           Ending Balance
          //        $16,305.32                      $18,794.16      
    

En las secciones siguientes se proporciona información detallada sobre cada una de las cadenas de formato numérico estándar.

El especificador de formato "C" (divisa) convierte un número en una cadena que representa una cantidad de divisa. El especificador de precisión indica el número deseado de posiciones decimales en la cadena de resultado. Si se omite el especificador de precisión, la precisión predeterminada está definida por la propiedad NumberFormatInfo.CurrencyDecimalDigits.

Si el valor al que se va a dar formato tiene más posiciones decimales que el número especificado o predeterminado, el valor fraccionario se redondea en la cadena de resultado. Si el valor situado a la derecha del número de posiciones decimales especificadas es 5 o superior, el último dígito de la cadena de resultado se redondea desde cero.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado. En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena devuelta.

Propiedad de NumberFormatInfoDescripción
CurrencyPositivePatternDefine la posición del símbolo de divisa para los valores positivos.
CurrencyNegativePatternDefine la posición del símbolo de divisa para los valores negativos y especifica si el signo negativo está representado por paréntesis o por la propiedad NegativeSign.
NegativeSignDefine el signo negativo usado si CurrencyNegativePattern indica que no se emplean paréntesis.
CurrencySymbolDefine el símbolo de divisa.
CurrencyDecimalDigitsDefine el número predeterminado de dígitos decimales en un valor de divisa. Este valor puede reemplazarse por el uso del especificador de precisión.
CurrencyDecimalSeparatorDefine la cadena que separa los dígitos integrales y decimales.
CurrencyGroupSeparatorDefine la cadena que separa los grupos de números integrales.
CurrencyGroupSizesDefine el número de dígitos enteros que aparecen en un grupo.

En el ejemplo siguiente se da formato a un valor Double con el especificador de formato de divisa.

      double value = 12345.6789;
      Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));

      Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));

      Console.WriteLine(value.ToString("C3", 
                        CultureInfo.CreateSpecificCulture("da-DK")));
      // The example displays the following output on a system whose
      // current culture is English (United States):
      //       $12,345.68
      //       $12,345.679
      //       kr 12.345,679

Volver a la tabla

El especificador de formato "D" (o decimal) convierte un número en una cadena de dígitos decimales (0-9), precedida por un signo menos si el número es negativo. Este formato sólo es compatible con los tipos enteros.

El especificador de precisión indica el número mínimo de dígitos deseado en la cadena resultante. Si es preciso, el número se rellena con ceros a la izquierda para generar el número de dígitos que aporta el especificador de precisión. Si no se indica ningún especificador de precisión, el valor predeterminado es el valor mínimo necesario para representar el entero sin ceros iniciales.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado. Como se muestra en la tabla siguiente, una única propiedad afecta al formato de la cadena de resultado.

Propiedad de NumberFormatInfoDescripción
NegativeSignDefine la cadena que indica que un número es negativo.

En el ejemplo siguiente se da formato a un valor Int32 con el especificador de formato decimal.

      int value; 
      
      value = 12345;
      Console.WriteLine(value.ToString("D"));
      // Displays 12345
      Console.WriteLine(value.ToString("D8"));
      // Displays 00012345

      value = -12345;
      Console.WriteLine(value.ToString("D"));
      // Displays -12345
      Console.WriteLine(value.ToString("D8"));
      // Displays -00012345

Volver a la tabla

El especificador de formato exponencial ("E") convierte un número en una cadena con el formato "-d.ddd…E+ddd" o "-d.ddd…e+ddd", donde cada "d" indica un dígito (0-9). La cadena comienza con un signo menos si el número es negativo. El separador decimal siempre va precedido por exactamente un dígito.

El especificador de precisión indica el número deseado de dígitos después del separador decimal. Si se omite el especificador de precisión, se emplea uno predeterminado que tiene seis dígitos después del separador decimal.

El modelo de mayúsculas o minúsculas del especificador de formato indica si se debe prefijar el exponente con una "E" o con una "e". El exponente siempre consta de un signo más o menos y de un mínimo de tres dígitos. El exponente se rellena con ceros para adaptarlo a este mínimo, si es necesario.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado. En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena devuelta.

Propiedad de NumberFormatInfoDescripción
NegativeSignDefine la cadena que indica que un número es negativo tanto para el coeficiente como para el exponente.
NumberDecimalSeparatorDefine la cadena que separa el dígito integral de los dígitos decimales en el coeficiente.
PositiveSignDefine la cadena que indica que un exponente es positivo.

En el ejemplo siguiente se da formato a un valor Double con el especificador de formato exponencial.

      double value = 12345.6789;
      Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
      // Displays 1.234568E+004
      
      Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
      // Displays 1.2345678900E+004
      
      Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
      // Displays 1.2346e+004
      
      Console.WriteLine(value.ToString("E", 
                        CultureInfo.CreateSpecificCulture("fr-FR")));
      // Displays 1,234568E+004

Volver a la tabla

El especificador de formato de punto fijo ("F) convierte un número en una cadena con el formato "-ddd.ddd…" donde cada "d" indica un dígito (0-9). La cadena comienza con un signo menos si el número es negativo.

El especificador de precisión indica el número deseado de cifras decimales. Si se omite el especificador de precisión, la propiedad NumberFormatInfo.NumberDecimalDigits actual proporciona la precisión numérica.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado. En la tabla siguiente se enumeran las propiedades del objeto NumberFormatInfo que controlan el formato de la cadena de resultado.

Propiedad de NumberFormatInfoDescripción
NegativeSignDefine la cadena que indica que un número es negativo.
NumberDecimalSeparatorDefine la cadena que separa los dígitos integrales de los decimales.
NumberDecimalDigitsDefine el número predeterminado de dígitos decimales. Este valor puede reemplazarse por el uso del especificador de precisión.

En el ejemplo siguiente se da formato a un valor Double e Int32 con el especificador de formato de punto fijo.

      int integerNumber;
      integerNumber = 17843;
      Console.WriteLine(integerNumber.ToString("F", 
                        CultureInfo.InvariantCulture));
      // Displays 17843.00
      
      integerNumber = -29541;
      Console.WriteLine(integerNumber.ToString("F3", 
                        CultureInfo.InvariantCulture));
      // Displays -29541.000
      
      double doubleNumber;
      doubleNumber = 18934.1879;
      Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
      // Displays 18934.19
      
      Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
      // Displays 18934
      
      doubleNumber = -1898300.1987;
      Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));  
      // Displays -1898300.2

      Console.WriteLine(doubleNumber.ToString("F3", 
                        CultureInfo.CreateSpecificCulture("es-ES")));
      // Displays -1898300,199                        

Volver a la tabla

El especificador de formato general ("G") convierte un número a la notación de punto fijo o científica más compacta, dependiendo del tipo del número y de si hay un especificador de precisión o no. El especificador de precisión define el número máximo de dígitos significativos que pueden aparecer en la cadena de resultado. Si el especificador de precisión se omite o es cero, el tipo del número determina la precisión predeterminada, como se indica en la tabla siguiente.

Tipo numéricoPrecisión predeterminada
Byte o SByte3 dígitos
Int16 o UInt165 dígitos
Int32 o UInt3210 dígitos
Int6419 dígitos
UInt6420 dígitos
BigInteger50 dígitos
Single7 dígitos
Double15 dígitos
Decimal29 dígitos

La notación de punto fijo se utiliza si el exponente que resultaría de la expresión del número en notación científica es mayor que -5 y menor que el especificador de precisión, de lo contrario se utiliza la notación científica. El resultado contiene un separador decimal si es necesario y se omiten los ceros finales después de ese separador. Si el especificador de precisión está presente y el número de dígitos significativos del resultado supera la precisión especificada, los dígitos finales sobrantes se quitan mediante redondeo.

Sin embargo, si el número es Decimal y se omite el especificador de precisión, siempre se usa la notación de punto fijo y se conservan los ceros finales.

Si se usa la notación científica, el exponente del resultado lleva el prefijo "E" si el especificador de formato es "G", o "e" si el especificador de formato es "g". El exponente contiene un mínimo de dos dígitos. Esto difiere del formato para la notación científica que genera el especificador de formato exponencial, que incluye un mínimo de tres dígitos en el exponente.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado. En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena de resultado.

Propiedad de NumberFormatInfoDescripción
NegativeSignDefine la cadena que indica que un número es negativo.
NumberDecimalSeparatorDefine la cadena que separa los dígitos integrales de los decimales.
PositiveSignDefine la cadena que indica que un exponente es positivo.

En el ejemplo siguiente se da formato a valores de punto flotante ordenados con el especificador de formato general.

      double number;
      
      number = 12345.6789;      
      Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
      // Displays  12345.6789
      Console.WriteLine(number.ToString("G", 
                        CultureInfo.CreateSpecificCulture("fr-FR")));
      // Displays 12345,6789
                              
      Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
      // Displays 12345.68 
      
      number = .0000023;
      Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
      // Displays 2.3E-06       
      Console.WriteLine(number.ToString("G", 
                        CultureInfo.CreateSpecificCulture("fr-FR")));
      // Displays 2,3E-06
      
      number = .0023;
      Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
      // Displays 0.0023

      number = 1234;
      Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));
      // Displays 1.2E+03

      number = Math.PI;
      Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));
      // Displays 3.1416    

Volver a la tabla

El especificador de formato numérico ("N") convierte un número en una cadena con el formato "-d,ddd,ddd.ddd…", donde "-" indica el símbolo de número negativo, si es necesario; "d", representa cada dígito (0-9); "," es el separador de grupo; y "." es el símbolo de punto decimal. El especificador de precisión indica el número deseado de dígitos después del separador decimal. Si se omite el especificador de precisión, el número de posiciones decimales está definido por la propiedad NumberFormatInfo.NumberDecimalDigits actual.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado. En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena de resultado.

Propiedad de NumberFormatInfoDescripción
NegativeSignDefine la cadena que indica que un número es negativo.
NumberNegativePatternDefine el formato de los valores negativos y especifica si el signo negativo se representa mediante paréntesis o por la propiedad NegativeSign.
NumberGroupSizesDefine el número de dígitos enteros que aparecen entre los separadores de grupos.
NumberGroupSeparatorDefine la cadena que separa los grupos de números integrales.
NumberDecimalSeparatorDefine la cadena que separa los dígitos integrales y decimales.
NumberDecimalDigitsDefine el número predeterminado de dígitos decimales. Este valor puede reemplazarse por el uso de un especificador de precisión.

En el ejemplo siguiente se da formato a valores de punto flotante ordenados con el especificador de formato numérico.

      double dblValue = -12445.6789;
      Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
      // Displays -12,445.68
      Console.WriteLine(dblValue.ToString("N1", 
                        CultureInfo.CreateSpecificCulture("sv-SE")));
      // Displays -12 445,7
      
      int intValue = 123456789;
      Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
      // Displays 123,456,789.0 

Volver a la tabla

El especificador de formato de porcentaje ("P") multiplica un número por 100 y lo convierte en una cadena que representa un porcentaje. El especificador de precisión indica el número deseado de cifras decimales. Si se omite el especificador de precisión, se usará la precisión numérica predeterminada proporcionada por la propiedad PercentDecimalDigits actual.

En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena devuelta.

Propiedad de NumberFormatInfoDescripción
PercentPositivePatternDefine la posición del símbolo de porcentaje para los valores positivos.
PercentNegativePatternDefine la posición del símbolo de porcentaje y del símbolo negativo para los valores negativos.
NegativeSignDefine la cadena que indica que un número es negativo.
PercentSymbolDefine el símbolo de porcentaje.
PercentDecimalDigitsDefine el número predeterminado de dígitos decimales en un valor de porcentaje. Este valor puede reemplazarse por el uso del especificador de precisión.
PercentDecimalSeparatorDefine la cadena que separa los dígitos integrales y decimales.
PercentGroupSeparatorDefine la cadena que separa los grupos de números integrales.
PercentGroupSizesDefine el número de dígitos enteros que aparecen en un grupo.

En el ejemplo siguiente se da formato a valores de punto flotante con el especificador de formato de porcentaje.

      double number = .2468013;
      Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
      // Displays 24.68 %
      Console.WriteLine(number.ToString("P", 
                        CultureInfo.CreateSpecificCulture("hr-HR")));
      // Displays 24,68%     
      Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
      // Displays 24.7 %

Volver a la tabla

El especificador de formato de operación de ida y vuelta ("R") se usa para garantizar que un valor numérico que se convierte en una cadena volverá a tomar el mismo valor numérico. Este formato solo es compatible para los tipos Single, Double y BigInteger.

Cuando se da formato a un valor BigInteger mediante este especificador, su representación de cadena contiene todos los dígitos significativos del valor BigInteger. Cuando se da formato a un valor Single o Double mediante este especificador, primero se comprueba empleando el formato general, con 15 dígitos de precisión para un tipo Double y 7 dígitos de precisión para un tipo Single. Si el valor recupera correctamente el mismo valor numérico al analizarse, se le aplica formato mediante el especificador de formato general. Si el valor no recupera correctamente el mismo valor numérico, se le da formato usando 17 dígitos de precisión para un tipo Double y 9 para un tipo Single.

Aunque puede incluir un especificador de precisión, se omite. Los especificadores de ida y vuelta tienen prioridad sobre la precisión al utilizar este especificador.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado. En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena de resultado.

Propiedad de NumberFormatInfoDescripción
NegativeSignDefine la cadena que indica que un número es negativo.
NumberDecimalSeparatorDefine la cadena que separa los dígitos integrales de los decimales.
PositiveSignDefine la cadena que indica que un exponente es positivo.

En el ejemplo siguiente se da formato a valores Double con el especificador de formato de ida y vuelta.

      double value;
      
      value = Math.PI;
      Console.WriteLine(value.ToString("r"));
      // Displays 3.1415926535897931
      Console.WriteLine(value.ToString("r", 
                        CultureInfo.CreateSpecificCulture("fr-FR")));
      // Displays 3,1415926535897931
      value = 1.623e-21;
      Console.WriteLine(value.ToString("r"));
      // Displays 1.623E-21

System_CAPS_ICON_important.jpg Importante

En algunos casos, los valores Double con el formato de cadena numérica estándar "R" no realizan correctamente la operación de ida y vuelta si se compilan usando los modificadores /platform:x64 o /platform:anycpu y se ejecutan en sistemas de 64 bits. Para más información, consulte el siguiente párrafo.

Para solucionar el problema de los valores Double con formato de cadena numérico estándar “R” que no hacen correctamente el viaje de ida y vuelta si se compilan con conmutadores /platform:x64 o /platform:anycpu y se ejecutan en sistemas de 64 bits, puede dar formato a los valores Double usando la cadena de formato numérico estándar “G17”. En el ejemplo siguiente se usa la cadena de formato "R" con un valor Double que no realiza correctamente la operación de ida y vuelta, y usa también la cadena de formato "G17" para realizar correctamente la operación de ida y vuelta del valor original.

using System;
using System.Globalization;

public class Example
{
   static void Main(string[] args)
   {
      Console.WriteLine("Attempting to round-trip a Double with 'R':");
      double initialValue = 0.6822871999174;
      string valueString = initialValue.ToString("R",
                                                 CultureInfo.InvariantCulture);
      double roundTripped = double.Parse(valueString,
                                         CultureInfo.InvariantCulture);
      Console.WriteLine("{0:R} = {1:R}: {2}\n",
                        initialValue, roundTripped, initialValue.Equals(roundTripped));

      Console.WriteLine("Attempting to round-trip a Double with 'G17':");
      string valueString17 = initialValue.ToString("G17",
                                                   CultureInfo.InvariantCulture);
      double roundTripped17 = double.Parse(valueString17,
                                           CultureInfo.InvariantCulture);
      Console.WriteLine("{0:R} = {1:R}: {2}\n",
                        initialValue, roundTripped17, initialValue.Equals(roundTripped17));
   }
}
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       0.6822871999174 = 0.68228719991740006: False
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True

Volver a la tabla

El especificador de formato hexadecimal ("X") convierte un número en una cadena de dígitos hexadecimales. El modelo de mayúsculas y minúsculas del especificador de formato indica si se van a usar caracteres en mayúsculas o en minúsculas para los dígitos hexadecimales mayores de 9. Por ejemplo, use "X" para generar "ABCDEF" y "x" para generar "abcdef". Este formato sólo es compatible con los tipos enteros.

El especificador de precisión indica el número mínimo de dígitos deseado en la cadena resultante. Si es preciso, el número se rellena con ceros a la izquierda para generar el número de dígitos que aporta el especificador de precisión.

La información de formato del objeto NumberFormatInfo actual no afecta a la cadena de resultado.

En el ejemplo siguiente se da formato a valores Int32 con el especificador de formato hexadecimal.

      int value; 
      
      value = 0x2045e;
      Console.WriteLine(value.ToString("x"));
      // Displays 2045e
      Console.WriteLine(value.ToString("X"));
      // Displays 2045E
      Console.WriteLine(value.ToString("X8"));
      // Displays 0002045E
      
      value = 123456789;
      Console.WriteLine(value.ToString("X"));
      // Displays 75BCD15
      Console.WriteLine(value.ToString("X2"));
      // Displays 75BCD15

Volver a la tabla

Configuración del Panel de control

Los valores de configuración del elemento Configuración regional y de idioma del Panel de control influyen en la cadena de resultado generada por una operación de formato. Esas configuraciones se usan para inicializar el objeto NumberFormatInfo asociado a la referencia cultural del subproceso actual, que proporciona valores que se usan para controlar el formato. Los equipos que usan configuraciones diferentes generarán cadenas de resultado distintas.

Asimismo, si se utiliza el constructor CultureInfo.CultureInfo(String) para crear instancias de un nuevo objeto CultureInfo que representa la misma referencia cultural que la referencia cultural del sistema actual, cualquier personalización establecida por el elemento Configuración regional y de idioma del Panel de control se aplicará al nuevo objeto CultureInfo. Puede usar el constructor CultureInfo.CultureInfo(String, Boolean) para crear un objeto CultureInfo que no refleje las personalizaciones de un sistema.

Propiedades NumberFormatInfo

El formato se ve influenciado por las propiedades del objeto NumberFormatInfo actual, proporcionado implícitamente por la referencia cultural del subproceso actual o explícitamente por el parámetro IFormatProvider del método que invoca el formato. Especifique un objeto NumberFormatInfo o CultureInfo para dicho parámetro.

System_CAPS_ICON_note.jpg Nota

Para obtener información sobre la personalización de patrones o cadenas que se usan para dar formato a valores numéricos, vea el tema de la clase NumberFormatInfo.

Tipos numéricos enteros y de punto flotante

Algunas descripciones de especificadores de formato numérico estándar hacen referencia a tipos numéricos enteros o de punto flotante. Los tipos numéricos integrales son Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64 y BigInteger. Los tipos numéricos de punto flotante son Decimal, Single y Double.

Infinitos de punto flotante y NaN

Independientemente de la cadena de formato, si el valor de un tipo de punto flotante Single o Double es infinito positivo, infinito negativo o NaN (Not a Number, no es un número), la cadena con formato será el valor de la propiedad PositiveInfinitySymbol, NegativeInfinitySymbol o NaNSymbol respectiva especificada por el objeto NumberFormatInfo aplicable actualmente.

En el ejemplo siguiente se da formato a un valor numérico integral y de punto flotante mediante la referencia cultural en-US y todos los especificadores de formato numérico estándar. En este ejemplo se usan dos tipos numéricos concretos (Double y Int32), pero se obtendrían resultados similares con cualquiera de los demás tipos base numéricos (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal y Single).

using System;
using System.Globalization;
using System.Threading;

public class NumericFormats
{
   public static void Main()
   {
      // Display string representations of numbers for en-us culture
      CultureInfo ci = new CultureInfo("en-us");
      
      // Output floating point values
      double floating = 10761.937554;
      Console.WriteLine("C: {0}", 
              floating.ToString("C", ci));           // Displays "C: $10,761.94"
      Console.WriteLine("E: {0}", 
              floating.ToString("E03", ci));         // Displays "E: 1.076E+004"
      Console.WriteLine("F: {0}", 
              floating.ToString("F04", ci));         // Displays "F: 10761.9376"         
      Console.WriteLine("G: {0}",  
              floating.ToString("G", ci));           // Displays "G: 10761.937554"
      Console.WriteLine("N: {0}", 
              floating.ToString("N03", ci));         // Displays "N: 10,761.938"
      Console.WriteLine("P: {0}", 
              (floating/10000).ToString("P02", ci)); // Displays "P: 107.62 %"
      Console.WriteLine("R: {0}", 
              floating.ToString("R", ci));           // Displays "R: 10761.937554"            
      Console.WriteLine();
      
      // Output integral values
      int integral = 8395;
      Console.WriteLine("C: {0}", 
              integral.ToString("C", ci));           // Displays "C: $8,395.00"
      Console.WriteLine("D: {0}", 
              integral.ToString("D6", ci));          // Displays "D: 008395" 
      Console.WriteLine("E: {0}", 
              integral.ToString("E03", ci));         // Displays "E: 8.395E+003"
      Console.WriteLine("F: {0}", 
              integral.ToString("F01", ci));         // Displays "F: 8395.0"    
      Console.WriteLine("G: {0}",  
              integral.ToString("G", ci));           // Displays "G: 8395"
      Console.WriteLine("N: {0}", 
              integral.ToString("N01", ci));         // Displays "N: 8,395.0"
      Console.WriteLine("P: {0}", 
              (integral/10000.0).ToString("P02", ci)); // Displays "P: 83.95 %"
      Console.WriteLine("X: 0x{0}", 
              integral.ToString("X", ci));           // Displays "X: 0x20CB"
      Console.WriteLine();
   }
}

NumberFormatInfo
Cadenas con formato numérico personalizado
Aplicar formato a tipos
Cómo: Rellenar un número con ceros iniciales
Ejemplo: Utilidad de formato de .NET Framework 4
Formatos compuestos

Mostrar: