Aplicar formato a tipos de .NETFormatting Types in .NET

Aplicar formato es el proceso de convertir una instancia de una clase, una estructura o un valor de enumeración en su representación de cadena, a menudo para que la cadena resultante se pueda mostrar a los usuarios o deserializar para restaurar el tipo de datos original.Formatting is the process of converting an instance of a class, structure, or enumeration value to its string representation, often so that the resulting string can be displayed to users or deserialized to restore the original data type. Esta conversión puede plantear varios desafíos:This conversion can pose a number of challenges:

  • La forma en que se almacenan internamente los valores no refleja necesariamente la manera en que los usuarios desean verlos.The way that values are stored internally does not necessarily reflect the way that users want to view them. Por ejemplo, un número de teléfono podría almacenarse con el formato 8009999999, que no es fácil de usar.For example, a telephone number might be stored in the form 8009999999, which is not user-friendly. Se debería mostrar en su lugar como 800-999-9999.It should instead be displayed as 800-999-9999. Consulte la sección Cadenas de formato personalizado para obtener un ejemplo en el que da formato a un número de esta forma.See the Custom Format Strings section for an example that formats a number in this way.

  • A veces, la conversión de un objeto en su representación de cadena no es intuitiva.Sometimes the conversion of an object to its string representation is not intuitive. Por ejemplo, no está claro cómo debe aparecer la representación de cadena de un objeto Temperature o un objeto Person.For example, it is not clear how the string representation of a Temperature object or a Person object should appear. Para obtener un ejemplo en el que se da formato a un objeto Temperature de varias formas, consulte la sección Cadenas de formato estándar .For an example that formats a Temperature object in a variety of ways, see the Standard Format Strings section.

  • A menudo, los valores requieren un formato dependiente de la referencia cultural.Values often require culture-sensitive formatting. Por ejemplo, en una aplicación en la que se usan números para reflejar los valores monetarios, las cadenas numéricas deben incluir el símbolo de divisa, el separador de grupo (que en la mayoría de las referencias culturales es el separador de miles) y el símbolo decimal correspondientes a la referencia cultural actual.For example, in an application that uses numbers to reflect monetary values, numeric strings should include the current culture’s currency symbol, group separator (which, in most cultures, is the thousands separator), and decimal symbol. Para ver un ejemplo, consulte la sección Formato que tiene en cuenta las referencias culturales con proveedores de formato y la interfaz IFormatProvider .For an example, see the Culture-Sensitive Formatting with Format Providers and the IFormatProvider Interface section.

  • Puede que una aplicación muestre el mismo valor de diferentes maneras.An application may have to display the same value in different ways. Por ejemplo, es posible que una aplicación represente un miembro de enumeración mostrando una representación de cadena de su nombre o mostrando su valor subyacente.For example, an application may represent an enumeration member by displaying a string representation of its name or by displaying its underlying value. Para obtener un ejemplo en el que se da formato a un miembro de la enumeración DayOfWeek de maneras diferentes, consulte la sección Cadenas de formato estándar .For an example that formats a member of the DayOfWeek enumeration in different ways, see the Standard Format Strings section.

Nota

La aplicación de formato convierte el valor de un tipo en una representación de cadena.Formatting converts the value of a type into a string representation. El análisis es lo contrario que la aplicación de formato.Parsing is the inverse of formatting. Una operación de análisis crea una instancia de un tipo de datos a partir de su representación de cadena.A parsing operation creates an instance of a data type from its string representation. Para información sobre cómo convertir cadenas en otros tipos de datos, vea Parsing Strings.For information about converting strings to other data types, see Parsing Strings.

.NET proporciona compatibilidad de formato enriquecida que permite a los desarrolladores hacer frente a estos requisitos..NET provides rich formatting support that enables developers to address these requirements.

Esta información general contiene las siguientes secciones:This overview contains the following sections:

Formato en .NETFormatting in .NET

El mecanismo básico para dar formato es la implementación predeterminada de la Object.ToString método, que se describe en el formato mediante el método ToString predeterminado sección más adelante en este tema.The basic mechanism for formatting is the default implementation of the Object.ToString method, which is discussed in the Default Formatting Using the ToString Method section later in this topic. Pero .NET proporciona varias formas de modificar y extender su compatibilidad de formato predeterminado.However, .NET provides several ways to modify and extend its default formatting support. Entre ellas se incluyen las siguientes:These include the following:

  • Invalidar el método Object.ToString para definir una representación de cadena personalizada del valor de un objeto.Overriding the Object.ToString method to define a custom string representation of an object’s value. Para obtener más información, vea la sección Invalidación del método ToString más adelante en este tema.For more information, see the Overriding the ToString Method section later in this topic.

  • Definir especificadores de formato que permitan que la representación de cadena del valor de un objeto adopte varios formatos.Defining format specifiers that enable the string representation of an object’s value to take multiple forms. Por ejemplo, el especificador de formato "X" en la siguiente instrucción convierte un entero en la representación de cadena de un valor hexadecimal.For example, the "X" format specifier in the following statement converts an integer to the string representation of a hexadecimal value.

    int integerValue = 60312;
    Console.WriteLine(integerValue.ToString("X"));   // Displays EB98.
    
    Dim integerValue As Integer = 60312
    Console.WriteLine(integerValue.ToString("X"))   ' Displays EB98.
    

    Para obtener más información sobre los especificadores de formato, vea la sección Método ToString y cadenas de formato .For more information about format specifiers, see the ToString Method and Format Strings section.

  • Usar proveedores de formato para aprovechar las convenciones de formato de una referencia cultural concreta.Using format providers to take advantage of the formatting conventions of a specific culture. Por ejemplo, la instrucción siguiente muestra un valor de divisa usando las convenciones de formato de la referencia cultural en-US.For example, the following statement displays a currency value by using the formatting conventions of the en-US culture.

    double cost = 1632.54; 
    Console.WriteLine(cost.ToString("C", 
                      new System.Globalization.CultureInfo("en-US")));   
    // The example displays the following output:
    //       $1,632.54
    
    Dim cost As Double = 1632.54
    Console.WriteLine(cost.ToString("C", New System.Globalization.CultureInfo("en-US")))
    ' The example displays the following output:
    '       $1,632.54
    

    Para obtener más información sobre cómo aplicar formato con proveedores de formato, vea la sección Proveedores de formato y la interfaz IFormatProvider .For more information about formatting with format providers, see the Format Providers and the IFormatProvider Interface section.

  • Implementar la interfaz IFormattable para admitir tanto la conversión de cadenas con la clase Convert como formatos compuestos.Implementing the IFormattable interface to support both string conversion with the Convert class and composite formatting. Para obtener más información, vea la sección Interfaz IFormattable .For more information, see the IFormattable Interface section.

  • Usar formatos compuestos para incrustar la representación de cadena de un valor en una cadena más larga.Using composite formatting to embed the string representation of a value in a larger string. Para obtener más información, vea la sección Formatos compuestos .For more information, see the Composite Formatting section.

  • Implementar ICustomFormatter y IFormatProvider para proporcionar una solución de formato personalizado completa.Implementing ICustomFormatter and IFormatProvider to provide a complete custom formatting solution. Para obtener más información, vea la sección Formato personalizado con ICustomFormatter .For more information, see the Custom Formatting with ICustomFormatter section.

En las secciones siguientes se examinan estos métodos para convertir un objeto en su representación de cadena.The following sections examine these methods for converting an object to its string representation.

Volver al principioBack to top

Formato predeterminado mediante el método ToStringDefault Formatting Using the ToString Method

Cada tipo derivado de System.Object hereda automáticamente un método ToString sin parámetros, que devuelve el nombre del tipo de forma predeterminada.Every type that is derived from System.Object automatically inherits a parameterless ToString method, which returns the name of the type by default. En el ejemplo siguiente se ilustra el método ToString predeterminado.The following example illustrates the default ToString method. Se define una clase denominada Automobile que no tiene ninguna implementación.It defines a class named Automobile that has no implementation. Cuando se crea una instancia de la clase y se llama a su método ToString , se muestra el nombre de su tipo.When the class is instantiated and its ToString method is called, it displays its type name. Observe que en el ejemplo no se llama explícitamente al método ToString .Note that the ToString method is not explicitly called in the example. El método Console.WriteLine(Object) llama implícitamente al método ToString del objeto pasado como argumento.The Console.WriteLine(Object) method implicitly calls the ToString method of the object passed to it as an argument.

using System;

public class Automobile
{
   // No implementation. All members are inherited from Object.
}

public class Example
{
   public static void Main()
   {
      Automobile firstAuto = new Automobile();
      Console.WriteLine(firstAuto);
   }
}
// The example displays the following output:
//       Automobile
Public Class Automobile
   ' No implementation. All members are inherited from Object.
End Class

Module Example
   Public Sub Main()
      Dim firstAuto As New Automobile()
      Console.WriteLine(firstAuto)
   End Sub
End Module
' The example displays the following output:
'       Automobile

Advertencia

A partir de Windows 8.1Windows 8.1, Windows en tiempo de ejecuciónWindows Runtime incluye una interfaz IStringable con un solo método, IStringable.ToString, que ofrece compatibilidad con el formato predeterminado.Starting with Windows 8.1Windows 8.1, the Windows en tiempo de ejecuciónWindows Runtime includes an IStringable interface with a single method, IStringable.ToString, which provides default formatting support. Sin embargo, es recomendable que los tipos administrados no implementen la interfaz IStringable .However, we recommend that managed types do not implement the IStringable interface. Para obtener más información, consulte la sección “Windows en tiempo de ejecuciónWindows Runtime y la interfaz IStringable” en la página de referencia de Object.ToString.For more information, see "The Windows en tiempo de ejecuciónWindows Runtime and the IStringable Interface" section on the Object.ToString reference page.

