IFormatProvider Interfaz

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Ensamblado:

mscorlib.dll

Ensamblado:

netstandard.dll

Proporciona un mecanismo para recuperar un objeto que controle el formato.

C#

public interface IFormatProvider

C#

[System.Runtime.InteropServices.ComVisible(true)]
public interface IFormatProvider

Derivado

System.Globalization.CultureInfo

System.Globalization.DateTimeFormatInfo

System.Globalization.NumberFormatInfo

Atributos

ComVisibleAttribute

Ejemplos

En el ejemplo siguiente se muestra cómo una IFormatProvider implementación puede cambiar la representación de un valor de fecha y hora. En este caso, se muestra una sola fecha mediante CultureInfo objetos que representan cuatro referencias culturales diferentes.

C#

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2009, 6, 1, 16, 37, 0);
      CultureInfo[] cultures = { new CultureInfo("en-US"),
                                 new CultureInfo("fr-FR"),
                                 new CultureInfo("it-IT"),
                                 new CultureInfo("de-DE") };
      foreach (CultureInfo culture in cultures)
         Console.WriteLine("{0}: {1}", culture.Name, dateValue.ToString(culture));
   }
}
// The example displays the following output:
//       en-US: 6/1/2009 4:37:00 PM
//       fr-FR: 01/06/2009 16:37:00
//       it-IT: 01/06/2009 16.37.00
//       de-DE: 01.06.2009 16:37:00

En el ejemplo siguiente se muestra el uso de una clase que implementa la IFormatProvider interfaz y el GetFormat método . La AcctNumberFormat clase convierte un Int64 valor que representa un número de cuenta en un número de cuenta con formato de 12 dígitos. Su GetFormat método devuelve una referencia a la instancia actual AcctNumberFormat si el formatType parámetro hace referencia a una clase que implementa ICustomFormatter; de lo contrario, GetFormat devuelve null.

C#

public class AcctNumberFormat : IFormatProvider, ICustomFormatter
{
   private const int ACCT_LENGTH = 12;

   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }

   public string Format(string fmt, object arg, IFormatProvider formatProvider)
   {
      // Provide default formatting if arg is not an Int64.
      if (arg.GetType() != typeof(Int64))
         try {
            return HandleOtherFormats(fmt, arg);
         }
         catch (FormatException e) {
            throw new FormatException(String.Format("The format of '{0}' is invalid.", fmt), e);
         }

      // Provide default formatting for unsupported format strings.
      string ufmt = fmt.ToUpper(CultureInfo.InvariantCulture);
      if (! (ufmt == "H" || ufmt == "I"))
         try {
            return HandleOtherFormats(fmt, arg);
         }
         catch (FormatException e) {
            throw new FormatException(String.Format("The format of '{0}' is invalid.", fmt), e);
         }

      // Convert argument to a string.
      string result = arg.ToString();

      // If account number is less than 12 characters, pad with leading zeroes.
      if (result.Length < ACCT_LENGTH)
         result = result.PadLeft(ACCT_LENGTH, '0');
      // If account number is more than 12 characters, truncate to 12 characters.
      if (result.Length > ACCT_LENGTH)
         result = result.Substring(0, ACCT_LENGTH);

      if (ufmt == "I")                    // Integer-only format.
         return result;
      // Add hyphens for H format specifier.
      else                                         // Hyphenated format.
         return result.Substring(0, 5) + "-" + result.Substring(5, 3) + "-" + result.Substring(8);
   }

   private string HandleOtherFormats(string format, object arg)
   {
      if (arg is IFormattable)
         return ((IFormattable)arg).ToString(format, CultureInfo.CurrentCulture);
      else if (arg != null)
         return arg.ToString();
      else
         return String.Empty;
   }
}

Después, la clase que implementa IFormatProvider se puede usar en una llamada a una operación de formato y análisis. Por ejemplo, el código siguiente llama al String.Format(IFormatProvider, String, Object[]) método para generar una cadena que contiene un número de cuenta con formato de 12 dígitos.

C#

using System;
using System.Globalization;

public enum DaysOfWeek { Monday=1, Tuesday=2 };

