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, vea Cadenas de 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 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.Flooro Math.Round.

    Cuando especificador de precisión controla el número de dígitos fraccionarios en la cadena de resultado, la cadena de resultado refleja un número redondeado a un resultado representable más cercano al resultado infinitomente preciso. Si hay dos resultados que se pueden representar de forma equitativa:

    • En .NET Framework y .NET Core hasta .NET Core 2.0, el entorno de ejecución selecciona el resultado con el dígito menos significativo (es decir, mediante MidpointRounding.AwayFromZero).
    • en .NET Core 2.1 y versiones posteriores, el entorno de ejecución selecciona el resultado con un dígito incluso menos significativo (es decir, mediante 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 formato compuesto y defina un componente de alineación en el elemento de formato.

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

Sugerencia

Puede descargar el Utilidad de formato, una aplicación de Windows Forms de .NET Core que le permite aplicar cadenas de formato a valores numéricos o numéricos o de fecha y hora y muestra la cadena de resultado. El código fuente está disponible para de 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 de para obtener información adicional sobre el uso de cadenas de formato numérico estándar y la sección Ejemplo de código de para obtener 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 del usuario, las variables de entorno y la versión de .NET que usa pueden afectar al formato. Por ejemplo, a partir de .NET 5, .NET intenta unificar los formatos culturales entre 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: solo tipos enteros (.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" Divisa 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" Ida y vuelta Resultado: cadena que puede realizar un recorrido de ida y vuelta a un número idéntico.

Compatible con: Single, Double y BigInteger.

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

Más información: especificador de formato 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 un 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 Try.NET ejecutor de código en línea y entorno de pruebas. 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#.

Se puede usar una cadena de formato numérico estándar 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 en un elemento de formato usado con métodos como String.Format, Console.WriteLiney StringBuilder.AppendFormat. Para obtener más información, vea formato compuesto. En el ejemplo siguiente se usa un elemento de formato para insertar un valor de moneda 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 {value:C2}.");
// 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 proporcionar un argumento alignment para especificar el ancho del campo numérico y si su valor está alineado a la derecha o a la izquierda. En el ejemplo siguiente se alinea 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 argumento formatString en un elemento de expresión interpolada de una cadena interpolada. Para obtener más información, consulte el artículo Interpolación de cadenas en la referencia de C# o en el artículo cadenas interpoladas de 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 se admite para 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 cadena de resultado no se ve afectada por la información de formato del objeto NumberFormatInfo actual.

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 se define mediante 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 cadena de resultado se ve afectada por la información de formato del objeto NumberFormatInfo actual. En la tabla siguiente se enumeran las propiedades NumberFormatInfo que controlan el formato de la cadena devuelta.

Propiedad NumberFormatInfo Descripción
CurrencyPositivePattern Define la ubicación del símbolo de moneda para los valores positivos.
CurrencyNegativePattern Define la ubicación del símbolo de moneda para los valores negativos y especifica si el signo negativo se representa entre paréntesis o la propiedad NegativeSign.
NegativeSign Define el signo negativo usado si CurrencyNegativePattern indica que no se usan paréntesis.
CurrencySymbol Define el símbolo de moneda.
CurrencyDecimalDigits Define el número predeterminado de dígitos decimales en un valor de moneda. Este valor se puede invalidar mediante el especificador de precisión.
CurrencyDecimalSeparator Define la cadena que separa dígitos enteros y decimales.
CurrencyGroupSeparator Define la cadena que separa grupos de números enteros.
CurrencyGroupSizes Define el número de dígitos enteros que aparecen en un grupo.

En el ejemplo siguiente se da formato a un valor de Double con el especificador de formato de moneda:

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 cadena de resultado se ve afectada por la información de formato del objeto NumberFormatInfo actual. Como se muestra en la tabla siguiente, una sola propiedad afecta al formato de la cadena de resultado.

Propiedad 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 de 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 cadena de resultado se ve afectada por la información de formato del objeto NumberFormatInfo actual. En la tabla siguiente se enumeran las propiedades NumberFormatInfo que controlan el formato de la cadena devuelta.

Propiedad NumberFormatInfo Descripción
NegativeSign Define la cadena que indica que un número es negativo para el coeficiente y el exponente.
NumberDecimalSeparator Define la cadena que separa el dígito entero de los dígitos decimales del coeficiente.
PositiveSign Define la cadena que indica que un exponente es positivo.

En el ejemplo siguiente se da formato a un valor de 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 cadena de resultado se ve afectada por la información de formato del objeto NumberFormatInfo actual. En la tabla siguiente se enumeran las propiedades del objeto NumberFormatInfo que controlan el formato de la cadena de resultado.

Propiedad NumberFormatInfo Descripción
NegativeSign Define la cadena que indica que un número es negativo.
NumberDecimalSeparator Define la cadena que separa los dígitos enteros de los dígitos decimales.
NumberDecimalDigits Define el número predeterminado de dígitos decimales. Este valor se puede invalidar mediante el especificador de precisión.

En el ejemplo siguiente se da formato a un Double y un valor de 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 Ilimitado (igual que "R")
Half Número de dígitos que se pueden recorrer de ida y vuelta más pequeños para representar el número
Single Número de dígitos que se pueden recorrer de ida y vuelta más pequeños para representar el número (en .NET Framework, G7 es el valor predeterminado)
Double Número de dígitos que se pueden recorrer de ida y vuelta más pequeños para representar el número (en .NET Framework, G15 es el valor predeterminado)
Decimal Número de dígitos que se pueden recorrer de ida y vuelta más pequeños 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 de Double, el especificador de formato "G17" garantiza que el Double valor original se redondee correctamente. Esto se debe a que Double es un número de punto flotante compatible con IEEE 754-2008 (binary64) que da hasta 17 dígitos significativos de precisión. En .NET Framework, se recomienda su uso en lugar de la especificador de formato "R", ya que en algunos casos "R" no puede realizar correctamente valores de punto flotante de doble precisión de ida y vuelta.

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

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

Propiedad NumberFormatInfo Descripción
NegativeSign Define la cadena que indica que un número es negativo.
NumberDecimalSeparator Define la cadena que separa los dígitos enteros de los dígitos 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 se define mediante la propiedad NumberFormatInfo.NumberDecimalDigits actual.

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

Propiedad 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 entre paréntesis o la propiedad NegativeSign.
NumberGroupSizes Define el número de dígitos enteros que aparecen entre separadores de grupo.
NumberGroupSeparator Define la cadena que separa grupos de números enteros.
NumberDecimalSeparator Define la cadena que separa dígitos enteros y decimales.
NumberDecimalDigits Define el número predeterminado de dígitos decimales. Este valor se puede invalidar mediante 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 usa la precisión numérica predeterminada proporcionada por la propiedad PercentDecimalDigits actual.

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

Propiedad NumberFormatInfo Descripción
PercentPositivePattern Define la ubicación del símbolo de porcentaje para los valores positivos.
PercentNegativePattern Define la ubicación del símbolo de porcentaje y el 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 se puede invalidar mediante el especificador de precisión.
PercentDecimalSeparator Define la cadena que separa dígitos enteros y decimales.
PercentGroupSeparator Define la cadena que separa grupos de números enteros.
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 ida y vuelta (R)

El especificador de formato de ida y vuelta ("R") intenta asegurarse de que un valor numérico que se convierte en una cadena se analiza de nuevo en el mismo valor numérico. Este formato solo se admite para los tipos Half, Single, Doubley BigInteger.

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

Cuando se da formato a un valor BigInteger mediante este especificador, su representación de cadena contiene todos los dígitos significativos del valor de BigInteger.

Aunque puede incluir un especificador de precisión, se omite. Los recorridos de ida y vuelta tienen prioridad sobre la precisión al usar este especificador. La cadena de resultado se ve afectada por la información de formato del objeto NumberFormatInfo actual. En la tabla siguiente se enumeran las propiedades NumberFormatInfo que controlan el formato de la cadena de resultado.

Propiedad NumberFormatInfo Descripción
NegativeSign Define la cadena que indica que un número es negativo.
NumberDecimalSeparator Define la cadena que separa los dígitos enteros de los dígitos decimales.
PositiveSign Define la cadena que indica que un exponente es positivo.

En el ejemplo siguiente se da formato a un valor de 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 de Double con formato "R" estándar de cadena de formato numérico no se realizan correctamente de ida y vuelta si se compilan con los modificadores de /platform:x64 o /platform:anycpu y se ejecutan en sistemas de 64 bits. Consulte el párrafo siguiente para obtener más información.

Para solucionar el problema de los valores de Double con el formato de cadena de formato numérico estándar "R" no se realiza correctamente el recorrido de ida y vuelta si se compila con los modificadores de /platform:x64 o /platform:anycpu y se ejecuta en sistemas de 64 bits, puede dar formato a los valores de Double mediante la cadena de formato numérico estándar "G17". En el ejemplo siguiente se usa la cadena de formato "R" con un valor de Double que no realiza correctamente el recorrido de ida y vuelta, y también se usa la cadena de formato "G17" para realizar correctamente el recorrido 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 cadena de resultado no se ve afectada por la información de formato del objeto NumberFormatInfo actual.

En el ejemplo siguiente se da formato Int32 valores 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

La configuración de la opciones regionales y de idioma elemento del Panel de control influye en la cadena de resultado producida por una operación de formato. Estos valores se usan para inicializar el objeto NumberFormatInfo asociado a la referencia cultural actual, que proporciona valores usados para controlar el formato. Los equipos que usan diferentes configuraciones generan cadenas de resultado diferentes.

Además, si el constructor de CultureInfo(String) se usa para crear instancias de un nuevo objeto de CultureInfo que representa la misma referencia cultural que la referencia cultural del sistema actual, las personalizaciones establecidas por el elemento Regional y Language Options en el Panel de control se aplicarán 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, que la referencia cultural actual proporciona implícitamente o explícitamente el parámetro IFormatProvider del método que invoca formato. Especifique un objeto NumberFormatInfo o CultureInfo para ese parámetro.

Nota:

Para obtener información sobre cómo personalizar los patrones o cadenas usados en el formato de valores numéricos, consulte 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 enteros son Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64y BigInteger. Los tipos numéricos de punto flotante son Decimal, Half, Singley Double.

Infinitos de punto flotante y NaN

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

Ejemplo de código

En el ejemplo siguiente se da formato a un valor numérico entero y de punto flotante mediante la referencia cultural de 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 produciría resultados similares para cualquiera de los otros tipos base numéricos (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal, Halfy 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

Consulte también