Compartir a través de

Cadenas con formato numérico estándar

  • Artículo

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 [format specifier][precision specifier], donde:

  • El especificador de formato es un carácter alfabético único que especifica el tipo de formato numérico, como, por ejemplo, moneda o porcentaje. 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, consulte Cadenas con formato numérico personalizado.

  • El especificador de precisión es un entero opcional que afecta al número de dígitos de la cadena resultante. En .NET 7 y versiones posteriores, el valor de precisión máximo es 999,999,999. En .NET 6, el valor de precisión máximo es Int32.MaxValue. En versiones anteriores de .NET, la precisión puede oscilar entre 0 y 99. 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 de la cadena de resultado, esta refleja un número redondeado al resultado representable más cercano al resultado de precisión infinita. En el caso de que haya dos resultados representables igualmente cercanos:

    • En .NET Framework y .NET Core hasta la versión 2.0, el entorno de ejecución selecciona el resultado con el dígito menos significativo mayor (es decir, mediante MidpointRounding.AwayFromZero).
    • En .NET Core 2.1 y versiones posteriores, el runtime selecciona el resultado con un dígito menos significativo par (es decir, usando MidpointRounding.ToEven).

    Nota

    El especificador de precisión determina el número de dígitos de la cadena de resultado. Para rellenar una cadena de resultado con espacios iniciales o finales, use la característica formatos compuestos y defina un componente de alineación en el elemento de formato.

Las cadenas con formato numérico estándar son compatibles con:

Sugerencia

Puede descargar la Utilidad de formato, que es una aplicación de .NET Core Windows Forms que permite aplicar cadenas de formato a valores numéricos o de fecha y hora, y que muestra la cadena de resultado. El código fuente está disponible para C# y Visual Basic.

Especificadores de formato estándar

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. Consulte la sección Notas para obtener información adicional sobre cómo usar las cadenas con formato numérico estándar y la sección Ejemplo de código para ver una ilustración completa de su uso.

El resultado de una cadena con formato para una referencia cultural específica puede diferir de los ejemplos siguientes. La configuración del sistema operativo, la configuración de usuario, las variables de entorno y la versión de .NET que se usen pueden afectar al formato. Por ejemplo, a partir de .NET 5, .NET intenta unificar los formatos culturales en las plataformas. Para obtener más información, consulte Globalización de .NET e ICU.

Especificador de formato NOMBRE Descripción Ejemplos
"B" o "b" Binario Resultado: una cadena binaria.

Compatible con: tipos enteros solo (.NET 8+).

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

Más información: Especificador de formato binario ("B").		 42 ("B")
-> 101010

255 ("b16")
-> 0000000011111111
"C" o "c" Moneda Resultado: 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" Decimal Resultado: 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 necesario.

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 fijo Resultado: 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" General Resultado: 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úmero Resultado: 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" Porcentaje Resultado: 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 vuelta Resultado: cadena que puede aplicar acciones de ida y vuelta (round-trip) a un número idéntico.

Compatible con: Single, Double y BigInteger.

Nota: Se recomienda solo para el tipo BigInteger. Para los tipos Double, use "G17"; para los tipos Single, use "G9".
Especificador de precisión: ignorado.

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" Hexadecimal Resultado: 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 único Especificador desconocido Resultado: produce FormatException en tiempo de ejecución.

Uso de Cadenas con formato numérico estándar

Nota:

Los ejemplos de C# de este artículo se ejecutan en el ejecutor de código en línea y área de juegos de Try.NET. Haga clic en el botón Ejecutar para ejecutar un ejemplo en una ventana interactiva. Una vez que se ejecuta el código, puede modificar y ejecutar el código modificado si vuelve a hacer clic en Ejecutar. El código modificado se ejecuta en la ventana interactiva o, si se produce un error en la compilación, en la ventana interactiva se muestran todos los mensajes de error del compilador de C#.

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

  • Se puede pasar al método TryFormat o 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 = static_cast<Decimal>(123.456);
Console::WriteLine(value.ToString("C2"));
// Displays $123.46

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

    Dim value As Decimal = 123.456d
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, consulte Formatos compuestos. En el ejemplo siguiente se usa un elemento de formato para insertar un valor de divisa en una cadena.

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

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

    Dim value As Decimal = 123.456d
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.

    array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                            static_cast<Decimal>(18794.16) };
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      

    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

    Dim amounts() As Decimal = {16305.32d, 18794.16d}
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

  • Se puede proporcionar como el argumento formatString en un elemento de la expresión interpolada de una cadena interpolada. Para más información, consulte el artículo String interpolation (Interpolación de cadenas) en la referencia de C# o el artículo Interpolated Strings (Cadenas interpoladas) en la referencia de Visual Basic.

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

