Esta documentación está archivada y no tiene mantenimiento.

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. Una cadena de formato numérico estándar presenta la forma Axx, donde A es un carácter alfabético que recibe el nombre de especificador de formato y xx es un entero opcional que recibe el nombre de 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. 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.

En la siguiente tabla se describen los especificadores de formato numérico estándar. Para obtener ejemplos del resultado producido por cada especificador de formato, vea Ejemplos de resultados de cadenas con formato numérico estándar. Para obtener más información, vea las notas a continuación de la tabla.

Especificador de formato Nombre Descripción

C o c

Moneda

El número se convierte en una cadena que representa una cantidad de moneda. La conversión se controla mediante la información de formato de moneda del objeto NumberFormatInfo actual.

El especificador de precisión indica el número deseado de cifras decimales. Si se omite el especificador de precisión, se emplea la precisión de moneda predeterminada aportada por el objeto NumberFormatInfo actual.

D o d

Decimal

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

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.

E o e

Científico (exponencial)

El número se convierte en una cadena de caracteres del tipo "-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 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.

La mayúscula o minúscula del especificador de formato indica si debemos 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.

F o f

Punto fijo

El número se convierte en una cadena del tipo "-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, se emplea la precisión numérica predeterminada aportada por el objeto NumberFormatInfo actual.

G o g

General

El número se convierte al punto fijo o la notación científica más compactos, dependiendo del tipo de número y de si hay un especificador de precisión. Si se omite el especificador de precisión o es cero, el tipo de número determina la precisión predeterminada, tal como se indica en la lista siguiente.

  • Byte o SByte: 3

  • Int16 o UInt16: 5

  • Int32 o UInt32: 10

  • Int64 o UInt64: 19

  • Single: 7

  • Double: 15

  • Decimal: 29

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 punto decimal si es necesario y se omiten los ceros finales. Si está presente el especificador de precisión y el número de dígitos significativos del resultado supera la precisión especificada, los dígitos finales sobrantes se eliminan mediante el redondeo.

La excepción a la regla anterior ocurre cuando el número es un Decimal y se omite el especificador de precisión. En tal caso, se utiliza siempre la notación de punto fijo y se conservan los ceros finales.

Si se utiliza la notación científica, el exponente en el resultado lleva el prefijo "E" si el especificador de formato es "G", o "e" si el especificador de formato es "g".

N o n

Número

El número se convierte en una cadena con la forma "-d,ddd,ddd.ddd…", donde '-' hace referencia a un símbolo de número negativo, si es necesario; 'd', a un dígito (0-9); ',', al separador de miles entre los grupos de números; y '.' al símbolo de separador decimal. El modelo de número negativo, el tamaño del grupo de números, el separador de miles y el separador decimal se especifican mediante el objeto NumberFormatInfo actual.

El especificador de precisión indica el número deseado de cifras decimales. Si se omite el especificador de precisión, se emplea la precisión numérica predeterminada aportada por el objeto NumberFormatInfo actual.

P o p

Porcentaje

El número se convierte en una cadena que representa un porcentaje, tal como lo define la propiedad NumberFormatInfo.PercentNegativePattern si el número es negativo, o la propiedad NumberFormatInfo.PercentPositivePattern si el número es positivo. El número convertido se multiplica por 100 para presentarlo como un porcentaje.

El especificador de precisión indica el número deseado de cifras decimales. Si se omite el especificador de precisión, se emplea la precisión numérica predeterminada aportada por el objeto NumberFormatInfo actual.

R o r

Acción de ida y vuelta

Este formato sólo es compatible con los tipos Single y Double. El especificador de acción de ida y vuelta garantiza que un valor numérico convertido en cadena volverá a tomar el mismo valor numérico. Cuando se da formato a un valor numérico mediante este especificador, primero se comprueba empleando el formato general, con 15 espacios de precisión para Double y 7 espacios de precisión para Single. Si el valor vuelve a ser efectivamente el mismo valor numérico, se le dará formato utilizando el especificador de formato general. Sin embargo, si el valor no recupera con éxito el mismo valor numérico, se le dará formato empleando 17 dígitos de precisión para Double y 9 dígitos de precisión para Single.

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

X o x

Hexadecimal

