Types de format dans .NETFormat types in .NET

La mise en forme est le processus de conversion d'une instance d'une classe, d'une structure ou d'une valeur d'énumération en représentation sous forme de chaîne, généralement pour exposer la chaîne obtenue aux utilisateurs ou pour qu'elle soit désérialisée afin de restaurer le type de données d'origine.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. Cette conversion peut présenter plusieurs difficultés :This conversion can pose a number of challenges:

  • La manière dont les valeurs sont stockées en interne ne reflète pas nécessairement celle dont les utilisateurs souhaitent les voir.The way that values are stored internally does not necessarily reflect the way that users want to view them. Par exemple, un numéro de téléphone peut être stocké sous la forme 8009999999, ce qui n'est pas convivial.For example, a telephone number might be stored in the form 8009999999, which is not user-friendly. Il devrait plutôt être affiché sous la forme 800-999-9999.It should instead be displayed as 800-999-9999. Consultez la section Chaînes de format personnalisé pour obtenir un exemple d'une telle mise en forme d'un nombre.See the Custom Format Strings section for an example that formats a number in this way.

  • La conversion d'un objet en sa représentation sous forme de chaîne n'est pas toujours intuitive.Sometimes the conversion of an object to its string representation is not intuitive. Par exemple, il n'est pas évident de savoir comment doit s'afficher la représentation sous forme de chaîne d'un objet Temperature ou Person.For example, it is not clear how the string representation of a Temperature object or a Person object should appear. Pour obtenir un exemple illustrant la mise en forme d'un objet Temperature selon différentes manières, consultez la section Chaînes de format standard .For an example that formats a Temperature object in a variety of ways, see the Standard Format Strings section.

  • Les valeurs requièrent souvent une mise en forme qui tient compte de la culture.Values often require culture-sensitive formatting. Par exemple, dans une application qui utilise des nombre pour refléter des valeurs monétaires, les chaînes numériques doivent inclure le symbole monétaire, le séparateur de groupes (qui, dans la plupart des cultures, est le séparateur des milliers) et le symbole décimal qui correspondent à la culture actuelle.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. Pour obtenir un exemple, consultez la section mise en forme dépendante de la culture avec les fournisseurs de format .For an example, see the Culture-sensitive formatting with format providers section.

  • Une application peut avoir à afficher la même valeur de différentes manières.An application may have to display the same value in different ways. Par exemple, une application peut représenter un membre d'énumération en affichant une représentation sous forme de chaîne de son nom ou en affichant sa valeur sous-jacente.For example, an application may represent an enumeration member by displaying a string representation of its name or by displaying its underlying value. Pour obtenir un exemple illustrant la mise en forme d'un membre de l'énumération DayOfWeek selon différentes manières, consultez la section Chaînes de format standard .For an example that formats a member of the DayOfWeek enumeration in different ways, see the Standard Format Strings section.

Notes

La mise en forme convertit la valeur d'un type en une représentation sous forme de chaîne.Formatting converts the value of a type into a string representation. L'analyse est l'opération inverse de la mise en forme.Parsing is the inverse of formatting. Une opération d'analyse crée une instance d'un type de données à partir de sa représentation sous forme de chaîne.A parsing operation creates an instance of a data type from its string representation. Pour plus d’informations sur la conversion de chaînes en d’autres types de données, consultez Parsing Strings.For information about converting strings to other data types, see Parsing Strings.

.NET assure une prise en charge évoluée de la mise en forme qui permet aux développeurs de surmonter ces difficultés..NET provides rich formatting support that enables developers to address these requirements.

Mise en forme dans .NETFormatting in .NET

Le mécanisme de base de la mise en forme est l'implémentation par défaut de la méthode Object.ToString, décrite dans la section Mise en forme par défaut à l'aide de la méthode ToString, plus loin dans cette rubrique.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. Toutefois, .NET propose différentes manières de modifier et d’étendre sa prise en charge par défaut de la mise en forme.However, .NET provides several ways to modify and extend its default formatting support. Notamment :These include the following:

  • Substitution de la méthode Object.ToString pour définir une représentation sous forme de chaîne personnalisée de la valeur d'un objet.Overriding the Object.ToString method to define a custom string representation of an object’s value. Pour plus d’informations, consultez la section substitution de la méthode ToString , plus loin dans cette rubrique.For more information, see the Override the ToString Method section later in this topic.

  • Définition de spécificateurs de format qui permettent à la représentation sous forme de chaîne de la valeur d'un objet de prendre plusieurs formes.Defining format specifiers that enable the string representation of an object’s value to take multiple forms. Par exemple, dans l'instruction suivante, le spécificateur de format "X" convertit un entier en la représentation sous forme de chaîne d'une valeur hexadécimale.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.
    

    Pour plus d'informations sur les spécificateurs de format, consultez la section Méthode ToString et chaînes de format .For more information about format specifiers, see the ToString Method and Format Strings section.

  • Utilisation de fournisseurs de format pour tirer parti des conventions de mise en forme d'une culture spécifique.Using format providers to take advantage of the formatting conventions of a specific culture. Par exemple, l'instruction suivante affiche une valeur monétaire en utilisant les conventions de mise en forme de la culture 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
    

    Pour plus d’informations sur la mise en forme avec les fournisseurs de format, consultez la section fournisseurs de format .For more information about formatting with format providers, see the Format Providers section.

  • Implémentation de l'interface IFormattable pour prendre en charge la conversion de chaînes avec la classe Convert et la mise en forme composite.Implementing the IFormattable interface to support both string conversion with the Convert class and composite formatting. Pour plus d'informations, consultez la section Interface IFormattable .For more information, see the IFormattable Interface section.

  • Utilisation de la mise en forme composite pour incorporer la représentation sous forme de chaîne d'une valeur dans une chaîne plus grande.Using composite formatting to embed the string representation of a value in a larger string. Pour plus d'informations, consultez la section Mise en forme composite .For more information, see the Composite Formatting section.

  • Implémentation d' ICustomFormatter et d' IFormatProvider pour fournir une solution de mise en forme personnalisée et complète.Implementing ICustomFormatter and IFormatProvider to provide a complete custom formatting solution. Pour plus d'informations, consultez la section Mise en forme personnalisée avec ICustomFormatter .For more information, see the Custom Formatting with ICustomFormatter section.