Puesto que todos los tipos distintos de las interfaces se derivan de Object, esta funcionalidad se proporciona automáticamente a sus clases o estructuras personalizadas.Because all types other than interfaces are derived from Object, this functionality is automatically provided to your custom classes or structures. Sin embargo, la funcionalidad proporcionada por el método ToString predeterminado es limitada: aunque identifica el tipo, no proporciona ninguna información sobre una instancia del tipo.However, the functionality offered by the default ToString method, is limited: Although it identifies the type, it fails to provide any information about an instance of the type. Para proporcionar una representación de cadena de un objeto que proporciona información sobre ese objeto, debe invalidar el método ToString .To provide a string representation of an object that provides information about that object, you must override the ToString method.

Nota

Las estructuras heredan de ValueType, que a su vez se deriva de Object.Structures inherit from ValueType, which in turn is derived from Object. Aunque ValueType invalida Object.ToString, su implementación es idéntica.Although ValueType overrides Object.ToString, its implementation is identical.

Volver al principioBack to top

Invalidación del método ToStringOverriding the ToString Method

La presentación del nombre de un tipo suele tener un uso limitado y no permite a los consumidores de sus tipos diferenciar una instancia de otra.Displaying the name of a type is often of limited use and does not allow consumers of your types to differentiate one instance from another. Sin embargo, puede invalidar el método ToString para proporcionar una representación más útil del valor de un objeto.However, you can override the ToString method to provide a more useful representation of an object’s value. En el ejemplo siguiente se define un objeto Temperature y se invalida su método ToString para mostrar la temperatura en grados centígrados.The following example defines a Temperature object and overrides its ToString method to display the temperature in degrees Celsius.

using System;

public class Temperature
{
   private decimal temp;
   
   public Temperature(decimal temperature)
   {
      this.temp = temperature;   
   }

   public override string ToString()
   {
      return this.temp.ToString("N1") + "°C";
   }
}

public class Example
{
   public static void Main()
   {
      Temperature currentTemperature = new Temperature(23.6m);
      Console.WriteLine("The current temperature is " +
                        currentTemperature.ToString());
   }
}
// The example displays the following output:
//       The current temperature is 23.6°C.
Public Class Temperature
   Private temp As Decimal
   
   Public Sub New(temperature As Decimal)
      Me.temp = temperature
   End Sub
   
   Public Overrides Function ToString() As String
      Return Me.temp.ToString("N1") + "°C"   
   End Function
End Class

Module Example
   Public Sub Main()
      Dim currentTemperature As New Temperature(23.6d)
      Console.WriteLine("The current temperature is " +
                        currentTemperature.ToString())
   End Sub
End Module
' The example displays the following output:
'       The current temperature is 23.6°C.

En. NET, la ToString método de cada tipo de valor primitivo se ha invalidado para mostrar el valor del objeto en lugar de su nombre.In .NET, the ToString method of each primitive value type has been overridden to display the object’s value instead of its name. En la tabla siguiente se muestra la invalidación para cada tipo primitivo.The following table shows the override for each primitive type. Observe que la mayoría de los métodos invalidados llaman a otra sobrecarga del método ToString y le pasan el especificador de formato "G", que define el formato general de su tipo, y un objeto IFormatProvider que representa la referencia cultural actual.Note that most of the overridden methods call another overload of the ToString method and pass it the "G" format specifier, which defines the general format for its type, and an IFormatProvider object that represents the current culture.

TipoType Invalidación de ToStringToString override
Boolean Devuelve Boolean.TrueString o Boolean.FalseString.Returns either Boolean.TrueString or Boolean.FalseString.
Byte Llama a Byte.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo Byte correspondiente a la referencia cultural actual.Calls Byte.ToString("G", NumberFormatInfo.CurrentInfo) to format the Byte value for the current culture.
Char Devuelve el carácter como una cadena.Returns the character as a string.
DateTime Llama a DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) para dar formato al valor de fecha y hora correspondiente a la referencia cultural actual.Calls DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) to format the date and time value for the current culture.
Decimal Llama a Decimal.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo Decimal correspondiente a la referencia cultural actual.Calls Decimal.ToString("G", NumberFormatInfo.CurrentInfo) to format the Decimal value for the current culture.
Double Llama a Double.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo Double correspondiente a la referencia cultural actual.Calls Double.ToString("G", NumberFormatInfo.CurrentInfo) to format the Double value for the current culture.
Int16 Llama a Int16.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo Int16 correspondiente a la referencia cultural actual.Calls Int16.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int16 value for the current culture.
Int32 Llama a Int32.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo Int32 correspondiente a la referencia cultural actual.Calls Int32.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int32 value for the current culture.
Int64 Llama a Int64.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo Int64 correspondiente a la referencia cultural actual.Calls Int64.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int64 value for the current culture.
SByte Llama a SByte.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo SByte correspondiente a la referencia cultural actual.Calls SByte.ToString("G", NumberFormatInfo.CurrentInfo) to format the SByte value for the current culture.
Single Llama a Single.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo Single correspondiente a la referencia cultural actual.Calls Single.ToString("G", NumberFormatInfo.CurrentInfo) to format the Single value for the current culture.
UInt16 Llama a UInt16.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo UInt16 correspondiente a la referencia cultural actual.Calls UInt16.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt16 value for the current culture.
UInt32 Llama a UInt32.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo UInt32 correspondiente a la referencia cultural actual.Calls UInt32.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt32 value for the current culture.
UInt64 Llama a UInt64.ToString("G", NumberFormatInfo.CurrentInfo) para dar formato al valor de tipo UInt64 correspondiente a la referencia cultural actual.Calls UInt64.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt64 value for the current culture.

Volver al principioBack to top

Método ToString y cadenas de formatoThe ToString Method and Format Strings

Recurrir al método ToString predeterminado o invalidar ToString resulta apropiado cuando un objeto tiene una única representación de cadena.Relying on the default ToString method or overriding ToString is appropriate when an object has a single string representation. Sin embargo, el valor de un objeto tiene a menudo varias representaciones.However, the value of an object often has multiple representations. Por ejemplo, una temperatura puede expresarse en grados Fahrenheit, grados centígrados o grados Kelvin.For example, a temperature can be expressed in degrees Fahrenheit, degrees Celsius, or kelvins. De manera similar, el valor entero 10 puede representarse de numerosas maneras; por ejemplo, 10, 10,0, 1,0e01 o $10,00.Similarly, the integer value 10 can be represented in numerous ways, including 10, 10.0, 1.0e01, or $10.00.

Para que un valor pueda tener varias representaciones de cadena, .NET usa cadenas de formato.To enable a single value to have multiple string representations, .NET uses format strings. Una cadena de formato es una cadena que contiene uno o varios especificadores de formato predefinidos, que son caracteres individuales o grupos de caracteres que definen cómo el método ToString debe dar formato a su salida.A format string is a string that contains one or more predefined format specifiers, which are single characters or groups of characters that define how the ToString method should format its output. A continuación, se pasa la cadena de formato como un parámetro al método ToString del objeto, por lo que determina cómo debe mostrarse la representación de cadena del valor de ese objeto.The format string is then passed as a parameter to the object's ToString method and determines how the string representation of that object's value should appear.

Todos los tipos numéricos, de fecha y hora, y de enumeración de .NET admiten un conjunto predefinido de especificadores de formato.All numeric types, date and time types, and enumeration types in .NET support a predefined set of format specifiers. Las cadenas de formato también se pueden emplear para definir varias representaciones de cadena de los tipos de datos definidos por una aplicación.You can also use format strings to define multiple string representations of your application-defined data types.

Cadenas de formato estándarStandard Format Strings

Una cadena de formato estándar contiene un único especificador de formato, que es un carácter alfabético que define la representación de cadena del objeto al que se aplica, junto con un especificador de precisión opcional que afecta a cuántos dígitos se muestran en la cadena de resultado.A standard format string contains a single format specifier, which is an alphabetic character that defines the string representation of the object to which it is applied, along with an optional precision specifier that affects how many digits are displayed in the result string. Si el especificador de precisión se omite o no se admite, un especificador de formato estándar es equivalente a una cadena de formato estándar.If the precision specifier is omitted or is not supported, a standard format specifier is equivalent to a standard format string.

.NET define un conjunto de especificadores de formato estándar para todos los tipos numéricos, de fecha y hora, y de enumeración..NET defines a set of standard format specifiers for all numeric types, all date and time types, and all enumeration types. Por ejemplo, cada una de estas categorías admite un especificador de formato estándar "G", que define una representación de cadena general de un valor de ese tipo.For example, each of these categories supports a "G" standard format specifier, which defines a general string representation of a value of that type.

Las cadenas de formato estándar para los tipos de enumeración controlan directamente la representación de cadena de un valor.Standard format strings for enumeration types directly control the string representation of a value. Las cadenas de formato que se pasan al método ToString de un valor de enumeración determinan si el valor se muestra con su nombre de cadena (especificadores de formato "G" y "F"), su valor integral subyacente (especificador de formato "D") o su valor hexadecimal (especificador de formato "X").The format strings passed to an enumeration value’s ToString method determine whether the value is displayed using its string name (the "G" and "F" format specifiers), its underlying integral value (the "D" format specifier), or its hexadecimal value (the "X" format specifier). En el ejemplo siguiente se muestra el uso de cadenas de formato estándar para dar formato a un valor de enumeración DayOfWeek .The following example illustrates the use of standard format strings to format a DayOfWeek enumeration value.