Este formato sólo es compatible con los tipos enteros. El número se convierte en una cadena de dígitos hexadecimales. La mayúscula o minúscula del especificador de formato indica si hay que emplear los caracteres en mayúsculas o en minúsculas para los dígitos hexadecimales mayores que 9. Por ejemplo, se utiliza 'X' para generar "ABCDEF"y 'x' para generar "abcdef".

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.

Cualquier otro carácter único

(Especificador desconocido)

(Un especificador desconocido inicia una excepción de formato en tiempo de ejecución.)

Notas

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. Estos valores de configuración se utilizan para inicializar el objeto NumberFormatInfo asociado a la referencia cultural del subproceso actual, y la referencia cultural del subproceso actual proporciona valores que se utilizan para controlar el formato. Los equipos que utilicen una configuración diferente generarán cadenas de resultado diferentes.

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.

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 enteros son Byte, SByte, Int16, Int32, Int64, UInt16, UInt32 y UInt64. Los tipos numéricos de punto flotante son Decimal, Single y Double.

Infinitos de punto flotante y NaN

Tenga en cuenta que, 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 actualmente aplicable.

Ejemplo

El siguiente ejemplo de código da formato a un valor numérico entero y de punto flotante mediante la referencia cultural actual del subproceso, una referencia cultural especificada y todos los especificadores de formato numérico estándar. Este ejemplo de código utiliza dos tipos numéricos concretos, pero produciría resultados similares para cualquiera de los tipos numéricos base (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, Decimal, Single y Double).

// This code example demonstrates the ToString(String) and 
// ToString(String, IFormatProvider) methods for integral and
// floating-point numbers, in conjunction with the standard 
// numeric format specifiers.
// This code example uses the System.Int32 integral type and 
// the System.Double floating-point type, but would yield 
// similar results for any of the numeric types. The integral 
// numeric types are System.Byte, SByte, Int16, Int32, Int64, 
// UInt16, UInt32, and UInt64. The floating-point numeric types 
// are Decimal, Single, and Double.

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