Especificador de formato binario (B)

El especificador de formato binario ("B") convierte un número en una cadena de dígitos binarios. Este formato solo es compatible con los tipos enteros y solo en .NET 8+.

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.

Especificador de formato de moneda (C)

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 NumberFormatInfo Descripción
CurrencyPositivePattern Define la posición del símbolo de divisa para los valores positivos.
CurrencyNegativePattern Define 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.
NegativeSign Define el signo negativo usado si CurrencyNegativePattern indica que no se emplean paréntesis.
CurrencySymbol Define el símbolo de divisa.
CurrencyDecimalDigits Define 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.
CurrencyDecimalSeparator Define la cadena que separa los dígitos integrales y decimales.
CurrencyGroupSeparator Define la cadena que separa los grupos de números integrales.
CurrencyGroupSizes Define 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

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
//       12.345,679 kr

Dim value As Double = 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

Especificador de formato decimal (D)

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 NumberFormatInfo Descripción
NegativeSign Define 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

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

Dim value As Integer

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

Especificador de formato exponencial (E)

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 NumberFormatInfo Descripción
NegativeSign Define la cadena que indica que un número es negativo tanto para el coeficiente como para el exponente.
NumberDecimalSeparator Define la cadena que separa el dígito integral de los dígitos decimales en el coeficiente.
PositiveSign Define 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

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

Dim value As Double = 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

Especificador de formato de punto fijo (F)

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 NumberFormatInfo Descripción
NegativeSign Define la cadena que indica que un número es negativo.
NumberDecimalSeparator Define la cadena que separa los dígitos integrales de los decimales.
NumberDecimalDigits Define 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                        

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

Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00

integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000

Dim doubleNumber As Double
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

Especificador de formato general (G)

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érico Precisión predeterminada
Byte o SByte 3 dígitos
Int16 o UInt16 5 dígitos
Int32 o UInt32 10 dígitos
Int64 19 dígitos
UInt64 20 dígitos
BigInteger Sin límite (igual que "R")
Half Número de dígitos más pequeño de ida y vuelta para representar el número
Single Número de dígitos más pequeño de ida y vuelta para representar el número (en .NET Framework, G7 es el valor predeterminado)
Double Número de dígitos más pequeño de ida y vuelta para representar el número (en .NET Framework, G15 es el valor predeterminado)
Decimal Número de dígitos más pequeño de ida y vuelta para representar el número

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.

Cuando se usa con un valor Double, el especificador de formato "G17" garantiza que el valor Double original realice una operación de ida y vuelta correctamente. Esto se debe a que Double es un número de punto flotante de doble precisión compatible con IEEE 754-2008 (binary64) que ofrece un máximo de 17 dígitos de precisión significativos. En .NET Framework, se recomienda su uso en lugar del especificador de formato "R", ya que, en algunos casos, "R" no logra realizar un recorrido de ida y vuelta correcto por los valores de números de punto flotante de doble precisión.

Cuando se usa con un valor Single, el especificador de formato "G9" garantiza que el valor Single original realice un recorrido de ida y vuelta correctamente. Esto se debe a que Single es un número de punto flotante de precisión sencilla compatible con IEEE 754-2008 (binary32) que ofrece hasta nueve dígitos de precisión significativos. Por motivos de rendimiento, se recomienda su uso en lugar del especificador de formato "R".

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 NumberFormatInfo Descripción
NegativeSign Define la cadena que indica que un número es negativo.
NumberDecimalSeparator Define la cadena que separa los dígitos integrales de los decimales.
PositiveSign Define 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    

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

Dim number As Double

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

Especificador de formato numérico (N)

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 NumberFormatInfo Descripción
NegativeSign Define la cadena que indica que un número es negativo.
NumberNegativePattern Define el formato de los valores negativos y especifica si el signo negativo se representa mediante paréntesis o por la propiedad NegativeSign.
NumberGroupSizes Define el número de dígitos enteros que aparecen entre los separadores de grupos.
NumberGroupSeparator Define la cadena que separa los grupos de números integrales.
NumberDecimalSeparator Define la cadena que separa los dígitos integrales y decimales.
NumberDecimalDigits Define 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 

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

Dim dblValue As Double = -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

Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0

Especificador de formato de porcentaje (P)

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 NumberFormatInfo Descripción
PercentPositivePattern Define la posición del símbolo de porcentaje para los valores positivos.
PercentNegativePattern Define la posición del símbolo de porcentaje y del símbolo negativo para los valores negativos.
NegativeSign Define la cadena que indica que un número es negativo.
PercentSymbol Define el símbolo de porcentaje.
PercentDecimalDigits Define 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.
PercentDecimalSeparator Define la cadena que separa los dígitos integrales y decimales.
PercentGroupSeparator Define la cadena que separa los grupos de números integrales.
PercentGroupSizes Define 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 %

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 %