Les sections suivantes étudient ces méthodes de conversion d'un objet en sa représentation sous forme de chaîne.The following sections examine these methods for converting an object to its string representation.

Mise en forme par défaut à l’aide de la méthode ToStringDefault formatting using the ToString method

Chaque type qui est dérivé d' System.Object hérite automatiquement d'une méthode ToString sans paramètre, laquelle retourne le nom du type par défaut.Every type that is derived from System.Object automatically inherits a parameterless ToString method, which returns the name of the type by default. L'exemple suivant illustre la méthode ToString par défaut.The following example illustrates the default ToString method. Il définit une classe nommée Automobile qui n'a pas d'implémentation.It defines a class named Automobile that has no implementation. Lorsque cette classe est instanciée et que sa méthode ToString est appelée, elle affiche son nom de type.When the class is instantiated and its ToString method is called, it displays its type name. Notez que la méthode ToString n'est pas appelée explicitement dans cet exemple.Note that the ToString method is not explicitly called in the example. La méthode Console.WriteLine(Object) appelle implicitement la méthode ToString de l'objet qui lui est passé comme argument.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

Avertissement

À partir de Windows 8.1, le Windows Runtime inclut une interface IStringable avec une méthode unique, IStringable. ToString, qui fournit la prise en charge de la mise en forme par défaut.Starting with Windows 8.1, the Windows Runtime includes an IStringable interface with a single method, IStringable.ToString, which provides default formatting support. Toutefois, nous recommandons que les types managés n'implémentent pas l'interface IStringable .However, we recommend that managed types do not implement the IStringable interface. Pour plus d’informations, consultez la section « Windows Runtime et interface IStringable » dans la page de référence de Object.ToString.For more information, see "The Windows Runtime and the IStringable Interface" section on the Object.ToString reference page.

Étant donné que tous les types autres que les interfaces sont dérivés de Object, ces fonctionnalités sont fournies automatiquement à vos classes ou structures personnalisées.Because all types other than interfaces are derived from Object, this functionality is automatically provided to your custom classes or structures. Toutefois, les fonctionnalités offertes par la méthode ToString par défaut sont limitées : Bien qu'elle identifie le type, elle ne fournit aucune information relative à une instance du type.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. Pour fournir une représentation sous forme de chaîne d'un objet qui donne des informations sur cet objet, vous devez substituer la méthode ToString .To provide a string representation of an object that provides information about that object, you must override the ToString method.

Notes

Les structures héritent de ValueType, qui, à son tour, est dérivé d' Object.Structures inherit from ValueType, which in turn is derived from Object. Bien que ValueType substitue Object.ToString, son implémentation est identique.Although ValueType overrides Object.ToString, its implementation is identical.

Substituer la méthode ToStringOverride the ToString method

L'utilité de l'affichage du nom d'un type est souvent limitée et ne permet pas aux consommateurs de vos types de différencier une instance d'une autre.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. Toutefois, vous pouvez substituer la méthode ToString pour fournir une représentation plus utile de la valeur d'un objet.However, you can override the ToString method to provide a more useful representation of an object’s value. L'exemple suivant définit un objet Temperature et substitue sa méthode ToString pour afficher la température en degrés Celsius.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.

Dans .NET, la méthode ToString de chaque type valeur primitif a été écrasée de façon à afficher la valeur de l’objet plutôt que son nom.In .NET, the ToString method of each primitive value type has been overridden to display the object’s value instead of its name. Le tableau suivant montre la substitution pour chaque type primitif.The following table shows the override for each primitive type. Notez que la plupart des méthodes substituées appellent une autre surcharge de la méthode ToString et lui passent le spécificateur de format "G", qui définit le format général pour son type, ainsi qu'un objet IFormatProvider qui représente la culture actuelle.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.

