IFormattable.ToString(String, IFormatProvider) Méthode

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Met en forme la valeur de l’instance actuelle en utilisant le format spécifié.

public:
 System::String ^ ToString(System::String ^ format, IFormatProvider ^ formatProvider);

public string ToString (string format, IFormatProvider formatProvider);

public string ToString (string? format, IFormatProvider? formatProvider);

abstract member ToString : string * IFormatProvider -> string

Public Function ToString (format As String, formatProvider As IFormatProvider) As String

Paramètres

format: String

Format à utiliser.

- ou -

Référence null (Nothing en Visual Basic) pour utiliser le format par défaut défini pour le type de l’implémentation IFormattable.

formatProvider: IFormatProvider

Fournisseur à utiliser pour mettre en forme la valeur.

- ou -

Référence null (Nothing en Visual Basic) pour obtenir les informations de format numérique dans les paramètres régionaux actuels du système d’exploitation.

Retours

String

Valeur de l’instance actuelle dans le format spécifié.

Exemples

L’exemple suivant illustre une Temperature classe qui implémente la ToString méthode . Cet exemple de code fait partie d’un exemple plus grand fourni pour la IFormattable classe .

using System;
using System.Globalization;

public class Temperature : IFormattable
{
   private decimal temp;

   public Temperature(decimal temperature)
   {
      if (temperature < -273.15m)
        throw new ArgumentOutOfRangeException(String.Format("{0} is less than absolute zero.",
                                              temperature));
      this.temp = temperature;
   }

   public decimal Celsius
   {
      get { return temp; }
   }

   public decimal Fahrenheit
   {
      get { return temp * 9 / 5 + 32; }
   }

   public decimal Kelvin
   {
      get { return temp + 273.15m; }
   }

   public override string ToString()
   {
      return this.ToString("G", CultureInfo.CurrentCulture);
   }

   public string ToString(string format)
   {
      return this.ToString(format, CultureInfo.CurrentCulture);
   }

   public string ToString(string format, IFormatProvider provider)
   {
      if (String.IsNullOrEmpty(format)) format = "G";
      if (provider == null) provider = CultureInfo.CurrentCulture;

      switch (format.ToUpperInvariant())
      {
         case "G":
         case "C":
            return temp.ToString("F2", provider) + " °C";
         case "F":
            return Fahrenheit.ToString("F2", provider) + " °F";
         case "K":
            return Kelvin.ToString("F2", provider) + " K";
         default:
            throw new FormatException(String.Format("The {0} format string is not supported.", format));
      }
   }
}

open System
open System.Globalization

type Temperature(temperature: decimal) =
    do 
        if temperature < -273.15M then
            raise (ArgumentOutOfRangeException $"{temperature} is less than absolute zero.")

    member _.Celsius =
        temperature

    member _.Fahrenheit =
        temperature * 9M / 5M + 32M

    member _.Kelvin =
        temperature + 273.15m

    override this.ToString() =
        this.ToString("G", CultureInfo.CurrentCulture)

    member this.ToString(format) =
        this.ToString(format, CultureInfo.CurrentCulture)

    member this.ToString(format, provider: IFormatProvider) =
        let format =
            if String.IsNullOrEmpty format then "G"
            else format

        let provider =
            if isNull provider then 
                CultureInfo.CurrentCulture :> IFormatProvider
            else provider

        match format.ToUpperInvariant() with
        | "G" | "C" ->
            temperature.ToString("F2", provider) + " °C"
        | "F" ->
            this.Fahrenheit.ToString("F2", provider) + " °F"
        | "K" ->
            this.Kelvin.ToString("F2", provider) + " K"
        | _ ->
            raise (FormatException $"The {format} format string is not supported.")

    interface IFormattable with
        member this.ToString(format, provider) = this.ToString(format, provider)

Imports System.Globalization