class Sample 
{
    public static void Main() 
    {
// Format a negative integer or floating-point number in various ways.
    int    integralVal = -12345;
    double floatingVal = -1234.567d;

    string msgCurrency =    "(C) Currency: . . . . . . ";
    string msgDecimal  =    "(D) Decimal:. . . . . . . ";
    string msgScientific =  "(E) Scientific: . . . . . ";
    string msgFixedPoint =  "(F) Fixed point:. . . . . ";
    string msgGeneral =     "(G) General (default):. . ";
    string msgNumber =      "(N) Number: . . . . . . . ";
    string msgPercent =     "(P) Percent:. . . . . . . ";
    string msgRoundTrip =   "(R) Round-trip: . . . . . ";
    string msgHexadecimal = "(X) Hexadecimal:. . . . . ";

    string msg1 = "Use ToString(String) and the current thread culture.\n";
    string msg2 = "Use ToString(String, IFormatProvider) and a specified culture.\n";
    string msgCulture     = "Culture:";
    string msgIntegralVal = "Integral value:";
    string msgFloatingVal = "Floating-point value:";

    CultureInfo ci;
//
    Console.Clear();
    Console.WriteLine("Standard Numeric Format Specifiers:\n");
// Display the values.
    Console.WriteLine(msg1);

// Display the thread current culture, which is used to format the values.
    ci = Thread.CurrentThread.CurrentCulture;
    Console.WriteLine("{0,-26}{1}", msgCulture, ci.DisplayName);

// Display the integral and floating-point values.
    Console.WriteLine("{0,-26}{1}", msgIntegralVal, integralVal);
    Console.WriteLine("{0,-26}{1}", msgFloatingVal, floatingVal);
    Console.WriteLine();

// Use the format specifiers that are only for integral types.
    Console.WriteLine("Format specifiers only for integral types:");
    Console.WriteLine(msgDecimal     + integralVal.ToString("D"));
    Console.WriteLine(msgHexadecimal + integralVal.ToString("X"));
    Console.WriteLine();

// Use the format specifier that is only for the Single and Double 
// floating-point types.
    Console.WriteLine("Format specifier only for the Single and Double types:");
    Console.WriteLine(msgRoundTrip   + floatingVal.ToString("R"));
    Console.WriteLine();

// Use the format specifiers that are for integral or floating-point types.
    Console.WriteLine("Format specifiers for integral or floating-point types:");
    Console.WriteLine(msgCurrency    + floatingVal.ToString("C"));
    Console.WriteLine(msgScientific  + floatingVal.ToString("E"));
    Console.WriteLine(msgFixedPoint  + floatingVal.ToString("F"));
    Console.WriteLine(msgGeneral     + floatingVal.ToString("G"));
    Console.WriteLine(msgNumber      + floatingVal.ToString("N"));
    Console.WriteLine(msgPercent     + floatingVal.ToString("P"));
    Console.WriteLine();

// Display the same values using a CultureInfo object. The CultureInfo class 
// implements IFormatProvider.
    Console.WriteLine(msg2);

// Display the culture used to format the values. 
// Create a European culture and change its currency symbol to "euro" because 
// this particular code example uses a thread current UI culture that cannot 
// display the euro symbol (€).
    ci = new CultureInfo("de-DE");
    ci.NumberFormat.CurrencySymbol = "euro";
    Console.WriteLine("{0,-26}{1}", msgCulture, ci.DisplayName);

// Display the integral and floating-point values.
    Console.WriteLine("{0,-26}{1}", msgIntegralVal, integralVal);
    Console.WriteLine("{0,-26}{1}", msgFloatingVal, floatingVal);
    Console.WriteLine();

// Use the format specifiers that are only for integral types.
    Console.WriteLine("Format specifiers only for integral types:");
    Console.WriteLine(msgDecimal     + integralVal.ToString("D", ci));
    Console.WriteLine(msgHexadecimal + integralVal.ToString("X", ci));
    Console.WriteLine();

// Use the format specifier that is only for the Single and Double 
// floating-point types.
    Console.WriteLine("Format specifier only for the Single and Double types:");
    Console.WriteLine(msgRoundTrip   + floatingVal.ToString("R", ci));
    Console.WriteLine();

// Use the format specifiers that are for integral or floating-point types.
    Console.WriteLine("Format specifiers for integral or floating-point types:");
    Console.WriteLine(msgCurrency    + floatingVal.ToString("C", ci));
    Console.WriteLine(msgScientific  + floatingVal.ToString("E", ci));
    Console.WriteLine(msgFixedPoint  + floatingVal.ToString("F", ci));
    Console.WriteLine(msgGeneral     + floatingVal.ToString("G", ci));
    Console.WriteLine(msgNumber      + floatingVal.ToString("N", ci));
    Console.WriteLine(msgPercent     + floatingVal.ToString("P", ci));
    Console.WriteLine();
    }
}
/*
This code example produces the following results:

Standard Numeric Format Specifiers:

Use ToString(String) and the current thread culture.

Culture:                  English (United States)
Integral value:           -12345
Floating-point value:     -1234.567

Format specifiers only for integral types:
(D) Decimal:. . . . . . . -12345
(X) Hexadecimal:. . . . . FFFFCFC7

Format specifier only for the Single and Double types:
(R) Round-trip: . . . . . -1234.567

Format specifiers for integral or floating-point types:
(C) Currency: . . . . . . ($1,234.57)
(E) Scientific: . . . . . -1.234567E+003
(F) Fixed point:. . . . . -1234.57
(G) General (default):. . -1234.567
(N) Number: . . . . . . . -1,234.57
(P) Percent:. . . . . . . -123,456.70 %

Use ToString(String, IFormatProvider) and a specified culture.

Culture:                  German (Germany)
Integral value:           -12345
Floating-point value:     -1234.567

Format specifiers only for integral types:
(D) Decimal:. . . . . . . -12345
(X) Hexadecimal:. . . . . FFFFCFC7

Format specifier only for the Single and Double types:
(R) Round-trip: . . . . . -1234,567

Format specifiers for integral or floating-point types:
(C) Currency: . . . . . . -1.234,57 euro
(E) Scientific: . . . . . -1,234567E+003
(F) Fixed point:. . . . . -1234,57
(G) General (default):. . -1234,567
(N) Number: . . . . . . . -1.234,57
(P) Percent:. . . . . . . -123.456,70%

*/

Vea también

Mostrar: