Cadenas con formato numérico estándar

Las cadenas de formato numérico estándar se utilizan para dar formato a tipos numéricos comunes. Una cadena de formato numérico estándar presenta la forma Axx, donde A es un carácter alfabético que recibe el nombre de especificador de formato y xx es un entero opcional que recibe el nombre de especificador de precisión. El especificador de precisión está comprendido entre el 0 y el 99 y afecta al número de dígitos del resultado. Cualquier cadena de formato numérico que contenga más de un carácter alfabético, incluido el espacio en blanco, se interpreta como una cadena de formato numérico personalizado. Para obtener más información, vea Cadenas con formato numérico personalizado.

Algunas sobrecargas del método ToString de todos los tipos numéricos admiten las cadenas de formato numérico estándar. Por ejemplo, se puede proporcionar una cadena de formato numérico a los métodos ToString(String, IFormatProvider) y ToString(String) del tipo Int32. La característica de formato compuesto de .NET Framework, que utilizan algunos métodos Write y WriteLine de las clases Console y StreamWriter, el método String.Format y el método StringBuilder.AppendFormat, admite también cadenas de formato numérico estándar.

SugerenciaSugerencia

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

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

Especificador de formato

Nombre

Descripción

Ejemplos

"C" o "c"

Currency

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 System.Globalization.NumberFormatInfo.

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

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

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

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

1234 ("D") -> 1234

-1234 ("D6") -> -001234

"E" o "e"

Exponencial (científico)

Resultado: notación exponencial.

Compatible con: todos los tipos numéricos.

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

Especificador de precisión predeterminado: 6.

Más información: Especificador de formato exponencial ("E").

1052.0329112756 ("E", en-US) -> 1.052033E+003

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

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

-1052.0329112756 ("E2", fr_FR) -> -1,05E+003

"F" o "f"

Punto 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 System.Globalization.NumberFormatInfo.

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 System.Globalization.NumberFormatInfo.

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 ("N", en-US) -> 1,234.0

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

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

-1234.56 ("N", ru-RU) -> -1 234,560

"P" o "p"

Percent

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 System.Globalization.NumberFormatInfo.

Más información: Especificador de formato de porcentaje ("P").

1 ("P", en-US) -> 100.00 %

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

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

-0.39678 ("P1", fr-FR) -> -39,7 %

"R" o "r"

Acción de ida y vuelta

Resultado: cadena que puede aplicar acciones de ida y vuelta (round-trip) a un número idéntico.

Compatible con: Single, Double y BigInteger.

Especificador de precisión: se omite.

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

123456789.12345678 ("R") -> 123456789.12345678

-1234567890.12345678 ("R") -> -1234567890.1234567

"X" o "x"

Hexadecimal

Resultado: cadena hexadecimal.

Compatible con: solo tipos integrales.

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

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

255 ("X") -> FF

-1 ("x") -> ff

255 ("x4") -> 00ff

-1 ("X4") -> 00FF

Cualquier otro carácter único

Especificador desconocido

Resultado: Produce FormatException en tiempo de ejecución.

Usar cadenas de formato numérico estándar

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

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

    Dim value As Decimal = 123.456d
    Console.WriteLine(value.ToString("C2"))         
    ' Displays $123.46
    
    decimal value = 123.456m;
    Console.WriteLine(value.ToString("C2"));
    // Displays $123.46
    
  • Se puede proporcionar como el parámetro formatString en un elemento de formato usado con métodos como String.Format, Console.WriteLine y StringBuilder.AppendFormat. Para obtener más información, vea Formatos compuestos. En el ejemplo siguiente se usa un elemento de formato para insertar un valor de divisa en una cadena.

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

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

Especificador de formato de divisa ("C")

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

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

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

Propiedad de NumberFormatInfo

Descripción

CurrencyPositivePattern

Define la posición del símbolo de divisa para los valores positivos.

CurrencyNegativePattern