TypeType Substitution de ToStringToString override
Boolean Retourne Boolean.TrueString ou Boolean.FalseString.Returns either Boolean.TrueString or Boolean.FalseString.
Byte Appelle Byte.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur Byte pour la culture actuelle.Calls Byte.ToString("G", NumberFormatInfo.CurrentInfo) to format the Byte value for the current culture.
Char Retourne le caractère sous forme de chaîne.Returns the character as a string.
DateTime Appelle DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) afin de mettre en forme la valeur de date et d'heure pour la culture actuelle.Calls DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) to format the date and time value for the current culture.
Decimal Appelle Decimal.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur Decimal pour la culture actuelle.Calls Decimal.ToString("G", NumberFormatInfo.CurrentInfo) to format the Decimal value for the current culture.
Double Appelle Double.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur Double pour la culture actuelle.Calls Double.ToString("G", NumberFormatInfo.CurrentInfo) to format the Double value for the current culture.
Int16 Appelle Int16.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur Int16 pour la culture actuelle.Calls Int16.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int16 value for the current culture.
Int32 Appelle Int32.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur Int32 pour la culture actuelle.Calls Int32.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int32 value for the current culture.
Int64 Appelle Int64.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur Int64 pour la culture actuelle.Calls Int64.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int64 value for the current culture.
SByte Appelle SByte.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur SByte pour la culture actuelle.Calls SByte.ToString("G", NumberFormatInfo.CurrentInfo) to format the SByte value for the current culture.
Single Appelle Single.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur Single pour la culture actuelle.Calls Single.ToString("G", NumberFormatInfo.CurrentInfo) to format the Single value for the current culture.
UInt16 Appelle UInt16.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur UInt16 pour la culture actuelle.Calls UInt16.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt16 value for the current culture.
UInt32 Appelle UInt32.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur UInt32 pour la culture actuelle.Calls UInt32.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt32 value for the current culture.
UInt64 Appelle UInt64.ToString("G", NumberFormatInfo.CurrentInfo) afin de mettre en forme la valeur UInt64 pour la culture actuelle.Calls UInt64.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt64 value for the current culture.

Méthode ToString et chaînes de formatThe ToString method and format strings

Le recours à la méthode ToString ou la substitution de ToString ne valent que lorsqu'un objet a une seule représentation sous forme de chaîne possible.Relying on the default ToString method or overriding ToString is appropriate when an object has a single string representation. Toutefois, la valeur d'un objet a souvent plusieurs représentations.However, the value of an object often has multiple representations. Par exemple, une température peut être exprimée en degrés Fahrenheit, Celsius ou Kelvin.For example, a temperature can be expressed in degrees Fahrenheit, degrees Celsius, or kelvins. De même, la valeur entière 10 peut être représentée de plusieurs façons, dont 10, 10,0, 1,0e01 ou $10,00.Similarly, the integer value 10 can be represented in numerous ways, including 10, 10.0, 1.0e01, or $10.00.

Pour permettre à une même valeur d’avoir plusieurs représentations sous forme de chaîne, .NET utilise des chaînes de format.To enable a single value to have multiple string representations, .NET uses format strings. Une chaîne de format est une chaîne qui contient un ou plusieurs spécificateurs de format prédéfinis, constitués d'un ou de plusieurs caractères servant à définir la manière dont la méthode ToString doit mettre en forme sa sortie.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. La chaîne de format est ensuite passée en tant que paramètre à la méthode ToString de l'objet et détermine la manière dont la représentation sous forme de chaîne de la valeur de cet objet doit apparaître.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.

Dans .NET, tous les types numériques, types de date et d’heure et types énumération prennent en charge un jeu prédéfini de spécificateurs de format.All numeric types, date and time types, and enumeration types in .NET support a predefined set of format specifiers. Vous pouvez aussi utiliser des chaînes de format pour définir plusieurs représentations sous forme de chaîne de vos types de données définis par l'application.You can also use format strings to define multiple string representations of your application-defined data types.

Chaînes de format standardStandard format strings

Une chaîne de format standard comprend un spécificateur de format unique, qui est un caractère alphabétique définissant la représentation sous forme de chaîne de l'objet auquel il s'applique, ainsi qu'un spécificateur de précision facultatif qui affecte le nombre de chiffres affichés dans la chaîne de résultat.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 le spécificateur de précision est omis ou n'est pas pris en charge, un spécificateur de format standard équivaut à une chaîne de format standard.If the precision specifier is omitted or is not supported, a standard format specifier is equivalent to a standard format string.

.NET définit un jeu de spécificateurs de format standard pour tous les types numériques, types de date et d’heure et types énumération..NET defines a set of standard format specifiers for all numeric types, all date and time types, and all enumeration types. Par exemple, chacune de ces catégories prend en charge un spécificateur de format standard "G", lequel définit une représentation sous forme de chaîne générale d'une valeur de ce type.For example, each of these categories supports a "G" standard format specifier, which defines a general string representation of a value of that type.

Les chaînes de format standard pour les types énumération contrôlent directement la représentation sous forme de chaîne d'une valeur.Standard format strings for enumeration types directly control the string representation of a value. Les chaînes de format passées à la méthode ToString d'une valeur d'énumération déterminent si la valeur est affichée en utilisant son nom de chaîne (spécificateurs de format "G" et "F"), sa valeur intégrale sous-jacente (spécificateur de format "D") ou sa valeur hexadécimale (spécificateur de format "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). L'exemple suivant illustre l'utilisation de chaînes de format standard pour mettre en forme une valeur d'énumération 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

Pour plus d’informations sur les chaînes de format d’énumération, consultez Enumeration Format Strings.For information about enumeration format strings, see Enumeration Format Strings.