public class TestFormatting
{
   public static void Main()
   {
      long acctNumber;
      double balance;
      DaysOfWeek wday;
      string output;

      acctNumber = 104254567890;
      balance = 16.34;
      wday = DaysOfWeek.Monday;

      output = String.Format(new AcctNumberFormat(),
                             "On {2}, the balance of account {0:H} was {1:C2}.",
                             acctNumber, balance, wday);
      Console.WriteLine(output);

      wday = DaysOfWeek.Tuesday;
      output = String.Format(new AcctNumberFormat(),
                             "On {2}, the balance of account {0:I} was {1:C2}.",
                             acctNumber, balance, wday);
      Console.WriteLine(output);
   }
}
// The example displays the following output:
//       On Monday, the balance of account 10425-456-7890 was $16.34.
//       On Tuesday, the balance of account 104254567890 was $16.34.

Comentarios

La IFormatProvider interfaz proporciona un objeto que proporciona información de formato para las operaciones de formato y análisis. Las operaciones de formato convierten el valor de un tipo en la representación de cadena de ese valor. Los métodos de formato típicos son los ToString métodos de un tipo, así como Format. Las operaciones de análisis convierten la representación de cadena de un valor en un tipo con ese valor. Los métodos de análisis típicos son Parse y TryParse.

La IFormatProvider interfaz consta de un único método, IFormatProvider.GetFormat. GetFormat es un método de devolución de llamada: el método de análisis o formato lo llama y lo pasa un Type objeto que representa el tipo de objeto que espera el método de formato o análisis proporcionará información de formato. El GetFormat método es responsable de devolver un objeto de ese tipo.

IFormatProvider Las implementaciones a menudo se usan implícitamente mediante el formato y los métodos de análisis. Por ejemplo, el DateTime.ToString(String) método usa implícitamente una IFormatProvider implementación que representa la referencia cultural actual del sistema. IFormatProvider Las implementaciones también se pueden especificar explícitamente mediante métodos que tienen un parámetro de tipo IFormatProvider, como Int32.Parse(String, IFormatProvider) y String.Format(IFormatProvider, String, Object[]).

El .NET Framework incluye las tres implementaciones predefinidas siguientes para proporcionar información específica de la referencia cultural IFormatProvider que se usa en el formato o el análisis de valores numéricos y de fecha y hora:

• La NumberFormatInfo clase , que proporciona información que se usa para dar formato a números, como la moneda, el separador de miles y los símbolos separadores decimales para una referencia cultural determinada. Para obtener información sobre las cadenas de formato predefinidas reconocidas por un NumberFormatInfo objeto y usadas en las operaciones de formato numérico, vea Cadenas de formato numérico estándar y Cadenas de formato numérico personalizado.

• La DateTimeFormatInfo clase , que proporciona información que se usa para dar formato a fechas y horas, como los símbolos separadores de fecha y hora para una referencia cultural determinada o el orden y el formato de los componentes de año, mes y día de una fecha. Para obtener información sobre las cadenas de formato predefinidas reconocidas por un DateTimeFormatInfo objeto y usadas en operaciones de formato numérico, vea Cadenas de formato de fecha y hora estándar y cadenas de formato de fecha y hora personalizados.

• Clase CultureInfo , que representa una referencia cultural determinada. Su GetFormat método devuelve un objeto o DateTimeFormatInfo específico NumberFormatInfo de la referencia cultural, dependiendo de si el CultureInfo objeto se usa en una operación de formato o análisis que implica números o fechas y horas.

El .NET Framework también admite el formato personalizado. Normalmente, esto implica la creación de una clase de formato que implementa y IFormatProvider ICustomFormatter. A continuación, se pasa una instancia de esta clase como parámetro a un método que realiza una operación de formato personalizada, como String.Format(IFormatProvider, String, Object[]) El ejemplo proporciona una ilustración de una implementación personalizada que da formato a un número como un número de cuenta de 12 dígitos.

Métodos

GetFormat(Type)

Devuelve un objeto que proporciona servicios de formato para el tipo especificado.

Se aplica a

Consulte también

• ICustomFormatter
• IFormattable
• Aplicar formato a tipos en .NET
• Procedimiento para definir y usar proveedores de formato numérico personalizado