DayOfWeek thisDay = DayOfWeek.Monday;
string[] formatStrings = {"G", "F", "D", "X"};

foreach (string formatString in formatStrings)
   Console.WriteLine(thisDay.ToString(formatString));
// The example displays the following output:
//       Monday
//       Monday
//       1
//       00000001
Dim thisDay As DayOfWeek = DayOfWeek.Monday
Dim formatStrings() As String = {"G", "F", "D", "X"}

For Each formatString As String In formatStrings
   Console.WriteLine(thisDay.ToString(formatString))
Next
' The example displays the following output:
'       Monday
'       Monday
'       1
'       00000001

Para información sobre las cadenas de formato de enumeración, vea Enumeration Format Strings.For information about enumeration format strings, see Enumeration Format Strings.

Las cadenas de formato estándar para tipos numéricos normalmente definen una cadena de resultado cuya apariencia exacta está controlada por uno o más valores de propiedad.Standard format strings for numeric types usually define a result string whose precise appearance is controlled by one or more property values. Por ejemplo, el especificador de formato "C" da formato a un número como un valor de divisa.For example, the "C" format specifier formats a number as a currency value. Al llamar al método ToString con el especificador de formato "C" como único parámetro, se usan los siguientes valores de propiedad del objeto NumberFormatInfo de la referencia cultural actual para definir la representación de cadena del valor numérico:When you call the ToString method with the "C" format specifier as the only parameter, the following property values from the current culture’s NumberFormatInfo object are used to define the string representation of the numeric value:

  • La propiedad CurrencySymbol , que especifica el símbolo de divisa de la referencia cultural actual.The CurrencySymbol property, which specifies the current culture’s currency symbol.

  • La propiedad CurrencyNegativePattern o CurrencyPositivePattern , que devuelve un entero que determina lo siguiente:The CurrencyNegativePattern or CurrencyPositivePattern property, which returns an integer that determines the following:

    • La posición del símbolo de divisa.The placement of the currency symbol.

    • Si los valores negativos se indican mediante un signo negativo inicial, un signo negativo final o paréntesis.Whether negative values are indicated by a leading negative sign, a trailing negative sign, or parentheses.

    • Si aparece un espacio entre el valor numérico y el símbolo de divisa.Whether a space appears between the numeric value and the currency symbol.

  • La propiedad CurrencyDecimalDigits , que define el número de dígitos fraccionarios en la cadena de resultado.The CurrencyDecimalDigits property, which defines the number of fractional digits in the result string.

  • La propiedad CurrencyDecimalSeparator , que define el símbolo del separador decimal en la cadena de resultado.The CurrencyDecimalSeparator property, which defines the decimal separator symbol in the result string.

  • La propiedad CurrencyGroupSeparator , que define el símbolo del separador de grupo.The CurrencyGroupSeparator property, which defines the group separator symbol.

  • La propiedad CurrencyGroupSizes , que define el número de dígitos de cada grupo que hay a la izquierda del decimal.The CurrencyGroupSizes property, which defines the number of digits in each group to the left of the decimal.

  • La propiedad NegativeSign , que determina el signo negativo usado en la cadena de resultado si no se emplean paréntesis para indicar valores negativos.The NegativeSign property, which determines the negative sign used in the result string if parentheses are not used to indicate negative values.

Además, las cadenas de formato numérico pueden incluir un especificador de precisión.In addition, numeric format strings may include a precision specifier. El significado de este especificador depende de la cadena de formato con la que se usa, pero suele indicar el número total de dígitos o el número de dígitos fraccionarios que deben aparecer en la cadena de resultado.The meaning of this specifier depends on the format string with which it is used, but it typically indicates either the total number of digits or the number of fractional digits that should appear in the result string. Por ejemplo, en el ejemplo siguiente se usa la cadena numérica estándar "X4" y un especificador de precisión para crear un valor de cadena que tiene cuatro dígitos hexadecimales.For example, the following example uses the "X4" standard numeric string and a precision specifier to create a string value that has four hexadecimal digits.

byte[] byteValues = { 12, 163, 255 };
foreach (byte byteValue in byteValues)
   Console.WriteLine(byteValue.ToString("X4"));
// The example displays the following output:
//       000C
//       00A3
//       00FF
Dim byteValues() As Byte = { 12, 163, 255 }
For Each byteValue As Byte In byteValues
   Console.WriteLine(byteValue.ToString("X4"))
Next
' The example displays the following output:
'       000C
'       00A3
'       00FF

Para más información sobre las cadenas de formato numérico estándar, vea Standard Numeric Format Strings.For more information about standard numeric formatting strings, see Standard Numeric Format Strings.

Las cadenas de formato estándar para valores de fecha y hora son alias de las cadenas de formato personalizado almacenadas por una propiedad DateTimeFormatInfo determinada.Standard format strings for date and time values are aliases for custom format strings stored by a particular DateTimeFormatInfo property. Por ejemplo, al llamar al método ToString de un valor de fecha y hora con el especificador de formato "D" se muestran la fecha y la hora usando la cadena de formato personalizado que está almacenada en la propiedad DateTimeFormatInfo.LongDatePattern de la referencia cultural actual.For example, calling the ToString method of a date and time value with the "D" format specifier displays the date and time by using the custom format string stored in the current culture’s DateTimeFormatInfo.LongDatePattern property. (Para obtener más información acerca de las cadenas de formato personalizado, vea la próxima sección.) En el ejemplo siguiente se ilustra esta relación.(For more information about custom format strings, see the next section.) The following example illustrates this relationship.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2009, 6, 30);
      Console.WriteLine("D Format Specifier:     {0:D}", date1);
      string longPattern = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern;
      Console.WriteLine("'{0}' custom format string:     {1}", 
                        longPattern, date1.ToString(longPattern));
   }
}
// The example displays the following output when run on a system whose
// current culture is en-US:
//    D Format Specifier:     Tuesday, June 30, 2009
//    'dddd, MMMM dd, yyyy' custom format string:     Tuesday, June 30, 2009
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim date1 As Date = #6/30/2009#
      Console.WriteLine("D Format Specifier:     {0:D}", date1)
      Dim longPattern As String = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern
      Console.WriteLine("'{0}' custom format string:     {1}", _
                        longPattern, date1.ToString(longPattern))
   End Sub
End Module
' The example displays the following output when run on a system whose
' current culture is en-US:
'    D Format Specifier:     Tuesday, June 30, 2009
'    'dddd, MMMM dd, yyyy' custom format string:     Tuesday, June 30, 2009

Para obtener más información acerca de las cadenas de formato de fecha y hora estándar, consulte Cadenas de formato de fecha y hora estándar.For more information about standard date and time format strings, see Standard Date and Time Format Strings.

También se pueden emplear las cadenas de formato estándar para definir la representación de cadena de un objeto definido por la aplicación generado por el método ToString(String) del objeto.You can also use standard format strings to define the string representation of an application-defined object that is produced by the object’s ToString(String) method. Puede definir los especificadores de formato estándar concretos que su objeto admite y determinar si distinguen entre mayúsculas y minúsculas o no.You can define the specific standard format specifiers that your object supports, and you can determine whether they are case-sensitive or case-insensitive. Su implementación del método ToString(String) debe aceptar lo siguiente:Your implementation of the ToString(String) method should support the following:

  • Un especificador de formato "G" que representa un formato personalizado o común del objeto.A "G" format specifier that represents a customary or common format of the object. La sobrecarga sin parámetros del método ToString del objeto debe llamar a su sobrecarga de ToString(String) y pasarle la cadena de formato estándar "G".The parameterless overload of your object's ToString method should call its ToString(String) overload and pass it the "G" standard format string.

  • Compatibilidad con un especificador de formato que sea igual a una referencia nula (Nothing en Visual Basic).Support for a format specifier that is equal to a null reference (Nothing in Visual Basic). Un especificador de formato que es igual a una referencia nula debe considerarse equivalente al especificador de formato "G".A format specifier that is equal to a null reference should be considered equivalent to the "G" format specifier.

Por ejemplo, una clase Temperature puede almacenar internamente la temperatura en grados centígrados y usar especificadores de formato para representar el valor del objeto Temperature en grados centígrados, grados Fahrenheit y grados Kelvin.For example, a Temperature class can internally store the temperature in degrees Celsius and use format specifiers to represent the value of the Temperature object in degrees Celsius, degrees Fahrenheit, and kelvins. Esto se muestra en el ejemplo siguiente.The following example provides an illustration.

using System;

public class Temperature
{
   private decimal m_Temp;
   
   public Temperature(decimal temperature)
   {
      this.m_Temp = temperature;
   }
   
   public decimal Celsius
   {
      get { return this.m_Temp; }
   }
   
   public decimal Kelvin
   {
      get { return this.m_Temp + 273.15m; }   
   }
   
   public decimal Fahrenheit
   {
      get { return Math.Round(((decimal) (this.m_Temp * 9 / 5 + 32)), 2); }
   }

   public override string ToString()
   {
      return this.ToString("C");
   }
   