Les chaînes de format standard pour les types numériques définissent généralement une chaîne de résultat dont l'apparence précise est contrôlée par une ou plusieurs valeurs de propriété.Standard format strings for numeric types usually define a result string whose precise appearance is controlled by one or more property values. Par exemple, le spécificateur de format "C" met en forme un nombre en tant que valeur monétaire.For example, the "C" format specifier formats a number as a currency value. Lorsque vous appelez la méthode ToString avec, comme seul paramètre, le spécificateur de format "C", les valeurs des propriétés suivantes de l'objet NumberFormatInfo de la culture actuelle sont utilisées pour définir la représentation sous forme de chaîne de la valeur numérique :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:

  • Propriété CurrencySymbol , qui spécifie le symbole monétaire de la culture actuelle.The CurrencySymbol property, which specifies the current culture’s currency symbol.

  • Propriété CurrencyNegativePattern ou CurrencyPositivePattern , qui retourne un entier déterminant :The CurrencyNegativePattern or CurrencyPositivePattern property, which returns an integer that determines the following:

    • la position du symbole monétaire ;The placement of the currency symbol.

    • si les valeurs négatives sont indiquées par un signe négatif devant, par un signe négatif derrière ou par des parenthèses ;Whether negative values are indicated by a leading negative sign, a trailing negative sign, or parentheses.

    • si un espace apparaît entre la valeur numérique et le symbole monétaire.Whether a space appears between the numeric value and the currency symbol.

  • Propriété CurrencyDecimalDigits , qui définit le nombre de chiffres fractionnaires dans la chaîne de résultat.The CurrencyDecimalDigits property, which defines the number of fractional digits in the result string.

  • Propriété CurrencyDecimalSeparator , qui définit le symbole de séparateur décimal dans la chaîne de résultat.The CurrencyDecimalSeparator property, which defines the decimal separator symbol in the result string.

  • Propriété CurrencyGroupSeparator , qui définit le symbole du séparateur de groupes.The CurrencyGroupSeparator property, which defines the group separator symbol.

  • Propriété CurrencyGroupSizes , qui définit le nombre de chiffres de chaque groupe situé à gauche du séparateur décimal.The CurrencyGroupSizes property, which defines the number of digits in each group to the left of the decimal.

  • Propriété NegativeSign , qui détermine le signe négatif utilisé dans la chaîne de résultat si les parenthèses ne sont pas utilisées pour indiquer des valeurs négatives.The NegativeSign property, which determines the negative sign used in the result string if parentheses are not used to indicate negative values.

De plus, les chaînes de format numériques peuvent inclure un spécificateur de précision.In addition, numeric format strings may include a precision specifier. La signification de ce spécificateur dépend de la chaîne de format avec laquelle il est utilisé, mais il indique généralement le nombre total de chiffres ou le nombre de chiffres fractionnaires qui doivent s'afficher dans la chaîne de résultat.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. Par exemple, le code suivant utilise la chaîne numérique standard "X4" et un spécificateur de précision pour créer une valeur de chaîne qui comprend quatre chiffres hexadécimaux.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

Pour plus d’informations sur les chaînes de format numériques standard, consultez Standard Numeric Format Strings.For more information about standard numeric formatting strings, see Standard Numeric Format Strings.