Dim number As Double = .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 %

Especificador de formato de operación de ida y vuelta (R)

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

En .NET Framework y en versiones de .NET Core anteriores a 3.0, el especificador de formato "R" no puede realizar correctamente los operaciones de ida y vuelta con los valores Double en algunos casos. Para los dos valores Double y Single, el especificador de formato "R" también ofrece un rendimiento relativamente bajo. En su lugar, se recomienda usar el especificador de formato "G17" para los valores Double y el especificador de formato "G9" para realizar un recorrido de ida y vuelta correcto por los valores Single.

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.

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 NumberFormatInfo Descripción
NegativeSign Define la cadena que indica que un número es negativo.
NumberDecimalSeparator Define la cadena que separa los dígitos integrales de los decimales.
PositiveSign Define la cadena que indica que un exponente es positivo.

En el ejemplo siguiente se da formato a un valor BigInteger con el especificador de formato de ida y vuelta.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{ 
   BigInteger value = BigInteger::Pow(Int64::MaxValue, 2);
   Console::WriteLine(value.ToString("R"));
}
// The example displays the following output:
//      85070591730234615847396907784232501249  



using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      var value = BigInteger.Pow(Int64.MaxValue, 2);
      Console.WriteLine(value.ToString("R"));
   }
}
// The example displays the following output:
//      85070591730234615847396907784232501249

Imports System.Numerics

Module Example
    Public Sub Main()
        Dim value = BigInteger.Pow(Int64.MaxValue, 2)
        Console.WriteLine(value.ToString("R"))
    End Sub
End Module
' The example displays the following output:
'      85070591730234615847396907784232501249

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 la cadena de formato numérico estándar "R" que no realizan correctamente la acción de ida y vuelta si se compilan con los conmutadores /platform:x64 o /platform:anycpu y se ejecutan en sistemas de 64 bits, puede darles 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:

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':
//       .NET Framework:
//       0.6822871999174 = 0.68228719991740006: False
//       .NET:
//       0.6822871999174 = 0.6822871999174: True
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True

Imports System.Globalization

Module Example
    Public Sub Main()
        Console.WriteLine("Attempting to round-trip a Double with 'R':")
        Dim initialValue As Double = 0.6822871999174
        Dim valueString As String = initialValue.ToString("R",
                                                 CultureInfo.InvariantCulture)
        Dim roundTripped As Double = Double.Parse(valueString,
                                                  CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped, initialValue.Equals(roundTripped))
        Console.WriteLine()

        Console.WriteLine("Attempting to round-trip a Double with 'G17':")
        Dim valueString17 As String = initialValue.ToString("G17",
                                                   CultureInfo.InvariantCulture)
        Dim roundTripped17 As Double = double.Parse(valueString17,
                                              CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped17, initialValue.Equals(roundTripped17))
    End Sub
End Module
' 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':
'       .NET Framework:
'       0.6822871999174 = 0.68228719991740006: False
'       .NET:
'       0.6822871999174 = 0.6822871999174: True
'
'       Attempting to round-trip a Double with 'G17':
'       0.6822871999174 = 0.6822871999174: True

Especificador de formato hexadecimal (X)

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

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

Dim value As Integer

value = &h2045e
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

Notas

Esta sección contiene información adicional sobre el uso de cadenas de formato numérico estándar.

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 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(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(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 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.

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, Half, Single y Double.

Infinitos de punto flotante y NaN

Independientemente de la cadena de formato, si el valor de un tipo de punto flotante Half, 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.

Ejemplo de código

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, Half y Single).

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

Option Strict On

Imports System.Globalization
Imports System.Threading

Module NumericFormats
    Public Sub Main()
        ' Display string representations of numbers for en-us culture
        Dim ci As New CultureInfo("en-us")

        ' Output floating point values
        Dim floating As Double = 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
        Dim integral As Integer = 8395
        Console.WriteLine("C: {0}", _
                integral.ToString("C", ci))           ' Displays "C: $8,395.00"
        Console.WriteLine("D: {0}", _
                integral.ToString("D6"))              ' 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).ToString("P02", ci)) ' Displays "P: 83.95 %"
        Console.WriteLine("X: 0x{0}", _
                integral.ToString("X", ci))           ' Displays "X: 0x20CB"
        Console.WriteLine()
    End Sub
End Module

Vea también