   public string ToString(string format)
   {  
      // Handle null or empty string.
      if (String.IsNullOrEmpty(format)) format = "C";
      // Remove spaces and convert to uppercase.
      format = format.Trim().ToUpperInvariant();      
      
      // Convert temperature to Fahrenheit and return string.
      switch (format)
      {
         // Convert temperature to Fahrenheit and return string.
         case "F":
            return this.Fahrenheit.ToString("N2") + " °F";
         // Convert temperature to Kelvin and return string.
         case "K":
            return this.Kelvin.ToString("N2") + " K";
         // return temperature in Celsius.
         case "G":
         case "C":
            return this.Celsius.ToString("N2") + " °C";
         default:
            throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
      }      
   }
}

public class Example
{
   public static void Main()
   {
      Temperature temp1 = new Temperature(0m);
      Console.WriteLine(temp1.ToString());
      Console.WriteLine(temp1.ToString("G"));
      Console.WriteLine(temp1.ToString("C"));
      Console.WriteLine(temp1.ToString("F"));
      Console.WriteLine(temp1.ToString("K"));

      Temperature temp2 = new Temperature(-40m);
      Console.WriteLine(temp2.ToString());
      Console.WriteLine(temp2.ToString("G"));
      Console.WriteLine(temp2.ToString("C"));
      Console.WriteLine(temp2.ToString("F"));
      Console.WriteLine(temp2.ToString("K"));

      Temperature temp3 = new Temperature(16m);
      Console.WriteLine(temp3.ToString());
      Console.WriteLine(temp3.ToString("G"));
      Console.WriteLine(temp3.ToString("C"));
      Console.WriteLine(temp3.ToString("F"));
      Console.WriteLine(temp3.ToString("K"));
      
      Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3));
   }
}
// The example displays the following output:
//       0.00 °C
//       0.00 °C
//       0.00 °C
//       32.00 °F
//       273.15 K
//       -40.00 °C
//       -40.00 °C
//       -40.00 °C
//       -40.00 °F
//       233.15 K
//       16.00 °C
//       16.00 °C
//       16.00 °C
//       60.80 °F
//       289.15 K
//       The temperature is now 16.00 °C.
Public Class Temperature
   Private m_Temp As Decimal
   
   Public Sub New(temperature As Decimal)
      Me.m_Temp = temperature
   End Sub
   
   Public ReadOnly Property Celsius() As Decimal
      Get
         Return Me.m_Temp
      End Get   
   End Property
   
   Public ReadOnly Property Kelvin() As Decimal
      Get
         Return Me.m_Temp + 273.15d   
      End Get
   End Property
   
   Public ReadOnly Property Fahrenheit() As Decimal
      Get
         Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
      End Get      
   End Property

   Public Overrides Function ToString() As String
      Return Me.ToString("C")
   End Function
   
   Public Overloads Function ToString(format As String) As String  
      ' Handle null or empty string.
      If String.IsNullOrEmpty(format) Then format = "C"
      ' Remove spaces and convert to uppercase.
      format = format.Trim().ToUpperInvariant()      
      
      Select Case format
         Case "F"
           ' Convert temperature to Fahrenheit and return string.
            Return Me.Fahrenheit.ToString("N2") & " °F"
         Case "K"
            ' Convert temperature to Kelvin and return string.
            Return Me.Kelvin.ToString("N2") & " K"
         Case "C", "G"
            ' Return temperature in Celsius.
            Return Me.Celsius.ToString("N2") & " °C"
         Case Else
            Throw New FormatException(String.Format("The '{0}' format string is not supported.", format))
      End Select      
   End Function
End Class

Public Module Example
   Public Sub Main()
      Dim temp1 As New Temperature(0d)
      Console.WriteLine(temp1.ToString())
      Console.WriteLine(temp1.ToString("G"))
      Console.WriteLine(temp1.ToString("C"))
      Console.WriteLine(temp1.ToString("F"))
      Console.WriteLine(temp1.ToString("K"))

      Dim temp2 As New Temperature(-40d)
      Console.WriteLine(temp2.ToString())
      Console.WriteLine(temp2.ToString("G"))
      Console.WriteLine(temp2.ToString("C"))
      Console.WriteLine(temp2.ToString("F"))
      Console.WriteLine(temp2.ToString("K"))

      Dim temp3 As New Temperature(16d)
      Console.WriteLine(temp3.ToString())
      Console.WriteLine(temp3.ToString("G"))
      Console.WriteLine(temp3.ToString("C"))
      Console.WriteLine(temp3.ToString("F"))
      Console.WriteLine(temp3.ToString("K"))
      
      Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3))
   End Sub
End Module
' The example displays the following output:
'       0.00 °C
'       0.00 °C
'       0.00 °C
'       32.00 °F
'       273.15 K
'       -40.00 °C
'       -40.00 °C
'       -40.00 °C
'       -40.00 °F
'       233.15 K
'       16.00 °C
'       16.00 °C
'       16.00 °C
'       60.80 °F
'       289.15 K
'       The temperature is now 16.00 °C.

Volver al principioBack to top

Cadenas de formato personalizadoCustom Format Strings

Además de las cadenas de formato estándar, .NET define cadenas de formato personalizado tanto para los valores numéricos como para los valores de fecha y hora.In addition to the standard format strings, .NET defines custom format strings for both numeric values and date and time values. Una cadena de formato personalizado se compone de uno o varios especificadores de formato personalizado que definen la representación de cadena de un valor.A custom format string consists of one or more custom format specifiers that define the string representation of a value. Por ejemplo, la cadena de formato personalizado de fecha y hora “yyyy/mm/dd hh:mm:ss.ffff t zzz” convierte una fecha en su representación de cadena con el formato "2008/11/15 07:45:00.0000 P -08:00" para la referencia cultural en-US.For example, the custom date and time format string "yyyy/mm/dd hh:mm:ss.ffff t zzz" converts a date to its string representation in the form "2008/11/15 07:45:00.0000 P -08:00" for the en-US culture. Del mismo modo, la cadena de formato personalizado “0000” convierte el valor entero 12 en “0012”.Similarly, the custom format string "0000" converts the integer value 12 to "0012". Para una lista completa de las cadenas de formato personalizado, vea Custom Date and Time Format Strings y Custom Numeric Format Strings.For a complete list of custom format strings, see Custom Date and Time Format Strings and Custom Numeric Format Strings.

Si una cadena de formato consta de un único especificador de formato personalizado, el especificador de formato debe ir precedido del símbolo de porcentaje (%) para evitar la confusión con un especificador de formato estándar.If a format string consists of a single custom format specifier, the format specifier should be preceded by the percent (%) symbol to avoid confusion with a standard format specifier. En el ejemplo siguiente, se usa el especificador de formato personalizado "M" para mostrar un número de un dígito o de dos dígitos del mes de una fecha determinada.The following example uses the "M" custom format specifier to display a one-digit or two-digit number of the month of a particular date.

DateTime date1 = new DateTime(2009, 9, 8);
Console.WriteLine(date1.ToString("%M"));       // Displays 9
Dim date1 As Date = #09/08/2009#
Console.WriteLine(date1.ToString("%M"))      ' Displays 9

Muchas cadenas de formato estándar para valores de fecha y hora son alias para cadenas de formato personalizado definidas por propiedades del objeto DateTimeFormatInfo .Many standard format strings for date and time values are aliases for custom format strings that are defined by properties of the DateTimeFormatInfo object. Las cadenas de formato personalizado también ofrecen una gran flexibilidad a la hora de proporcionar formatos definidos por la aplicación para los valores numéricos o de fecha y hora.Custom format strings also offer considerable flexibility in providing application-defined formatting for numeric values or date and time values. Puede definir sus propias cadenas de resultado personalizadas para los valores numéricos y de fecha y hora si combina varios especificadores de formato personalizados en una única cadena de formato personalizado.You can define your own custom result strings for both numeric values and date and time values by combining multiple custom format specifiers into a single custom format string. En el ejemplo siguiente se define una cadena de formato personalizado que muestra el día de la semana entre paréntesis después del nombre de mes, el día y el año.The following example defines a custom format string that displays the day of the week in parentheses after the month name, day, and year.

string customFormat = "MMMM dd, yyyy (dddd)";
DateTime date1 = new DateTime(2009, 8, 28);
Console.WriteLine(date1.ToString(customFormat));   
// The example displays the following output if run on a system
// whose language is English:
//       August 28, 2009 (Friday)      
Dim customFormat As String = "MMMM dd, yyyy (dddd)"
Dim date1 As Date = #8/28/2009#
Console.WriteLine(date1.ToString(customFormat))   
' The example displays the following output if run on a system
' whose language is English:
'       August 28, 2009 (Friday)      

En el ejemplo siguiente se define una cadena de formato personalizado que muestra un valor de Int64 como un número de teléfono de Estados Unidos estándar de siete dígitos con el código de área.The following example defines a custom format string that displays an Int64 value as a standard, seven-digit U.S. telephone number along with its area code.

using System;

public class Example
{
   public static void Main()
   {
      long number = 8009999999;
      string fmt = "000-000-0000";
      Console.WriteLine(number.ToString(fmt));
   }
}
// The example displays the following output:
//        800-999-9999
Module Example
   Public Sub Main()
      Dim number As Long = 8009999999
      Dim fmt As String = "000-000-0000"
      Console.WriteLine(number.ToString(fmt))
   End Sub
End Module
' The example displays the following output:

' The example displays the following output:
'       800-999-9999

Aunque las cadenas de formato estándar pueden satisfacer generalmente la mayoría de las necesidades de formato para los tipos definidos por la aplicación, también puede definir especificadores de formato personalizados para dar formato a sus tipos.Although standard format strings can generally handle most of the formatting needs for your application-defined types, you may also define custom format specifiers to format your types.

Volver al principioBack to top