Define la posición del símbolo de divisa para los valores negativos y especifica si el signo negativo está representado por paréntesis o por la propiedad NegativeSign.

NegativeSign

Define el signo negativo usado si CurrencyNegativePattern indica que no se emplean paréntesis.

CurrencySymbol

Define el símbolo de divisa.

CurrencyDecimalDigits

Define el número predeterminado de dígitos decimales en un valor de divisa. Este valor puede reemplazarse por el uso del especificador de precisión.

CurrencyDecimalSeparator

Define la cadena que separa los dígitos integrales y decimales.

CurrencyGroupSeparator

Define la cadena que separa los grupos de números integrales.

CurrencyGroupSizes

Define el número de dígitos enteros que aparecen en un grupo.

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

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
double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));

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

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

Volver a la tabla

Especificador de formato decimal ("D")

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

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

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

Propiedad de NumberFormatInfo

Descripción

NegativeSign

Define la cadena que indica que un número es negativo.

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

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
int value; 

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

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

Volver a la tabla

Especificador de formato exponencial ("E")

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

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

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

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

Propiedad de NumberFormatInfo

Descripción

NegativeSign

Define la cadena que indica que un número es negativo tanto para el coeficiente como para el exponente.

NumberDecimalSeparator

Define la cadena que separa el dígito integral de los dígitos decimales en el coeficiente.

PositiveSign

Define la cadena que indica que un exponente es positivo.

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

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
double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004

Console.WriteLine(value.ToString("E", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004

Volver a la tabla

Especificador de formato de punto fijo ("F")

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

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

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

Propiedad de NumberFormatInfo

Descripción

NegativeSign

Define la cadena que indica que un número es negativo.

NumberDecimalSeparator

Define la cadena que separa los dígitos integrales de los decimales.

NumberDecimalDigits

Define el número predeterminado de dígitos decimales. Este valor puede reemplazarse por el uso del especificador de precisión.

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

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                        
int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F", 
                  CultureInfo.InvariantCulture));
// Displays 17843.00

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

double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));  
// Displays -1898300.2

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

Volver a la tabla

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

29 dígitos

Single

7 dígitos

Double

15 dígitos

Decimal

29 dígitos

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

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

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

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

Propiedad de NumberFormatInfo

Descripción

NegativeSign

Define la cadena que indica que un número es negativo.

NumberDecimalSeparator

Define la cadena que separa los dígitos integrales de los decimales.

NumberDecimalDigits

Define el número predeterminado de dígitos decimales. Este valor puede reemplazarse por el uso del especificador de precisión.

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.

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    
double number;

