IFormattable.ToString(String, IFormatProvider) Método

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Da formato al valor de la instancia actual usando el formato especificado.

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

Parámetros

format: String

Formato que se usará.

o bien

Referencia nula (Nothing en Visual Basic) para usar el formato predeterminado definido para el tipo de la implementación IFormattable.

formatProvider: IFormatProvider

Proveedor que se usa para dar formato al valor.

o bien

Referencia nula (Nothing en Visual Basic) para obtener la información de formato numérico de la configuración regional actual del sistema operativo.

Devoluciones

String

Valor de la instancia actual en el formato especificado.

Ejemplos

En el ejemplo siguiente se muestra una Temperature clase que implementa el ToString método . Este ejemplo de código es parte de un ejemplo mayor proporcionado para la clase IFormattable.

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

Comentarios

El ToString método convierte un valor en una representación de cadena que se puede expresar de varias maneras. Su formato preciso depende de símbolos específicos o de un orden especificado definido por culturas, profesiones o industrias específicas. Puede llamar directamente al método . También lo llaman automáticamente los Convert.ToString(Object) métodos y Convert.ToString(Object, IFormatProvider) , y por métodos que usan la característica de formato compuesto en .NET Framework, como String.Format(String, Object[]), Console.WriteLine(String, Object[])y StringBuilder.AppendFormat(String, Object[]). (Para obtener más información, vea Formato compuesto).

Los métodos de formato compuesto llaman al ToString método una vez para cada elemento de formato en una cadena de formato. Los parámetros pasados al método dependen del método de formato específico al que se llama y en el contenido del elemento de formato, como se indica a continuación:

Si el elemento de formato no incluye una cadena de formato (por ejemplo, si el elemento de formato es simplemente {0}), se pasa null como el valor del System.String parámetro .
Si el elemento de formato incluye una cadena de formato (por ejemplo, {0:G}), esa cadena de formato se pasa como el valor del System.String parámetro .
Si la llamada al método original no incluye un System.IFormatProvider parámetro , CultureInfo.CurrentCulture se pasa como el valor del System.IFormatProvider parámetro .
Si la llamada al método original incluye un System.IFormatProvider parámetro, el proveedor proporcionado en la llamada al método se pasa como el valor del System.IFormatProvider parámetro .

Nota

Los métodos de formato compuesto llaman a la implementación de ToString un objeto solo si no se pasan a un ICustomFormatter proveedor de formato o si el Format método del proveedor de formato personalizado devuelve null.

.NET Framework incluye tres proveedores de formato, todos los cuales implementan la IFormatProvider interfaz :

NumberFormatInfo proporciona información de formato numérico, como los caracteres que se usarán para separadores decimales y de grupo, y la ortografía y la colocación de símbolos de moneda en valores monetarios.
DateTimeFormatInfo proporciona información de formato relacionada con la fecha y la hora, como la posición del mes, el día y el año en un patrón de fecha.
CultureInfo contiene la información de formato predeterminada en una referencia cultural específica, incluida la información de formato numérico y la información de formato relacionada con la fecha y la hora.

Además, puede definir su propio proveedor de formato personalizado.

Notas a los implementadores

El ToString(String, IFormatProvider) método debe admitir el especificador de formato "G" (general). Además del especificador "G", la clase puede definir la lista de especificadores de formato que admite. Además, la clase debe estar preparada para controlar un especificador de formato que sea null. Para obtener más información sobre el formato y los códigos de formato, vea Formato de tipos.

Se aplica a

Compartir a través de