Dar formato a cadenas y tipos de biblioteca de clase .NETFormat Strings and .NET Class Library Types

Todos los tipos numéricos (es decir, los tipos Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64y BigInteger )All numeric types (that is, the Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64, and BigInteger types)

, así como DateTime, DateTimeOffset, TimeSpan, Guidy todos los tipos de enumeración, son compatibles con el formato con cadenas de formato., as well as the DateTime, DateTimeOffset, TimeSpan, Guid, and all enumeration types, support formatting with format strings. Para obtener información sobre las cadenas de formato específicas que admite cada tipo, consulte los temas siguientes.For information on the specific format strings supported by each type, see the following topics

TítuloTitle DefiniciónDefinition
Standard Numeric Format StringsStandard Numeric Format Strings Describe cadenas de formato estándar que crean representaciones de cadena usadas con frecuencia de valores numéricos.Describes standard format strings that create commonly used string representations of numeric values.
Custom Numeric Format StringsCustom Numeric Format Strings Describe cadenas de formato personalizado que crean formatos específicos de la aplicación para valores numéricos.Describes custom format strings that create application-specific formats for numeric values.
Standard Date and Time Format StringsStandard Date and Time Format Strings Describe cadenas de formato estándar que crean representaciones de cadena usadas con frecuencia de valores DateTime .Describes standard format strings that create commonly used string representations of DateTime values.
Custom Date and Time Format StringsCustom Date and Time Format Strings Describe cadenas de formato personalizado que crean formatos específicos de la aplicación para valores DateTime .Describes custom format strings that create application-specific formats for DateTime values.
Cadenas de formato TimeSpan estándarStandard TimeSpan Format Strings Describe cadenas de formato estándar que crean representaciones de cadena usadas con frecuencia de intervalos de tiempo.Describes standard format strings that create commonly used string representations of time intervals.
Cadenas de formato TimeSpan personalizadoCustom TimeSpan Format Strings Describe cadenas de formato personalizado que crean formatos específicos de la aplicación para intervalos de tiempo.Describes custom format strings that create application-specific formats for time intervals.
Enumeration Format StringsEnumeration Format Strings Describe cadenas de formato estándar que se usan para crear representaciones de cadena de valores de enumeración.Describes standard format strings that are used to create string representations of enumeration values.
Guid.ToString(String) Describe cadenas de formato estándar para los valores de Guid .Describes standard format strings for Guid values.

Formato que tiene en cuenta las referencias culturales con proveedores de formato y la interfaz IFormatProviderCulture-Sensitive Formatting with Format Providers and the IFormatProvider Interface

Si bien los especificadores de formato permiten personalizar el formato de los objetos, la generación de una representación de cadena significativa de los objetos requiere a menudo información de formato adicional.Although format specifiers let you customize the formatting of objects, producing a meaningful string representation of objects often requires additional formatting information. Por ejemplo, cuando se da formato a un número como un valor de divisa mediante la cadena de formato estándar "C" o la cadena de formato personalizado “$ #,#.00”, se necesita como mínimo información sobre el símbolo de divisa, el separador de grupos y el separador decimal correctos para incluirla en la cadena con formato.For example, formatting a number as a currency value by using either the "C" standard format string or a custom format string such as "$ #,#.00" requires, at a minimum, information about the correct currency symbol, group separator, and decimal separator to be available to include in the formatted string. En. NET, esta información de formato adicional debe ponerse a disposición a través de la IFormatProvider interfaz, que se proporciona como un parámetro a uno o más sobrecargas de la ToString método de tipos numéricos y tipos de fecha y hora.In .NET, this additional formatting information is made available through the IFormatProvider interface, which is provided as a parameter to one or more overloads of the ToString method of numeric types and date and time types. IFormatProviderlas implementaciones se usan en .NET para admitir el formato específico de la referencia cultural.IFormatProvider implementations are used in .NET to support culture-specific formatting. En el siguiente ejemplo se muestra cómo cambia la representación en forma de cadena de un objeto cuando se le da formato con tres objetos IFormatProvider que representan referencias culturales diferentes.The following example illustrates how the string representation of an object changes when it is formatted with three IFormatProvider objects that represent different cultures.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      decimal value = 1603.42m;
      Console.WriteLine(value.ToString("C3", new CultureInfo("en-US")));
      Console.WriteLine(value.ToString("C3", new CultureInfo("fr-FR")));
      Console.WriteLine(value.ToString("C3", new CultureInfo("de-DE")));
   }
}
// The example displays the following output:
//       $1,603.420
//       1 603,420 €
//       1.603,420 €
Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim value As Decimal = 1603.42d
      Console.WriteLine(value.ToString("C3", New CultureInfo("en-US")))
      Console.WriteLine(value.ToString("C3", New CultureInfo("fr-FR")))
      Console.WriteLine(value.ToString("C3", New CultureInfo("de-DE")))
   End Sub
End Module
' The example displays the following output:
'       $1,603.420
'       1 603,420 €
'       1.603,420 €

La interfaz IFormatProvider incluye un método, GetFormat(Type), que tiene un único parámetro que especifica el tipo de objeto que proporciona información de formato.The IFormatProvider interface includes one method, GetFormat(Type), which has a single parameter that specifies the type of object that provides formatting information. Si el método puede proporcionar un objeto de ese tipo, lo devuelve.If the method can provide an object of that type, it returns it. De lo contrario, devuelve una referencia nula (Nothing en Visual Basic).Otherwise, it returns a null reference (Nothing in Visual Basic).

IFormatProvider.GetFormat es un método de devolución de llamada.IFormatProvider.GetFormat is a callback method. Al llamar a una sobrecarga del método ToString que incluye un parámetro de IFormatProvider , se llama al método GetFormat de ese objeto IFormatProvider .When you call a ToString method overload that includes an IFormatProvider parameter, it calls the GetFormat method of that IFormatProvider object. El método GetFormat devuelve un objeto que proporciona al método formatType la información de formato necesaria especificada por su parámetro ToString .The GetFormat method is responsible for returning an object that provides the necessary formatting information, as specified by its formatType parameter, to the ToString method.

Varios métodos de formato o de conversión de cadenas incluyen un parámetro de tipo IFormatProviderpero, en muchos casos, se omite el valor del parámetro cuando se llama al método.A number of formatting or string conversion methods include a parameter of type IFormatProvider, but in many cases the value of the parameter is ignored when the method is called. En la tabla siguiente se muestran algunos métodos de formato que usan el parámetro y el tipo del objeto Type que pasan al método IFormatProvider.GetFormat.The following table lists some of the formatting methods that use the parameter and the type of the Type object that they pass to the IFormatProvider.GetFormat method.

MétodoMethod Tipo de parámetro formatTypeType of formatType parameter
MétodoToString de tipos numéricosToString method of numeric types System.Globalization.NumberFormatInfo
MétodoToString de tipos de fecha y horaToString method of date and time types System.Globalization.DateTimeFormatInfo
String.Format System.ICustomFormatter
StringBuilder.AppendFormat System.ICustomFormatter

Nota

Los métodos ToString de los tipos numéricos y los tipos de fecha y hora se sobrecargan y solo algunas de las sobrecargas incluyen un parámetro IFormatProvider .The ToString methods of the numeric types and date and time types are overloaded, and only some of the overloads include an IFormatProvider parameter. Si un método no tiene un parámetro de tipo IFormatProvider, se pasa en su lugar el objeto devuelto por la propiedad CultureInfo.CurrentCulture.If a method does not have a parameter of type IFormatProvider, the object that is returned by the CultureInfo.CurrentCulture property is passed instead. Por ejemplo, una llamada al método Int32.ToString() predeterminado resultará finalmente en una llamada similar a esta: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture).For example, a call to the default Int32.ToString() method ultimately results in a method call such as the following: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture).

.NET proporciona tres clases que implementan IFormatProvider:.NET provides three classes that implement IFormatProvider:

También se puede implementar un proveedor de formato propio para reemplazar cualquiera de estas clases.You can also implement your own format provider to replace any one of these classes. Sin embargo, el método GetFormat de la implementación debe devolver un objeto del tipo mostrado en la tabla anterior si debe proporcionar información de formato al método ToString .However, your implementation’s GetFormat method must return an object of the type listed in the previous table if it has to provide formatting information to the ToString method.

Volver al principioBack to top

Formato que tiene en cuenta las referencias culturales de valores numéricosCulture-Sensitive Formatting of Numeric Values

De forma predeterminada, el formato de los valores numéricos depende de la referencia cultural.By default, the formatting of numeric values is culture-sensitive. Si no especifica una referencia cultural cuando llama a un método de formato, se utilizan las convenciones de formato de la referencia cultural del subproceso actual.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. Esto se muestra en el ejemplo siguiente, que cambia la referencia cultural del subproceso actual cuatro veces y después llama al método Decimal.ToString(String).This is illustrated in the following example, which changes the current thread culture four times and then calls the Decimal.ToString(String) method. En cada caso, la cadena resultante refleja las convenciones de formato de la referencia cultural actual.In each case, the result string reflects the formatting conventions of the current culture. Esto se debe a que los métodos ToString y ToString(String) incluyen llamadas a cada tipo numérico del método ToString(String, IFormatProvider) .This is because the ToString and ToString(String) methods wrap calls to each numeric type's ToString(String, IFormatProvider) method.

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

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
      Decimal value = 1043.17m;
      
      foreach (var cultureName in cultureNames) {
         // Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name);
         Console.WriteLine(value.ToString("C2"));
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The current culture is en-US
//       $1,043.17
//       
//       The current culture is fr-FR
//       1 043,17 €
//       
//       The current culture is es-MX
//       $1,043.17
//       
//       The current culture is de-DE
//       1.043,17 €
Imports System.Globalization
Imports System.Threading 

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "es-MX", "de-DE" }
      Dim value As Decimal = 1043.17d 
      
      For Each cultureName In cultureNames
         ' Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name)
         Console.WriteLine(value.ToString("C2"))
         Console.WriteLine()
      Next                  
   End Sub