number = 12345.6789;      
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays  12345.6789
Console.WriteLine(number.ToString("G", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
// Displays 12345.68 

number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 2.3E-06       
Console.WriteLine(number.ToString("G", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 0.0023

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

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

Volver a la tabla

Especificador de formato numérico ("N")

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

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

Propiedad de NumberFormatInfo

Descripción

NegativeSign

Define la cadena que indica que un número es negativo.

NumberNegativePattern

Define el formato de los valores negativos y especifica si el signo negativo se representa mediante paréntesis o por la propiedad NegativeSign.

NumberGroupSizes

Define el número de dígitos enteros que aparecen entre los separadores de grupos.

NumberGroupSeparator

Define la cadena que separa los grupos de números integrales.

NumberDecimalSeparator

Define la cadena que separa los dígitos integrales y decimales.

NumberDecimalDigits

Define el número predeterminado de dígitos decimales. Este valor puede reemplazarse por el uso de un especificador de precisión.

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

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 
double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", 
                  CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0 

Volver a la tabla

Especificador de formato de porcentaje ("P")

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

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

Propiedad de NumberFormatInfo

Descripción

PercentPositivePattern

Define la posición del símbolo de porcentaje para los valores positivos.

PercentNegativePattern

Define la posición del símbolo de porcentaje y del símbolo negativo para los valores negativos.

NegativeSign

Define la cadena que indica que un número es negativo.

PercentSymbol

Define el símbolo de porcentaje.

PercentDecimalDigits

Define el número predeterminado de dígitos decimales en un valor de porcentaje. Este valor puede reemplazarse por el uso del especificador de precisión.

PercentDecimalSeparator

Define la cadena que separa los dígitos integrales y decimales.

PercentGroupSeparator

Define la cadena que separa los grupos de números integrales.

PercentGroupSizes

Define el número de dígitos enteros que aparecen en un grupo.

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

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

Volver a la tabla

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

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

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

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

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

Propiedad de NumberFormatInfo

Descripción

NegativeSign

Define la cadena que indica que un número es negativo.

NumberDecimalSeparator

Define la cadena que separa los dígitos integrales de los decimales.

PositiveSign

Define la cadena que indica que un exponente es positivo.

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

Dim value As Double

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

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

Volver a la tabla

Especificador de formato hexadecimal ("X")

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

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

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

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

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
int value; 

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

value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15

Volver a la tabla

Notas

Configuración del Panel de control

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

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

Propiedades NumberFormatInfo

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

Tipos numéricos enteros y de punto flotante

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

Infinitos de punto flotante y NaN

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

Ejemplo

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

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
using System;
using System.Globalization;
using System.Threading;

public class NumericFormats
{
   public static void Main()
   {
      // Display string representations of numbers for en-us culture
      CultureInfo ci = new CultureInfo("en-us");

      // Output floating point values
      double floating = 10761.937554;
      Console.WriteLine("C: {0}", 
              floating.ToString("C", ci));           // Displays "C: $10,761.94"
      Console.WriteLine("E: {0}", 
              floating.ToString("E03", ci));         // Displays "E: 1.076E+004"
      Console.WriteLine("F: {0}", 
              floating.ToString("F04", ci));         // Displays "F: 10761.9376"         
      Console.WriteLine("G: {0}",  
              floating.ToString("G", ci));           // Displays "G: 10761.937554"
      Console.WriteLine("N: {0}", 
              floating.ToString("N03", ci));         // Displays "N: 10,761.938"
      Console.WriteLine("P: {0}", 
              (floating/10000).ToString("P02", ci)); // Displays "P: 107.62 %"
      Console.WriteLine("R: {0}", 
              floating.ToString("R", ci));           // Displays "R: 10761.937554"            
      Console.WriteLine();

      // Output integral values
      int integral = 8395;
      Console.WriteLine("C: {0}", 
              integral.ToString("C", ci));           // Displays "C: $8,395.00"
      Console.WriteLine("D: {0}", 
              integral.ToString("D6", ci));          // Displays "D: 008395" 
      Console.WriteLine("E: {0}", 
              integral.ToString("E03", ci));         // Displays "E: 8.395E+003"
      Console.WriteLine("F: {0}", 
              integral.ToString("F01", ci));         // Displays "F: 8395.0"    
      Console.WriteLine("G: {0}",  
              integral.ToString("G", ci));           // Displays "G: 8395"
      Console.WriteLine("N: {0}", 
              integral.ToString("N01", ci));         // Displays "N: 8,395.0"
      Console.WriteLine("P: {0}", 
              (integral/10000.0).ToString("P02", ci)); // Displays "P: 83.95 %"
      Console.WriteLine("X: 0x{0}", 
              integral.ToString("X", ci));           // Displays "X: 0x20CB"
      Console.WriteLine();
   }
}

Vea también

Tareas

Cómo: Rellenar un número con ceros iniciales

Referencia

NumberFormatInfo

Conceptos

Cadenas con formato numérico personalizado

Aplicar formato a tipos

Historial de cambios

Fecha

Historial

Motivo

Marzo de 2011

Agregado un vínculo a la utilidad de formato.

Mejora de la información.

Julio de 2010

Se ha indicado que con la cadena de formato estándar "C" se usa el redondeo desde cero.

Comentarios de los clientes.