Nota
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
Las cadenas de formato numérico estándar se usan para dar formato a tipos numéricos comunes. Una cadena de formato numérico estándar toma la forma [format specifier][precision specifier], donde:
El especificador de formato es un carácter alfabético único que especifica el tipo de formato numérico, 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 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 Math.Ceilingmétodo , Math.Flooro Math.Round .
Cuando el 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 de formato compuesto y defina un componente de ancho en el elemento de formato.
Las cadenas de formato numérico estándar son compatibles con:
Algunas sobrecargas del
ToStringmétodo de todos los tipos numéricos. Por ejemplo, puede proporcionar una cadena de formato numérico a los Int32.ToString(String) métodos y Int32.ToString(String, IFormatProvider) .Método
TryFormatde todos los tipos numéricos, por ejemplo, Int32.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) y Single.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider).La característica de formato compuesto de .NET, que usan algunos
Writemétodos yWriteLinede las Console clases y StreamWriter , el String.Format método y el StringBuilder.AppendFormat método . La característica de formato compuesto permite incluir la representación de cadena de varios elementos de datos en una sola cadena, especificar el ancho del campo y alinear números en un campo. Para obtener más información, consulte Formato compuesto.Cadenas interpoladas en C# y Visual Basic, que proporcionan una sintaxis simplificada en comparación con las cadenas de formato compuesto.
Sugerencia
Puede descargar la 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 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 muestra la salida de ejemplo generada por cada especificador de formato. Consulte la sección Notas para obtener información adicional sobre el uso de cadenas de formato numérico estándar y la sección Ejemplo de código 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 más información, consulte Globalización e ICU de .NET.
| 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 moneda. 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 moneda ("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 solo con: tipos enteros. Especificador de precisión: número mínimo de dígitos. Especificador de precisión predeterminado: número mínimo de dígitos necesarios. Más información: Especificador de formato Decimal("D"). |
1234 ("D") -> Año 1234 -1234 ("D6") -> -001234 |
| "E" o "e" | Exponencial (científica) | 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) -> 1052033e+003 -1052.0329112756 ("e2", en-US) -> -1.05e+003 -1052.0329112756 ("E2", fr-FR) -> -105E+003 |
| "F" o "f" | Punto fijo | Resultado: dígitos enteros 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 Fixed-Point ("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: cuanto más compacto sea la notación fija o científica. 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 enteros y decimales, separadores de grupo y separador decimal con signo negativo opcional. Compatible con: Todos los tipos numéricos. Especificador de precisión: número deseado de posiciones decimales. Especificador de precisión predeterminado: definido por NumberFormatInfo.NumberDecimalDigits. Más información: Especificador de formato numérico ("N"). |
1.234,567 ("N", en-US) -> 1.234.57 1.234,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 posiciones decimales. Especificador de precisión predeterminado: definido por NumberFormatInfo.PercentDecimalDigits. Más información: Especificador de formato percent ("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 BigInteger tipo. Para Double los tipos, use "G17"; para Single los tipos, 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: una cadena hexadecimal. Compatible solo con: 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") -> 00 y ss. -1 ("X4") -> 00FF |
| Cualquier otro carácter único | Especificador desconocido | Resultado: produce una FormatException excepción en tiempo de ejecución. |
Uso de cadenas de formato numérico estándar
Nota:
Los ejemplos de C# de este artículo se ejecutan en el ejecutor de código insertado y en el área de juegos de Try.NET. Seleccione el botón Ejecutar para ejecutar un ejemplo en una ventana interactiva. Una vez ejecutado el código, puede modificarlo y ejecutar el código modificado seleccionando Ejecutar de nuevo. 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 o a
TryFormatuna sobrecarga delToStringmétodo que tiene unformatparámetro . En el ejemplo siguiente se da formato a un valor numérico como una cadena de moneda en la referencia cultural actual (en este caso, la referencia cultural en-US).decimal value = 123.456m; Console.WriteLine(value.ToString("C2")); // Displays $123.46Dim value As Decimal = 123.456d Console.WriteLine(value.ToString("C2")) ' Displays $123.46Se puede proporcionar como argumento
formatStringen un elemento de formato usado con métodos como String.Format, Console.WriteLiney StringBuilder.AppendFormat. Para obtener más información, consulte Formato compuesto. En el ejemplo siguiente se usa un elemento de formato para insertar un valor de moneda en una cadena.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
alignmentargumento 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.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.16Dim 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.16Se puede proporcionar como argumento
formatStringen un elemento de expresión interpolada de una cadena interpolada. Para obtener más información, vea el artículo Interpolación de cadenas en la referencia de C# o en el artículo Cadenas interpoladas de 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 deseados en la cadena resultante. Si es necesario, el número se rellena con ceros a su izquierda para generar el número de dígitos proporcionados por el especificador de precisión.
La cadena de resultado no se ve afectada por la información de formato del objeto actual NumberFormatInfo .
Especificador de formato de moneda (C)
El especificador de formato "C" (o moneda) convierte un número en una cadena que representa una cantidad de moneda. 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 NumberFormatInfo.CurrencyDecimalDigits propiedad .
Si el valor al que se va a dar formato tiene más del número especificado o predeterminado de posiciones decimales, 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 de cero.
La cadena de resultado se ve afectada por la información de formato del objeto actual NumberFormatInfo . En la tabla siguiente se enumeran las NumberFormatInfo propiedades 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 colocación del símbolo de moneda para los valores negativos y especifica si el signo negativo se representa entre paréntesis o la NegativeSign propiedad . |
| 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 Double valor 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
// 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), prefijo por un signo menos si el número es negativo. Este formato solo se admite para tipos enteros.
El especificador de precisión indica el número mínimo de dígitos deseados en la cadena resultante. Si es necesario, el número se rellena con ceros a su izquierda para generar el número de dígitos proporcionados por el especificador de precisión. Si no se especifica 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 actual NumberFormatInfo . 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 Int32 valor 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
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 del 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. Exactamente un dígito siempre precede al separador 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, se usa un valor predeterminado de seis dígitos después de usar el separador decimal.
El caso del especificador de formato indica si se debe prefijar el exponente con "E" o "e". El exponente siempre consta de un signo más o menos y un mínimo de tres dígitos. El exponente se rellena con ceros para cumplir este mínimo, si es necesario.
La cadena de resultado se ve afectada por la información de formato del objeto actual NumberFormatInfo . En la tabla siguiente se enumeran las NumberFormatInfo propiedades 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 Double valor 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
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 de la forma "-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 posiciones decimales. Si se omite el especificador de precisión, la propiedad actual NumberFormatInfo.NumberDecimalDigits proporciona la precisión numérica.
La cadena de resultado se ve afectada por la información de formato del objeto actual NumberFormatInfo . En la tabla siguiente se enumeran las propiedades del NumberFormatInfo objeto 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 Double y un Int32 valor 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
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 en el más compacto de notación fija o científica, dependiendo del tipo del número y de si existe un especificador de precisión. El especificador de precisión define el número máximo de dígitos significativos que pueden aparecer en la cadena de resultado. Si se omite el especificador de precisión o 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 usa si el exponente que daría lugar a expresar el número en notación científica es mayor que -5 y menor que el especificador de precisión; De lo contrario, se usa la notación científica. El resultado contiene un separador decimal si es necesario y ceros finales después de omitir el separador decimal. Si el especificador de precisión está presente y el número de dígitos significativos en el resultado supera la precisión especificada, los dígitos finales excesivos se quitan redondeando.
Sin embargo, si el número es y Decimal 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 tiene 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 de notación científica generado por el especificador de formato exponencial, que incluye un mínimo de tres dígitos en el exponente.
Cuando se usa con un Double valor, el especificador de formato "G17" garantiza que el valor original Double se redondee correctamente. Esto se debe a Double que 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 del especificador de formato "R", ya que, en algunos casos, "R" no puede realizar correctamente valores de punto flotante de precisión doble de ida y vuelta.
Cuando se usa con un Single valor, el especificador de formato "G9" garantiza que el valor original Single se redondee correctamente. Esto se debe a Single que es un número de punto flotante compatible con IEEE 754-2008 () de precisión sencilla (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".
La cadena de resultado se ve afectada por la información de formato del objeto actual NumberFormatInfo . En la tabla siguiente se enumeran las NumberFormatInfo propiedades 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
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 de la forma "-d,ddd,ddd.ddd...", donde "-" indica un símbolo de número negativo si es necesario, "d" indica un dígito (0-9), "," indica un separador de grupo y "." indica un 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, la propiedad actual NumberFormatInfo.NumberDecimalDigits define el número de posiciones decimales.
La cadena de resultado se ve afectada por la información de formato del objeto actual NumberFormatInfo . En la tabla siguiente se enumeran las NumberFormatInfo propiedades 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 NegativeSign propiedad . |
| 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 los valores de punto flotante ordenados con el especificador de formato de número:
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 percent ("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 posiciones decimales. Si se omite el especificador de precisión, se usa la precisión numérica predeterminada proporcionada por la propiedad actual PercentDecimalDigits .
En la tabla siguiente se enumeran las NumberFormatInfo propiedades 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 los 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 %
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 Halftipos , 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 valores de ida y vuelta Double en algunos casos. Para los valores y DoubleSingle , el especificador de formato "R" ofrece un rendimiento relativamente bajo. En su lugar, se recomienda usar el especificador de formato "G17" para Double los valores y el especificador de formato "G9" para los valores de ida y vuelta Single correctos.
Cuando se da formato a un BigInteger valor mediante este especificador, su representación de cadena contiene todos los dígitos significativos del BigInteger valor.
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 actual NumberFormatInfo . En la tabla siguiente se enumeran las NumberFormatInfo propiedades 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 BigInteger valor con el especificador de formato de ida y vuelta.
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, Double los valores con formato "R" estándar de cadena de formato numérico no se realizan correctamente de ida y vuelta si se compilan con los /platform:x64 modificadores 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 Double los valores con 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 /platform:x64 modificadores o /platform:anycpu y se ejecuta en sistemas de 64 bits, puede dar formato Double a los valores mediante la cadena de formato numérico estándar "G17". En el ejemplo siguiente se usa la cadena de formato "R" con un Double valor 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($"{initialValue:R} = {roundTripped:R}: {initialValue.Equals(roundTripped)}\n");
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($"{initialValue:R} = {roundTripped17:R}: {initialValue.Equals(roundTripped17)}\n");
// 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 caso del especificador de formato indica si se deben usar caracteres en mayúsculas o minúsculas para dígitos hexadecimales mayores que 9. Por ejemplo, use "X" para generar "ABCDEF" y "x" para generar "abcdef". Este formato solo se admite para tipos enteros.
El especificador de precisión indica el número mínimo de dígitos deseados en la cadena resultante. Si es necesario, el número se rellena con ceros a su izquierda para generar el número de dígitos proporcionados por el especificador de precisión.
La cadena de resultado no se ve afectada por la información de formato del objeto actual NumberFormatInfo .
En el ejemplo siguiente se da formato a los 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
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 del elemento Opciones regionales y de idioma del Panel de control influye en la cadena de resultados generada por una operación de formato. Estos valores se usan para inicializar el objeto asociado a la referencia cultural actual, que proporciona valores usados para controlar el NumberFormatInfo formato. Los equipos que usan diferentes configuraciones generan cadenas de resultado diferentes.
Además, si el CultureInfo(String) constructor se usa para crear instancias de un nuevo CultureInfo objeto que representa la misma referencia cultural que la referencia cultural del sistema actual, las personalizaciones establecidas por el elemento Opciones regionales y de idioma del Panel de control se aplicarán al nuevo CultureInfo objeto. Puede usar el CultureInfo(String, Boolean) constructor para crear un CultureInfo objeto que no refleje las personalizaciones de un sistema.
Propiedades NumberFormatInfo
El formato se ve influenciado por las propiedades del objeto actual NumberFormatInfo , que la referencia cultural actual proporciona implícitamente o explícitamente el IFormatProvider parámetro del método que invoca formato. Especifique un NumberFormatInfo objeto 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, vea el tema de la NumberFormatInfo clase .
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, Int32Int64UInt16UInt32, , UInt64y .BigInteger Los tipos numéricos de punto flotante son Decimal, Half, Singley Double.
Enteros de punto flotante y NaN
Independientemente de la cadena de formato, si el valor de un Halftipo de punto flotante , Singleo Double es infinito positivo, infinito negativo o no un número (NaN), la cadena con formato es el valor de la propiedad respectiva PositiveInfinitySymbol, NegativeInfinitySymbolo NaNSymbol especificada por el objeto aplicable NumberFormatInfo 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 ), pero produciría resultados similares para cualquiera de los otros tipos base numéricos (Int32, Byte, SByteInt16Int32Int64UInt16UInt32UInt64BigInteger, y ). DecimalHalfSingle
// 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: {floating.ToString("C", ci)}"); // Displays "C: $10,761.94"
Console.WriteLine($"E: {floating.ToString("E03", ci)}"); // Displays "E: 1.076E+004"
Console.WriteLine($"F: {floating.ToString("F04", ci)}"); // Displays "F: 10761.9376"
Console.WriteLine($"G: {floating.ToString("G", ci)}"); // Displays "G: 10761.937554"
Console.WriteLine($"N: {floating.ToString("N03", ci)}"); // Displays "N: 10,761.938"
Console.WriteLine($"P: {(floating/10000).ToString("P02", ci)}"); // Displays "P: 107.62 %"
Console.WriteLine($"R: {floating.ToString("R", ci)}"); // Displays "R: 10761.937554"
Console.WriteLine();
// Output integral values
int integral = 8395;
Console.WriteLine($"C: {integral.ToString("C", ci)}"); // Displays "C: $8,395.00"
Console.WriteLine($"D: {integral.ToString("D6", ci)}"); // Displays "D: 008395"
Console.WriteLine($"E: {integral.ToString("E03", ci)}"); // Displays "E: 8.395E+003"
Console.WriteLine($"F: {integral.ToString("F01", ci)}"); // Displays "F: 8395.0"
Console.WriteLine($"G: {integral.ToString("G", ci)}"); // Displays "G: 8395"
Console.WriteLine($"N: {integral.ToString("N01", ci)}"); // Displays "N: 8,395.0"
Console.WriteLine($"P: {(integral/10000.0).ToString("P02", ci)}"); // Displays "P: 83.95 %"
Console.WriteLine($"X: 0x{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
Colaborar con nosotros en GitHub
El origen de este contenido se puede encontrar en GitHub, donde también puede crear y revisar problemas y solicitudes de incorporación de cambios. Para más información, consulte nuestra guía para colaboradores.