End Module
' The example displays the following output:
'       The current culture is en-US
'       $1,043.17
'       
'       The current culture is fr-FR
'       1 043,17 €
'       
'       The current culture is es-MX
'       $1,043.17
'       
'       The current culture is de-DE
'       1.043,17 €

También se puede dar formato a un valor numérico para una referencia cultural concreta llamando a una sobrecarga de ToString que tenga un parámetro provider y pasándole uno de los elementos siguientes:You can also format a numeric value for a specific culture by calling a ToString overload that has a provider parameter and passing it either of the following:

En el siguiente ejemplo se utilizan objetos NumberFormatInfo que representan las referencias culturales de inglés (Estados Unidos) e inglés (Reino Unido), y las referencias culturales neutras de francés y ruso para dar formato a un número de punto flotante.The following example uses NumberFormatInfo objects that represent the English (United States) and English (Great Britain) cultures and the French and Russian neutral cultures to format a floating-point number.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {                                                                                                    
      Double value = 1043.62957;
      string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };
      
      foreach (var name in cultureNames) {
         NumberFormatInfo nfi = CultureInfo.CreateSpecificCulture(name).NumberFormat;
         Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi));
      }   
   }
}
// The example displays the following output:
//       en-US: 1,043.630
//       en-GB: 1,043.630
//       ru:    1 043,630
//       fr:    1 043,630
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim value As Double = 1043.62957
      Dim cultureNames() As String = { "en-US", "en-GB", "ru", "fr" }
      
      For Each name In cultureNames
         Dim nfi As NumberFormatInfo = CultureInfo.CreateSpecificCulture(name).NumberFormat
         Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi))
      Next   
   End Sub
End Module
' The example displays the following output:
'       en-US: 1,043.630
'       en-GB: 1,043.630
'       ru:    1 043,630
'       fr:    1 043,630

Formato que tiene en cuenta las referencias culturales de valores de fecha y horaCulture-Sensitive Formatting of Date and Time Values

De forma predeterminada, el formato de los valores de fecha y hora tiene en cuenta las referencias culturales.By default, the formatting of date and time values is culture-sensitive. Si no especifica una referencia cultural cuando llama a un método de formato, se utilizan las convenciones de formato de la referencia cultural del subproceso actual.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. Esto se muestra en el ejemplo siguiente, que cambia la referencia cultural del subproceso actual cuatro veces y después llama al método DateTime.ToString(String).This is illustrated in the following example, which changes the current thread culture four times and then calls the DateTime.ToString(String) method. En cada caso, la cadena resultante refleja las convenciones de formato de la referencia cultural actual.In each case, the result string reflects the formatting conventions of the current culture. Esto se debe a que los métodos DateTime.ToString(), DateTime.ToString(String), DateTimeOffset.ToString() y DateTimeOffset.ToString(String) encapsulan llamadas a los métodos DateTime.ToString(String, IFormatProvider) y DateTimeOffset.ToString(String, IFormatProvider).This is because the DateTime.ToString(), DateTime.ToString(String), DateTimeOffset.ToString(), and DateTimeOffset.ToString(String) methods wrap calls to the DateTime.ToString(String, IFormatProvider) and DateTimeOffset.ToString(String, IFormatProvider) methods.

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

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
      DateTime dateToFormat = new DateTime(2012, 5, 28, 11, 30, 0);
      
      foreach (var cultureName in cultureNames) {
         // Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name);
         Console.WriteLine(dateToFormat.ToString("F"));
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       The current culture is en-US
//       Monday, May 28, 2012 11:30:00 AM
//       
//       The current culture is fr-FR
//       lundi 28 mai 2012 11:30:00
//       
//       The current culture is es-MX
//       lunes, 28 de mayo de 2012 11:30:00 a.m.
//       
//       The current culture is de-DE
//       Montag, 28. Mai 2012 11:30:00
Imports System.Globalization
Imports System.Threading 

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "es-MX", "de-DE" }
      Dim dateToFormat As Date = #5/28/2012 11:30AM#
      
      For Each cultureName In cultureNames
         ' Change the current thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("The current culture is {0}", 
                           Thread.CurrentThread.CurrentCulture.Name)
         Console.WriteLine(dateToFormat.ToString("F"))
         Console.WriteLine()
      Next                  
   End Sub
End Module
' The example displays the following output:
'       The current culture is en-US
'       Monday, May 28, 2012 11:30:00 AM
'       
'       The current culture is fr-FR
'       lundi 28 mai 2012 11:30:00
'       
'       The current culture is es-MX
'       lunes, 28 de mayo de 2012 11:30:00 a.m.
'       
'       The current culture is de-DE
'       Montag, 28. Mai 2012 11:30:00 

También se puede dar formato a un valor de fecha y hora para una referencia cultural concreta llamando a una sobrecarga de DateTime.ToString o DateTimeOffset.ToString que tenga un parámetro provider y pasándole uno de los elementos siguientes:You can also format a date and time value for a specific culture by calling a DateTime.ToString or DateTimeOffset.ToString overload that has a provider parameter and passing it either of the following:

En el siguiente ejemplo se utilizan objetos DateTimeFormatInfo que representan las referencias culturales de inglés (Estados Unidos) e inglés (Reino Unido), y las referencias culturales neutras de francés y ruso para dar formato a una fecha.The following example uses DateTimeFormatInfo objects that represent the English (United States) and English (Great Britain) cultures and the French and Russian neutral cultures to format a date.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {                                                                                                    
      DateTime dat1 = new DateTime(2012, 5, 28, 11, 30, 0);
      string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };
      
      foreach (var name in cultureNames) {
         DateTimeFormatInfo dtfi = CultureInfo.CreateSpecificCulture(name).DateTimeFormat;
         Console.WriteLine("{0}: {1}", name, dat1.ToString(dtfi));
      }   
   }
}
// The example displays the following output:
//       en-US: 5/28/2012 11:30:00 AM
//       en-GB: 28/05/2012 11:30:00
//       ru: 28.05.2012 11:30:00
//       fr: 28/05/2012 11:30:00
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dat1 As Date = #5/28/2012 11:30AM#
      Dim cultureNames() As String = { "en-US", "en-GB", "ru", "fr" }
      
      For Each name In cultureNames
         Dim dtfi As DateTimeFormatInfo = CultureInfo.CreateSpecificCulture(name).DateTimeFormat
         Console.WriteLine("{0}: {1}", name, dat1.ToString(dtfi))
      Next   
   End Sub
End Module
' The example displays the following output:
'       en-US: 5/28/2012 11:30:00 AM
'       en-GB: 28/05/2012 11:30:00
'       ru: 28.05.2012 11:30:00
'       fr: 28/05/2012 11:30:00

Interfaz IFormattableThe IFormattable Interface

Normalmente, los tipos que sobrecargan el método ToString con una cadena de formato y un parámetro IFormatProvider también implementan la interfaz IFormattable .Typically, types that overload the ToString method with a format string and an IFormatProvider parameter also implement the IFormattable interface. Esta interfaz tiene un solo miembro, IFormattable.ToString(String, IFormatProvider), que incluye una cadena de formato y un proveedor de formato como parámetros.This interface has a single member, IFormattable.ToString(String, IFormatProvider), that includes both a format string and a format provider as parameters.

La implementación de la interfaz IFormattable para su clase definida por la aplicación ofrece dos ventajas:Implementing the IFormattable interface for your application-defined class offers two advantages:

En el ejemplo siguiente se define una clase Temperature que implementa la interfaz IFormattable .The following example defines a Temperature class that implements the IFormattable interface. Admite los especificadores de formato "C" o "G" para mostrar la temperatura en grados centígrados, el especificador de formato "F" para mostrar la temperatura en grados Fahrenheit y el especificador de formato "K" para mostrar la temperatura en grados Kelvin.It supports the "C" or "G" format specifiers to display the temperature in Celsius, the "F" format specifier to display the temperature in Fahrenheit, and the "K" format specifier to display the temperature in Kelvin.

using System;
using System.Globalization;

public class Temperature : IFormattable
{
   private decimal m_Temp;

   public Temperature(decimal temperature)
   {
      this.m_Temp = temperature;
   }
   
   public decimal Celsius
   {
      get { return this.m_Temp; }
   }
   
   public decimal Kelvin
   {
      get { return this.m_Temp + 273.15m; }   
   }
   
   public decimal Fahrenheit
   {
      get { return Math.Round((decimal) this.m_Temp * 9 / 5 + 32, 2); }
   }

   public override string ToString()
   {
      return this.ToString("G", null);
   }
   
   public string ToString(string format)
   {
      return this.ToString(format, null);
   }
   
   public string ToString(string format, IFormatProvider provider)  
   {
      // Handle null or empty arguments.
      if (String.IsNullOrEmpty(format))
         format = "G";
      // Remove any white space and covert to uppercase.
      format = format.Trim().ToUpperInvariant();

      if (provider == null)
         provider = NumberFormatInfo.CurrentInfo;
            
      switch (format)
      {
         // Convert temperature to Fahrenheit and return string.
         case "F":
            return this.Fahrenheit.ToString("N2", provider) + "°F";
         // Convert temperature to Kelvin and return string.
         case "K":
            return this.Kelvin.ToString("N2", provider) + "K";
         // Return temperature in Celsius.
         case "C":
         case "G":
            return this.Celsius.ToString("N2", provider) + "°C";
         default:
            throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
      }      
   }
}
Imports System.Globalization