Les chaînes de format standard pour les valeurs de date et d'heure sont des alias de chaînes de format personnalisées stockées par une propriété DateTimeFormatInfo particulière.Standard format strings for date and time values are aliases for custom format strings stored by a particular DateTimeFormatInfo property. Par exemple, appeler la méthode ToString d'une valeur de date et d'heure avec le spécificateur de format "D" affiche la date et l'heure en utilisant la chaîne de format personnalisée stockée dans la propriété DateTimeFormatInfo.LongDatePattern de la culture actuelle.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. (Pour plus d’informations sur les chaînes de format personnalisées, consultez la section suivante.) L’exemple suivant illustre cette relation.(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

Pour plus d’informations sur les chaînes de format de date et heure standard, consultez Standard Date and Time Format Strings.For more information about standard date and time format strings, see Standard Date and Time Format Strings.

Vous pouvez aussi utiliser des chaînes de format standard pour définir la représentation sous forme de chaîne produite par la méthode ToString(String) d'un objet défini par l'application.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. Vous pouvez définir les spécificateurs de format standard spécifiques que votre objet prend en charge, et déterminer s'ils respectent la casse.You can define the specific standard format specifiers that your object supports, and you can determine whether they are case-sensitive or case-insensitive. Votre implémentation de la méthode ToString(String) doit prendre en charge les éléments suivants :Your implementation of the ToString(String) method should support the following:

  • Spécificateur de format "G" qui représente un format habituel ou commun de l'objet.A "G" format specifier that represents a customary or common format of the object. La surcharge sans paramètre de la méthode ToString de votre objet doit appeler sa surcharge ToString(String) et lui passer la chaîne de format standard "G".The parameterless overload of your object's ToString method should call its ToString(String) overload and pass it the "G" standard format string.

  • Prise en charge d'un spécificateur de format qui est égal à une référence null (Nothing en Visual Basic).Support for a format specifier that is equal to a null reference (Nothing in Visual Basic). Un spécificateur de format qui est égal à une référence null doit être considéré comme équivalent au spécificateur de format "G".A format specifier that is equal to a null reference should be considered equivalent to the "G" format specifier.

Par exemple, une classe Temperature peut stocker en interne la température en degrés Celsius et utiliser des spécificateurs de format pour représenter la valeur de l'objet Temperature en degrés Celsius, Fahrenheit et 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. L'exemple suivant illustre cette situation.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.

Chaînes de format personnaliséesCustom format strings

Outre les chaînes de format standard, .NET définit des chaînes de format personnalisées pour les valeurs numériques et les valeurs de date et d’heure.In addition to the standard format strings, .NET defines custom format strings for both numeric values and date and time values. Une chaîne de format personnalisée se compose d'un ou de plusieurs spécificateurs de format personnalisés qui définissent la représentation sous forme de chaîne d'une valeur.A custom format string consists of one or more custom format specifiers that define the string representation of a value. Par exemple, la chaîne de format de date et d'heure personnalisée "yyyy\mm\dd hh:mm:ffff t zzz" convertit une date en sa représentation sous forme de chaîne "2008/11/15 07:45:00.0000 P -08:00" pour la culture 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. De même, la chaîne de format personnalisée "0000" convertit la valeur entière 12 en "0012".Similarly, the custom format string "0000" converts the integer value 12 to "0012". Pour obtenir la liste complète des chaînes de format personnalisées, consultez Custom Date and Time Format Strings et 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 une chaîne de format se compose d'un seul spécificateur de format personnalisé, le spécificateur de format doit être précédé du symbole de pourcentage (%) pour éviter toute confusion avec un spécificateur de format standard.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. L'exemple suivant utilise le spécificateur de format personnalisé "M" pour afficher un nombre à un chiffre ou à deux chiffres du mois d'une date particulière.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

De nombreuses chaînes de format standard pour les valeurs de date et d'heure sont des alias de chaînes de format personnalisées qui sont définies par les propriétés de l'objet 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. Les chaînes de format personnalisées offrent également une souplesse considérable en matière de mise en forme définie par l'application pour les valeurs numériques ou les valeurs de date et d'heure.Custom format strings also offer considerable flexibility in providing application-defined formatting for numeric values or date and time values. Vous pouvez définir vos propres chaînes de résultat personnalisées à la fois pour les valeurs numériques et pour les valeurs de date et d'heure en combinant plusieurs spécificateurs de format personnalisés dans une chaîne de format personnalisée unique.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. L'exemple suivant définit une chaîne de format personnalisée qui affiche le jour de la semaine entre parenthèses après le nom du mois, le jour et l'année.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)      

L’exemple ci-dessous définit une chaîne de format personnalisée qui affiche une valeur Int64 sous la forme d’un numéro de téléphone américain standard à sept chiffres avec son indicatif régional.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

Bien que les chaînes de format standard puissent généralement gérer la plupart des besoins de mise en forme pour vos types définis par l'application, vous pouvez également définir des spécificateurs de format personnalisés pour mettre en forme vos types.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.

Chaînes de format et types .NETFormat strings and .NET types

Tous les types numériques (c’est-à-dire, les types Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64 et BigInteger), ainsi que les types DateTime, DateTimeOffset, TimeSpan et Guid, et tous les types énumération, prennent en charge la mise en forme avec des chaînes de format.All numeric types (that is, the Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64, and BigInteger types), as well as the DateTime, DateTimeOffset, TimeSpan, Guid, and all enumeration types, support formatting with format strings. Pour plus d’informations sur les chaînes de format spécifiques prises en charge par chaque type, consultez les rubriques suivantes :For information on the specific format strings supported by each type, see the following topics:

TitreTitle DéfinitionDefinition
Chaînes de format numériques standardStandard Numeric Format Strings Décrit des chaînes de format standard qui créent des représentations sous forme de chaîne couramment utilisées de valeurs numériques.Describes standard format strings that create commonly used string representations of numeric values.
Chaînes de format numériques personnaliséesCustom Numeric Format Strings Décrit des chaînes de format personnalisées qui créent des formats spécifiques à l'application pour les valeurs numériques.Describes custom format strings that create application-specific formats for numeric values.
Chaînes de format de date et d'heure standardStandard Date and Time Format Strings Décrit des chaînes de format standard qui créent des représentations courantes de valeurs DateTime et DateTimeOffset sous forme de chaînes.Describes standard format strings that create commonly used string representations of DateTime and DateTimeOffset values.
Chaînes de format de date et d’heure personnaliséesCustom Date and Time Format Strings Décrit des chaînes de format personnalisées qui créent des formats propres à l'application pour les valeurs DateTime et DateTimeOffset.Describes custom format strings that create application-specific formats for DateTime and DateTimeOffset values.
Chaînes de format TimeSpan standardStandard TimeSpan Format Strings Décrit des chaînes de format standard qui créent des représentations sous forme de chaîne couramment utilisées d'intervalles de temps.Describes standard format strings that create commonly used string representations of time intervals.
Chaînes de format TimeSpan personnaliséesCustom TimeSpan Format Strings Décrit des chaînes de format personnalisées qui créent des formats spécifiques à l'application pour les intervalles de temps.Describes custom format strings that create application-specific formats for time intervals.
Enumeration Format StringsEnumeration Format Strings Décrit les chaînes de format standard qui sont utilisées pour créer des représentations sous forme de chaîne de valeurs d'énumération.Describes standard format strings that are used to create string representations of enumeration values.
Guid.ToString(String) Décrit les chaînes de format standard pour les valeurs Guid .Describes standard format strings for Guid values.

Mise en forme dépendante de la culture avec les fournisseurs de formatCulture-sensitive formatting with format providers

Si les spécificateurs de format vous permettent de personnaliser la mise en forme d'objets, la production, pour ces derniers, d'une représentation sous forme de chaîne explicite requiert souvent des informations de mise en forme supplémentaires.Although format specifiers let you customize the formatting of objects, producing a meaningful string representation of objects often requires additional formatting information. Par exemple, la mise en forme d'un nombre en tant que valeur monétaire en utilisant la chaîne de format standard "C" ou une chaîne de format personnalisée telle que "$ #, #.00" requiert au minimum l'existence d'informations à inclure dans la chaîne mise en forme concernant le symbole monétaire, le séparateur de groupes et le séparateur décimal appropriés.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. Dans .NET, ces informations de mise en forme supplémentaires sont disponibles sur l’interface IFormatProvider, laquelle est fournie comme paramètre d’une ou plusieurs surcharges de la méthode ToString de types numériques et de types de date et d’heure.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. Des implémentations de IFormatProvider sont utilisées dans .NET pour prendre en charge la mise en forme propre à la culture.IFormatProvider implementations are used in .NET to support culture-specific formatting. L'exemple suivant montre comment la représentation d'un objet sous forme de chaîne évolue lorsqu'il est mis en forme avec trois objets IFormatProvider représentant des cultures différentes.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 €

L'interface IFormatProvider inclut une méthode, GetFormat(Type), qui a un seul paramètre spécifiant le type d'objet qui fournit les informations de mise en forme.The IFormatProvider interface includes one method, GetFormat(Type), which has a single parameter that specifies the type of object that provides formatting information. Si la méthode peut fournir un objet de ce type, elle le retourne.If the method can provide an object of that type, it returns it. Sinon, elle retourne une référence null (Nothing en Visual Basic).Otherwise, it returns a null reference (Nothing in Visual Basic).

IFormatProvider.GetFormat est une méthode de rappel.IFormatProvider.GetFormat is a callback method. Lorsque vous appelez une surcharge de méthode ToString qui inclut un paramètre IFormatProvider , elle appelle la méthode GetFormat de cet objet IFormatProvider .When you call a ToString method overload that includes an IFormatProvider parameter, it calls the GetFormat method of that IFormatProvider object. La méthode GetFormat est chargée de retourner les informations de mise en forme requises, spécifiées par son paramètre formatType , à la méthode 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.

Certaines méthodes de mise en forme ou de conversion de chaînes incluent un paramètre de type IFormatProvider, mais la valeur de ce paramètre est souvent ignorée lorsque la méthode est appelée.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. Le tableau suivant répertorie certaines des méthodes de mise en forme qui utilisent le paramètre et le type de l'objet Type qu'elles passent à la méthode 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éthodeMethod Type de paramètre formatTypeType of formatType parameter
Méthode ToString de types numériquesToString method of numeric types System.Globalization.NumberFormatInfo
Méthode ToString de types de date et d'heureToString method of date and time types System.Globalization.DateTimeFormatInfo
String.Format System.ICustomFormatter
StringBuilder.AppendFormat System.ICustomFormatter

Notes

Les méthodes ToString des types numériques et des types de date et d'heure sont surchargées, et seules certaines des surcharges incluent un paramètre 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 une méthode n'a pas de paramètre de type IFormatProvider, l'objet retourné par la propriété CultureInfo.CurrentCulture est passé à la place.If a method does not have a parameter of type IFormatProvider, the object that is returned by the CultureInfo.CurrentCulture property is passed instead. Par exemple, un appel à la méthode Int32.ToString() par défaut a, pour résultat, un appel de méthode semblable au suivant : 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 propose trois classes qui implémentent IFormatProvider :.NET provides three classes that implement IFormatProvider:

Vous pouvez aussi implémenter votre propre fournisseur de format en remplacement de l'une de ces classes.You can also implement your own format provider to replace any one of these classes. Toutefois, la méthode GetFormat de votre implémentation doit retourner un objet du type répertorié dans le tableau précédent s'il doit fournir des informations de mise en forme à la méthode 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.

Mise en forme dépendante de la culture des valeurs numériquesCulture-sensitive formatting of numeric values

Par défaut, la mise en forme des valeurs numériques est dépendante de la culture.By default, the formatting of numeric values is culture-sensitive. Si vous ne spécifiez pas de culture lorsque vous appelez une méthode de mise en forme, les conventions de mise en forme de la culture actuelle du thread sont utilisées.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. Ceci est illustré dans l'exemple ci-dessous où la culture actuelle du thread est changée quatre fois avant que la méthode Decimal.ToString(String) soit appelée.This is illustrated in the following example, which changes the current thread culture four times and then calls the Decimal.ToString(String) method. Dans chaque cas, la chaîne obtenue reflète les conventions de mise en forme de la culture actuelle.In each case, the result string reflects the formatting conventions of the current culture. Ceci tient au fait que les méthodes ToString et ToString(String) encapsulent les appels à la méthode ToString(String, IFormatProvider) de chaque type numérique.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 €

Vous pouvez également mettre en forme une valeur numérique pour une culture spécifique en appelant une surcharge ToString dotée d'un paramètre provider et en lui passant l'un ou l'autre des éléments suivants :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:

L'exemple suivant utilise des objets NumberFormatInfo qui représentent les cultures Anglais (États-Unis) et Anglais (Royaume-Uni), ainsi que les cultures neutres Français et Russe pour mettre en forme un nombre à virgule flottante.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

Mise en forme dépendante de la culture des valeurs de date et d’heureCulture-sensitive formatting of date and time values

Par défaut, la mise en forme des valeurs de date et d'heure est dépendante de la culture.By default, the formatting of date and time values is culture-sensitive. Si vous ne spécifiez pas de culture lorsque vous appelez une méthode de mise en forme, les conventions de mise en forme de la culture actuelle du thread sont utilisées.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. Ceci est illustré dans l'exemple ci-dessous où la culture actuelle du thread est changée quatre fois avant que la méthode DateTime.ToString(String) soit appelée.This is illustrated in the following example, which changes the current thread culture four times and then calls the DateTime.ToString(String) method. Dans chaque cas, la chaîne obtenue reflète les conventions de mise en forme de la culture actuelle.In each case, the result string reflects the formatting conventions of the current culture. Ceci tient au fait que les méthodes DateTime.ToString(), DateTime.ToString(String), DateTimeOffset.ToString()et DateTimeOffset.ToString(String) encapsulent les appels aux méthodes DateTime.ToString(String, IFormatProvider) et 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 

Vous pouvez également mettre en forme une valeur de date et d'heure pour une culture spécifique en appelant une surcharge DateTime.ToString ou DateTimeOffset.ToString dotée d'un paramètre provider et en lui passant l'un ou l'autre des éléments suivants :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:

L'exemple suivant utilise des objets DateTimeFormatInfo qui représentent les cultures Anglais (États-Unis) et Anglais (Royaume-Uni), ainsi que les cultures neutres Français et Russe pour mettre en forme une date.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

Interface IFormattableThe IFormattable interface

En règle générale, les types qui surchargent la méthode ToString avec une chaîne de format et un paramètre IFormatProvider implémentent également l'interface IFormattable .Typically, types that overload the ToString method with a format string and an IFormatProvider parameter also implement the IFormattable interface. Cette interface comprend un seul membre, IFormattable.ToString(String, IFormatProvider), qui inclut comme paramètres une chaîne de format et un fournisseur de format.This interface has a single member, IFormattable.ToString(String, IFormatProvider), that includes both a format string and a format provider as parameters.

L'implémentation de l'interface IFormattable pour votre classe définie par l'application présente deux avantages :Implementing the IFormattable interface for your application-defined class offers two advantages:

L'exemple suivant définit une classe Temperature qui implémente l'interface IFormattable .The following example defines a Temperature class that implements the IFormattable interface. Il prend en charge les spécificateurs de format "C" ou "G" pour afficher la température en Celsius, le spécificateur de format "F" pour afficher la température en Fahrenheit et le spécificateur de format "K" pour afficher la température en 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

L'exemple suivant instancie un objet Temperature.The following example instantiates a Temperature object. Il appelle ensuite la méthode ToString et utilise plusieurs chaînes de format composites pour obtenir des représentations sous forme de chaîne différentes d'un objet Temperature .It then calls the ToString method and uses several composite format strings to obtain different string representations of a Temperature object. Chacun de ces appels de méthode appelle, à son tour, l'implémentation d' IFormattable de la classe 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

Mise en forme compositeComposite formatting

Certaines méthodes, telles que String.Format et StringBuilder.AppendFormat, prennent en charge la mise en forme composite.Some methods, such as String.Format and StringBuilder.AppendFormat, support composite formatting. Une chaîne de format composite est un genre de modèle retournant une seule chaîne qui incorpore la représentation sous forme de chaîne de zéro, un ou plusieurs objets.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. Chaque objet est représenté dans la chaîne de format composite par un élément de mise en forme indexé.Each object is represented in the composite format string by an indexed format item. L'index de l'élément de mise en forme correspond à la position de l'objet qu'il représente dans la liste de paramètres de la méthode.The index of the format item corresponds to the position of the object that it represents in the method's parameter list. Les index sont de base zéro.Indexes are zero-based. Par exemple, dans l'appel suivant à la méthode String.Format, le premier élément de mise en forme, {0:D}, est remplacé par la représentation sous forme de chaîne de thatDate ; le deuxième élément de mise en forme, {1}, est remplacé par la représentation sous forme de chaîne item1 ; le troisième élément de mise en forme, {2:C2}, est remplacé par la représentation sous forme de chaîne 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.

En plus de remplacer un élément de format par la représentation sous forme de chaîne de l'objet correspondant, les éléments de format vous permettent également de contrôler les éléments suivants :In addition to replacing a format item with the string representation of its corresponding object, format items also let you control the following:

  • La façon spécifique dont un objet est représenté sous forme de chaîne, si l'objet implémente l'interface IFormattable et prend en charge les chaînes de format.The specific way in which an object is represented as a string, if the object implements the IFormattable interface and supports format strings. Ceci se fait en faisant suivre l'index de l'élément de format d'un : (deux-points), suivi d'une chaîne de format valide.You do this by following the format item's index with a : (colon) followed by a valid format string. L'exemple précédent a fait cela en mettant en forme une valeur de date avec la chaîne de format "d" (modèle de date courte) (par exemple {0:d}) et en mettant en forme une valeur numérique avec la chaîne de format "C2" (par exemple {2:C2} pour représenter le nombre comme valeur monétaire avec deux décimales.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.

  • La largeur du champ qui contient la représentation sous forme de chaîne de l'objet, et l'alignement de la représentation sous forme de chaîne de ce champ.The width of the field that contains the object's string representation, and the alignment of the string representation in that field. Ceci se fait en faisant suivre l'index de l'élément de format d'une , (virgule), suivie de la largeur du champ.You do this by following the format item's index with a , (comma) followed the field width. La chaîne est alignée à droite dans le champ si la largeur du champ est une valeur positive, et elle est alignée à gauche si la largeur du champ est une valeur négative.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. L'exemple suivant aligne à gauche des valeurs de date dans un champ de 20 caractères, et aligne à droite des valeurs décimales avec une décimale dans un champ de 11 caractères.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
    

    Notez que si le composant de chaîne d'alignement et le composant de chaîne de format sont présents, le premier a priorité sur le deuxième (par exemple {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}.

Pour plus d’informations sur la mise en forme composite, consultez Composite Formatting.For more information about composite formatting, see Composite Formatting.

Mise en forme personnalisée avec ICustomFormatterCustom formatting with ICustomFormatter

Deux méthodes de mise en forme composites, String.Format(IFormatProvider, String, Object[]) et StringBuilder.AppendFormat(IFormatProvider, String, Object[]), incluent également un paramètre de fournisseur de format qui prend en charge la mise en forme personnalisée.Two composite formatting methods, String.Format(IFormatProvider, String, Object[]) and StringBuilder.AppendFormat(IFormatProvider, String, Object[]), include a format provider parameter that supports custom formatting. Lorsque l'une de ces méthodes de mise en forme est appelée, elle passe à la méthode Type du fournisseur de format un objet ICustomFormatter qui représente une interface GetFormat .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. La méthode GetFormat est alors chargée de retourner l'implémentation d' ICustomFormatter qui fournit la mise en forme personnalisée.The GetFormat method is then responsible for returning the ICustomFormatter implementation that provides custom formatting.

L'interface ICustomFormatter a une méthode unique, Format(String, Object, IFormatProvider), qui est appelée automatiquement par une méthode de mise en forme composite, une fois pour chaque élément de mise en forme dans une chaîne de format composite.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. La méthode Format(String, Object, IFormatProvider) a trois paramètres : une chaîne de format, qui représente l'argument formatString dans un élément de mise en forme, un objet à mettre en forme et un objet IFormatProvider qui fournit des services de mise en forme.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. En général, la classe qui implémente ICustomFormatter implémente également IFormatProvider; ce dernier paramètre est donc une référence à la classe de mise en forme personnalisée elle-même.Typically, the class that implements ICustomFormatter also implements IFormatProvider, so this last parameter is a reference to the custom formatting class itself. La méthode retourne une représentation sous forme de chaîne mise en forme personnalisée de l'objet à mettre en forme.The method returns a custom formatted string representation of the object to be formatted. Si la méthode ne peut pas mettre en forme l'objet, elle doit retourner une référence null (Nothing en Visual Basic).If the method cannot format the object, it should return a null reference (Nothing in Visual Basic).

L'exemple suivant fournit une implémentation d' ICustomFormatter nommée ByteByByteFormatter qui affiche des valeurs entières sous la forme d'une séquence de valeurs hexadécimales à deux chiffres suivie d'un espace.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

L'exemple suivant utilise la classe ByteByByteFormatter pour mettre en forme des valeurs entières.The following example uses the ByteByByteFormatter class to format integer values. Notez que la méthode ICustomFormatter.Format est appelée plusieurs fois dans le deuxième appel de méthode String.Format(IFormatProvider, String, Object[]), et que le fournisseur NumberFormatInfo par défaut est utilisé dans le troisième appel de méthode, car la méthode .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 ne reconnaît pas la chaîne de format "N0" et retourne une référence null (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
TitreTitle DéfinitionDefinition
Chaînes de format numériques standardStandard Numeric Format Strings Décrit des chaînes de format standard qui créent des représentations sous forme de chaîne couramment utilisées de valeurs numériques.Describes standard format strings that create commonly used string representations of numeric values.
Chaînes de format numériques personnaliséesCustom Numeric Format Strings Décrit des chaînes de format personnalisées qui créent des formats spécifiques à l'application pour les valeurs numériques.Describes custom format strings that create application-specific formats for numeric values.
Chaînes de format de date et d'heure standardStandard Date and Time Format Strings Décrit des chaînes de format standard qui créent des représentations sous forme de chaîne couramment utilisées de valeurs DateTime .Describes standard format strings that create commonly used string representations of DateTime values.
Chaînes de format de date et d’heure personnaliséesCustom Date and Time Format Strings Décrit des chaînes de format personnalisées qui créent des formats spécifiques à l'application pour les valeurs DateTime .Describes custom format strings that create application-specific formats for DateTime values.
Chaînes de format TimeSpan standardStandard TimeSpan Format Strings Décrit des chaînes de format standard qui créent des représentations sous forme de chaîne couramment utilisées d'intervalles de temps.Describes standard format strings that create commonly used string representations of time intervals.
Chaînes de format TimeSpan personnaliséesCustom TimeSpan Format Strings Décrit des chaînes de format personnalisées qui créent des formats spécifiques à l'application pour les intervalles de temps.Describes custom format strings that create application-specific formats for time intervals.
Enumeration Format StringsEnumeration Format Strings Décrit les chaînes de format standard qui sont utilisées pour créer des représentations sous forme de chaîne de valeurs d'énumération.Describes standard format strings that are used to create string representations of enumeration values.
Mise en forme compositeComposite Formatting Explique comment incorporer une ou plusieurs valeurs mises en forme dans une chaîne.Describes how to embed one or more formatted values in a string. La chaîne peut ensuite être affichée dans la console ou écrite dans un flux.The string can subsequently be displayed on the console or written to a stream.
Exécution d’opérations de mise en formePerforming Formatting Operations Répertorie les rubriques qui fournissent des instructions pas à pas pour effectuer des opérations de mise en forme spécifiques.Lists topics that provide step-by-step instructions for performing specific formatting operations.
Analyse de chaînesParsing Strings Décrit comment initialiser des objets aux valeurs décrites par des représentations sous forme de chaîne de ces objets.Describes how to initialize objects to the values described by string representations of those objects. L'analyse est l'opération inverse de la mise en forme.Parsing is the inverse operation of formatting.

ReferenceReference