Public Class Temperature : Implements IFormattable
   Private temp As Decimal
   
   Public Sub New(temperature As Decimal)
      If temperature < -273.15 Then _ 
        Throw New ArgumentOutOfRangeException(String.Format("{0} is less than absolute zero.", _
                                              temperature))
      Me.temp = temperature
   End Sub
   
   Public ReadOnly Property Celsius As Decimal
      Get
         Return temp
      End Get
   End Property
   
   Public ReadOnly Property Fahrenheit As Decimal
      Get
         Return temp * 9 / 5 + 32
      End Get
   End Property
   
   Public ReadOnly Property Kelvin As Decimal
      Get
         Return temp + 273.15d
      End Get
   End Property

   Public Overrides Function ToString() As String
      Return Me.ToString("G", CultureInfo.CurrentCulture)
   End Function
      
   Public Overloads Function ToString(fmt As String) As String
      Return Me.ToString(fmt, CultureInfo.CurrentCulture)
   End Function
   
   Public Overloads Function ToString(fmt As String, provider As IFormatProvider) _
                   As String _
                   Implements IFormattable.ToString
      If String.IsNullOrEmpty(fmt) Then fmt = "G"
      If provider Is Nothing Then provider = CultureInfo.CurrentCulture
      
      Select Case fmt.ToUpperInvariant()
         Case "G", "C"
            Return temp.ToString("F2", provider) + " °C" 
         Case "F"
            Return Fahrenheit.ToString("F2", provider) + " °F"
         Case "K"
            Return Kelvin.ToString("F2", provider) + " K"
         Case Else
            Throw New FormatException(String.Format("The {0} format string is not supported.", fmt))
      End Select
   End Function
End Class

Remarques

La ToString méthode convertit une valeur en une représentation sous forme de chaîne qui peut être exprimée de plusieurs façons. Son format précis dépend de symboles spécifiques ou d’un ordre spécifié défini par des cultures, des professions ou des industries spécifiques. Vous pouvez appeler la méthode directement. Il est également appelé automatiquement par les Convert.ToString(Object) méthodes et Convert.ToString(Object, IFormatProvider) et par les méthodes qui utilisent la fonctionnalité de mise en forme composite dans le .NET Framework, telles que String.Format(String, Object[]), Console.WriteLine(String, Object[])et StringBuilder.AppendFormat(String, Object[]). (Pour plus d’informations, consultez Mise en forme composite.)

Les méthodes de mise en forme composite appellent la ToString méthode une fois pour chaque élément de format dans une chaîne de format. Les paramètres passés à la méthode dépendent de la méthode de mise en forme spécifique appelée et du contenu de l’élément de format, comme suit :

Si l’élément de format n’inclut pas de chaîne de format (par exemple, si l’élément de format est simplement {0}), il est passé null comme valeur du System.String paramètre .
Si l’élément de format inclut une chaîne de format (par exemple, {0:G}), cette chaîne de format est passée comme valeur du System.String paramètre .
Si l’appel de méthode d’origine n’inclut pas de System.IFormatProvider paramètre, CultureInfo.CurrentCulture est passé comme valeur du System.IFormatProvider paramètre .
Si l’appel de méthode d’origine inclut un System.IFormatProvider paramètre, le fournisseur fourni dans l’appel de méthode est passé comme valeur du System.IFormatProvider paramètre .

Notes

L’implémentation d’un ToString objet est appelée par les méthodes de mise en forme composite uniquement si elles ne reçoivent pas de ICustomFormatter fournisseur de format, ou si la Format méthode du fournisseur de format personnalisé retourne null.

Le .NET Framework comprend trois fournisseurs de format, qui implémentent tous l’interface IFormatProvider :

NumberFormatInfo fournit des informations de mise en forme numériques, telles que les caractères à utiliser pour les séparateurs décimaux et de groupes, ainsi que l’orthographe et le placement des symboles monétaires dans les valeurs monétaires.
DateTimeFormatInfo fournit des informations de mise en forme liées à la date et à l’heure, telles que la position du mois, le jour et l’année dans un modèle de date.
CultureInfo contient les informations de mise en forme par défaut dans une culture spécifique, y compris les informations de format numérique et les informations de mise en forme liées à la date et à l’heure.

En outre, vous pouvez définir votre propre fournisseur de format personnalisé.

Notes pour les responsables de l’implémentation

La ToString(String, IFormatProvider) méthode doit prendre en charge le spécificateur de format « G » (général). Outre le spécificateur « G », la classe peut définir la liste des spécificateurs de format qu’elle prend en charge. En outre, la classe doit être préparée pour gérer un spécificateur de format qui est null. Pour plus d’informations sur la mise en forme et les codes de mise en forme, consultez Mise en forme des types.

S’applique à