Public Class Temperature : Implements IFormattable
   Private m_Temp As Decimal

   Public Sub New(temperature As Decimal)
      Me.m_Temp = temperature
   End Sub
   
   Public ReadOnly Property Celsius() As Decimal
      Get
         Return Me.m_Temp
      End Get   
   End Property
   
   Public ReadOnly Property Kelvin() As Decimal
      Get
         Return Me.m_Temp + 273.15d   
      End Get
   End Property
   
   Public ReadOnly Property Fahrenheit() As Decimal
      Get
         Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
      End Get      
   End Property

   Public Overrides Function ToString() As String
      Return Me.ToString("G", Nothing)
   End Function
   
   Public Overloads Function ToString(format As String) As String
      Return Me.ToString(format, Nothing)
   End Function
   
   Public Overloads Function ToString(format As String, provider As IFormatProvider) As String _  
      Implements IFormattable.ToString

      ' Handle null or empty arguments.
      If String.IsNullOrEmpty(format) Then format = "G"
      ' Remove any white space and convert to uppercase.
      format = format.Trim().ToUpperInvariant()

      If provider Is Nothing Then provider = NumberFormatInfo.CurrentInfo
            
      Select Case format
         ' Convert temperature to Fahrenheit and return string.
         Case "F"
            Return Me.Fahrenheit.ToString("N2", provider) & "°F"
         ' Convert temperature to Kelvin and return string.
         Case "K"
            Return Me.Kelvin.ToString("N2", provider) & "K"
         ' Return temperature in Celsius.
         Case "C", "G"
            Return Me.Celsius.ToString("N2", provider) & "°C"
         Case Else
            Throw New FormatException(String.Format("The '{0}' format string is not supported.", format))
      End Select      
   End Function
End Class

En el ejemplo siguiente se crea una instancia de un objeto Temperature .The following example instantiates a Temperature object. A continuación, llama al método ToString y usa varias cadenas de formato compuesto para obtener representaciones de cadena diferentes de un objeto Temperature .It then calls the ToString method and uses several composite format strings to obtain different string representations of a Temperature object. Cada una de estas llamadas al método, a su vez, llama a la implementación de IFormattable de la clase Temperature .Each of these method calls, in turn, calls the IFormattable implementation of the Temperature class.

public class Example
{
   public static void Main()
   {
      CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
      Temperature temp = new Temperature(22m);
      Console.WriteLine(Convert.ToString(temp, new CultureInfo("ja-JP")));
      Console.WriteLine("Temperature: {0:K}", temp);
      Console.WriteLine("Temperature: {0:F}", temp);
      Console.WriteLine(String.Format(new CultureInfo("fr-FR"), "Temperature: {0:F}", temp));
   }
}
// The example displays the following output:
//       22.00°C
//       Temperature: 295.15K
//       Temperature: 71.60°F
//       Temperature: 71,60°F
Public Module Example
   Public Sub Main()
      Dim temp As New Temperature(22d)
      CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US")
      Console.WriteLine(Convert.ToString(temp1, New CultureInfo("ja-JP")))
      Console.WriteLine("Temperature: {0:K}", temp)
      Console.WriteLine("Temperature: {0:F}", temp)
      Console.WriteLine(String.Format(New CultureInfo("fr-FR"), "Temperature: {0:F}", temp)) 
   End Sub
End Module
' The example displays the following output:
'       22.00°C
'       Temperature: 295.15K
'       Temperature: 71.60°F
'       Temperature: 71,60°F

Volver al principioBack to top

Formatos compuestosComposite Formatting

Algunos métodos, como String.Format y StringBuilder.AppendFormat, admiten formatos compuestos.Some methods, such as String.Format and StringBuilder.AppendFormat, support composite formatting. Una cadena de formato compuesto es un tipo de plantilla que devuelve una sola cadena que incorpora la representación de cadena de cero, uno o más objetos.A composite format string is a kind of template that returns a single string that incorporates the string representation of zero, one, or more objects. Cada objeto se representa en la cadena de formato compuesto mediante un elemento de formato indizado.Each object is represented in the composite format string by an indexed format item. El índice del elemento de formato corresponde a la posición del objeto que representa en la lista de parámetros del método.The index of the format item corresponds to the position of the object that it represents in the method's parameter list. Los índices son de base cero.Indexes are zero-based. Por ejemplo, en la siguiente llamada al método String.Format, el primer elemento de formato, {0:D} se reemplaza con la representación de cadena de thatDate; el segundo elemento de formato, {1}, se reemplaza con la representación de cadena de item1 y el tercer elemento de formato, {2:C2}, se reemplaza con la representación de cadena de item1.Value.For example, in the following call to the String.Format method, the first format item, {0:D}, is replaced by the string representation of thatDate; the second format item, {1}, is replaced by the string representation of item1; and the third format item, {2:C2}, is replaced by the string representation of item1.Value.

result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.", 
                       thatDate, item1, item1.Value);
Console.WriteLine(result);                            
// The example displays output like the following if run on a system
// whose current culture is en-US:
//       On 5/1/2009, the inventory of WidgetA was worth $107.44.
result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.", _
                       thatDate, item1, item1.Value)
Console.WriteLine(result)                            
' The example displays output like the following if run on a system
' whose current culture is en-US:
'       On 5/1/2009, the inventory of WidgetA was worth $107.44.

Además de reemplazar un elemento de formato con la representación de cadena de su objeto correspondiente, los elementos de formato también permiten controlar lo siguiente:In addition to replacing a format item with the string representation of its corresponding object, format items also let you control the following:

  • La forma específica en que un objeto se representa como una cadena, si el objeto implementa la interfaz IFormattable y admite cadenas de formato.The specific way in which an object is represented as a string, if the object implements the IFormattable interface and supports format strings. Para ello, siga el índice del elemento de formato con un signo : (dos puntos) seguido de una cadena de formato válida.You do this by following the format item's index with a : (colon) followed by a valid format string. En el ejemplo anterior, esto se hacía dando formato a un valor de fecha con la cadena de formato "d" (patrón de fecha corta) (por ejemplo, {0:d}) y dando formato a un valor numérico con la cadena de formato "C2" (por ejemplo, {2:C2} ) para representar el número como un valor de moneda con dos decimales fraccionarios.The previous example did this by formatting a date value with the "d" (short date pattern) format string (e.g., {0:d}) and by formatting a numeric value with the "C2" format string (e.g., {2:C2} to represent the number as a currency value with two fractional decimal digits.

  • El ancho del campo que contiene la representación de cadena del objeto y la alineación de la representación de cadena en ese campo.The width of the field that contains the object's string representation, and the alignment of the string representation in that field. Para ello, escriba una coma ( , ) seguida del ancho del campo.You do this by following the format item's index with a , (comma) followed the field width. La cadena se alinea a la derecha en el campo si el ancho del campo es un valor positivo, y se alinea a la izquierda si el ancho del campo es un valor negativo.The string is right-aligned in the field if the field width is a positive value, and it is left-aligned if the field width is a negative value. En el ejemplo siguiente los valores de fecha se alinean a la izquierda en un campo de 20 caracteres y los valores decimales con un dígito fraccionario se alinean a la derecha en un campo de 11 caracteres.The following example left-aligns date values in a 20-character field, and it right-aligns decimal values with one fractional digit in an 11-character field.

    DateTime startDate = new DateTime(2015, 8, 28, 6, 0, 0);
    decimal[] temps = { 73.452m, 68.98m, 72.6m, 69.24563m,
                       74.1m, 72.156m, 72.228m };
    Console.WriteLine("{0,-20} {1,11}\n", "Date", "Temperature");
    for (int ctr = 0; ctr < temps.Length; ctr++)
       Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps[ctr]);
    
    // The example displays the following output:
    //       Date                 Temperature
    //
    //       8/28/2015 6:00 AM           73.5
    //       8/29/2015 6:00 AM           69.0
    //       8/30/2015 6:00 AM           72.6
    //       8/31/2015 6:00 AM           69.2
    //       9/1/2015 6:00 AM            74.1
    //       9/2/2015 6:00 AM            72.2
    //       9/3/2015 6:00 AM            72.2
    
    Dim startDate As New Date(2015, 8, 28, 6, 0, 0)
    Dim temps() As Decimal = { 73.452, 68.98, 72.6, 69.24563,
                               74.1, 72.156, 72.228 }
    Console.WriteLine("{0,-20} {1,11}", "Date", "Temperature")
    Console.WriteLine()
    For ctr As Integer = 0 To temps.Length - 1
       Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps(ctr))
    Next
    ' The example displays the following output:
    '       Date                 Temperature
    '
    '       8/28/2015 6:00 AM           73.5
    '       8/29/2015 6:00 AM           69.0
    '       8/30/2015 6:00 AM           72.6
    '       8/31/2015 6:00 AM           69.2
    '       9/1/2015 6:00 AM            74.1
    '       9/2/2015 6:00 AM            72.2
    '       9/3/2015 6:00 AM            72.2
    

    Tenga en cuenta que, si están presentes tanto el componente de cadena de alineación como el componente de cadena de formato, el primero precede al último (por ejemplo, {0,-20:g}).Note that, if both the alignment string component and the format string component are present, the former precedes the latter (for example, {0,-20:g}.

Para más información sobre los formatos compuestos, vea Composite Formatting.For more information about composite formatting, see Composite Formatting.

Volver al principioBack to top

Formato personalizado con ICustomFormatterCustom Formatting with ICustomFormatter

Dos métodos de formato compuesto, String.Format(IFormatProvider, String, Object[]) y StringBuilder.AppendFormat(IFormatProvider, String, Object[]), incluyen un parámetro de proveedor de formato que admite formatos personalizados.Two composite formatting methods, String.Format(IFormatProvider, String, Object[]) and StringBuilder.AppendFormat(IFormatProvider, String, Object[]), include a format provider parameter that supports custom formatting. Cuando se llama a alguno de estos métodos de formato, se pasa un objeto Type que representa una interfaz ICustomFormatter al método GetFormat del proveedor de formato.When either of these formatting methods is called, it passes a Type object that represents an ICustomFormatter interface to the format provider’s GetFormat method. A continuación, el método GetFormat devuelve la implementación de ICustomFormatter que proporciona el formato personalizado.The GetFormat method is then responsible for returning the ICustomFormatter implementation that provides custom formatting.

La interfaz ICustomFormatter tiene un único método, Format(String, Object, IFormatProvider), al que un método de formato compuesto llama automáticamente una vez para cada elemento de formato de una cadena de formato compuesto.The ICustomFormatter interface has a single method, Format(String, Object, IFormatProvider), that is called automatically by a composite formatting method, once for each format item in a composite format string. El método Format(String, Object, IFormatProvider) tiene tres parámetros: una cadena de formato, que representa el argumento formatString de un elemento de formato, un objeto para dar formato y un objeto IFormatProvider que proporciona servicios de formato.The Format(String, Object, IFormatProvider) method has three parameters: a format string, which represents the formatString argument in a format item, an object to format, and an IFormatProvider object that provides formatting services. Normalmente, la clase que implementa ICustomFormatter también implementa IFormatProvider, de modo que este último parámetro es una referencia a la propia clase de formato personalizado.Typically, the class that implements ICustomFormatter also implements IFormatProvider, so this last parameter is a reference to the custom formatting class itself. El método devuelve una representación de cadena con formato personalizado del objeto al que se va a dar formato.The method returns a custom formatted string representation of the object to be formatted. Si el método no puede dar formato al objeto, debe devolver una referencia nula (Nothing en Visual Basic).If the method cannot format the object, it should return a null reference (Nothing in Visual Basic).

En el ejemplo siguiente se proporciona una implementación de ICustomFormatter denominada ByteByByteFormatter que muestra los valores enteros como una secuencia de valores hexadecimales de dos dígitos seguidos de un espacio.The following example provides an ICustomFormatter implementation named ByteByByteFormatter that displays integer values as a sequence of two-digit hexadecimal values followed by a space.

public class ByteByByteFormatter : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   { 
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public string Format(string format, object arg, 
                          IFormatProvider formatProvider)
   {   
      if (! formatProvider.Equals(this)) return null;
      
      // Handle only hexadecimal format string.
      if (! format.StartsWith("X")) return null;
      
      byte[] bytes;
      string output = null;
      
      // Handle only integral types.
      if (arg is Byte) 
         bytes = BitConverter.GetBytes((Byte) arg);
      else if (arg is Int16)
         bytes = BitConverter.GetBytes((Int16) arg);
      else if (arg is Int32)
         bytes = BitConverter.GetBytes((Int32) arg);
      else if (arg is Int64)   
         bytes = BitConverter.GetBytes((Int64) arg);
      else if (arg is SByte)
         bytes = BitConverter.GetBytes((SByte) arg);
      else if (arg is UInt16)
         bytes = BitConverter.GetBytes((UInt16) arg);
      else if (arg is UInt32)
         bytes = BitConverter.GetBytes((UInt32) arg);
      else if (arg is UInt64)
         bytes = BitConverter.GetBytes((UInt64) arg);
      else
         return null;

      for (int ctr = bytes.Length - 1; ctr >= 0; ctr--)
         output += String.Format("{0:X2} ", bytes[ctr]);   
      
      return output.Trim();
   }
}
Public Class ByteByByteFormatter : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, arg As Object, 
                          formatProvider As IFormatProvider) As String _
                          Implements ICustomFormatter.Format

      If Not formatProvider.Equals(Me) Then Return Nothing

      ' Handle only hexadecimal format string.
      If Not fmt.StartsWith("X") Then 
            Return Nothing
      End If

      ' Handle only integral types.
      If Not typeof arg Is Byte AndAlso
         Not typeof arg Is Int16 AndAlso
         Not typeof arg Is Int32 AndAlso
         Not typeof arg Is Int64 AndAlso
         Not typeof arg Is SByte AndAlso
         Not typeof arg Is UInt16 AndAlso
         Not typeof arg Is UInt32 AndAlso
         Not typeof arg Is UInt64 Then _
            Return Nothing

      Dim bytes() As Byte = BitConverter.GetBytes(arg)
      Dim output As String = Nothing
         
      For ctr As Integer = bytes.Length - 1 To 0 Step -1
         output += String.Format("{0:X2} ", bytes(ctr))   
      Next
      
      Return output.Trim()
   End Function
End Class

En el ejemplo siguiente se usa la clase ByteByByteFormatter para dar formato a valores enteros.The following example uses the ByteByByteFormatter class to format integer values. Tenga en cuenta que la ICustomFormatter.Format método se llama más de una vez en el segundo String.Format(IFormatProvider, String, Object[]) llamada al método y que el valor predeterminado NumberFormatInfo proveedor se usa en la tercera llamada al método porque el.ByteByByteFormatter.FormatNote that the ICustomFormatter.Format method is called more than once in the second String.Format(IFormatProvider, String, Object[]) method call, and that the default NumberFormatInfo provider is used in the third method call because the .ByteByByteFormatter.Format no reconoce la cadena de formato "N0" y devuelve una referencia nula (Nothing en Visual Basic).method does not recognize the "N0" format string and returns a null reference (Nothing in Visual Basic).

public class Example
{
   public static void Main()
   {
      long value = 3210662321; 
      byte value1 = 214;
      byte value2 = 19;
      
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X}", value));
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})", 
                                      value1, value2, value1 & value2));                                
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0,10:N0}", value));
   }
}
// The example displays the following output:
//       00 00 00 00 BF 5E D1 B1
//       00 D6 And 00 13 = 00 12 (018)
//       3,210,662,321
Public Module Example
   Public Sub Main()
      Dim value As Long = 3210662321 
      Dim value1 As Byte = 214
      Dim value2 As Byte = 19
      
      Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X}", value)))
      Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})", 
                                      value1, value2, value1 And value2)))                                
      Console.WriteLine(String.Format(New ByteByByteFormatter(), "{0,10:N0}", value))
   End Sub
End Module
' The example displays the following output:
'       00 00 00 00 BF 5E D1 B1
'       00 D6 And 00 13 = 00 12 (018)
'       3,210,662,321

Volver al principioBack to top

TítuloTitle DefiniciónDefinition
Standard Numeric Format StringsStandard Numeric Format Strings Describe cadenas de formato estándar que crean representaciones de cadena usadas con frecuencia de valores numéricos.Describes standard format strings that create commonly used string representations of numeric values.
Custom Numeric Format StringsCustom Numeric Format Strings Describe cadenas de formato personalizado que crean formatos específicos de la aplicación para valores numéricos.Describes custom format strings that create application-specific formats for numeric values.
Standard Date and Time Format StringsStandard Date and Time Format Strings Describe cadenas de formato estándar que crean representaciones de cadena usadas con frecuencia de valores DateTime .Describes standard format strings that create commonly used string representations of DateTime values.
Custom Date and Time Format StringsCustom Date and Time Format Strings Describe cadenas de formato personalizado que crean formatos específicos de la aplicación para valores DateTime .Describes custom format strings that create application-specific formats for DateTime values.
Cadenas de formato TimeSpan estándarStandard TimeSpan Format Strings Describe cadenas de formato estándar que crean representaciones de cadena usadas con frecuencia de intervalos de tiempo.Describes standard format strings that create commonly used string representations of time intervals.
Cadenas de formato TimeSpan personalizadoCustom TimeSpan Format Strings Describe cadenas de formato personalizado que crean formatos específicos de la aplicación para intervalos de tiempo.Describes custom format strings that create application-specific formats for time intervals.
Enumeration Format StringsEnumeration Format Strings Describe cadenas de formato estándar que se usan para crear representaciones de cadena de valores de enumeración.Describes standard format strings that are used to create string representations of enumeration values.
Formatos compuestosComposite Formatting Describe cómo incrustar uno o más valores con formato en una cadena.Describes how to embed one or more formatted values in a string. Posteriormente se puede mostrar la cadena en la consola o escrita en una secuencia.The string can subsequently be displayed on the console or written to a stream.
Efectuar operaciones de formatoPerforming Formatting Operations Muestra los temas en los que se proporcionan instrucciones paso a paso para realizar operaciones de formato concretas.Lists topics that provide step-by-step instructions for performing specific formatting operations.
Parsing StringsParsing Strings Describe cómo inicializar objetos en los valores descritos por representaciones de cadena de dichos objetos.Describes how to initialize objects to the values described by string representations of those objects. El análisis es la operación inversa de la aplicación de formato.Parsing is the inverse operation of formatting.

Volver al principioBack to top

ReferenciaReference

System.IFormattable

System.IFormatProvider

System.ICustomFormatter