Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Interfaz ICustomFormatter

 

Publicado: octubre de 2016

Define un método que admite formatos personalizados del valor de un objeto.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(true)]
public interface ICustomFormatter

NombreDescripción
System_CAPS_pubmethodFormat(String, Object, IFormatProvider)

Convierte el valor del objeto especificado en la representación de cadena equivalente usando el formato y la información de formato específica de la referencia cultural especificados.

El ICustomFormatter interfaz incluye un único método, ICustomFormatter.Format. Cuando se implementa mediante un tipo de valor o referencia, la Format método devuelve una representación de cadena de formato personalizado del valor de un objeto.

Normalmente, el ICustomFormatter se implementa con el IFormatProvider interfaz para personalizar el comportamiento de los dos métodos de formato de cadena compuesta .NET Framework que incluyen un IFormatProvider parámetro. En concreto, la ICustomFormatter interfaz puede proporcionar formatos personalizados del valor de un objeto pasado a la String.Format(IFormatProvider, String, Object[]) y StringBuilder.AppendFormat(IFormatProvider, String, Object[]) métodos.

Proporciona una representación personalizada del valor de un objeto requiere que haga lo siguiente:

  1. Defina una clase que implementa el ICustomFormatter interfaz y su miembro simple, el Format (método).

  2. Defina una clase que implementa el IFormatProvider interfaz y su miembro simple, el GetFormat (método). El GetFormat método devuelve una instancia de su ICustomFormatter implementación. A menudo, una sola clase implementa tanto ICustomFormatter y IFormatProvider. En de ese caso, la clase GetFormat implementación simplemente devuelve una instancia de sí mismo.

  3. Pasar el IFormatProvider implementación como el provider argumento de la String.Format(IFormatProvider, String, Object[]) método o un método comparable.

El método de .NET Framework utilizará el formato personalizado en lugar del suyo propio.

Notas para implementadores:

Common language runtime intenta utilizar su ICustomFormatter implementación para cada elemento de formato de cadena de formato compuesto. Como resultado, debe esperar que su ICustomFormatter se llamará la implementación para proporcionar servicios de formato a objetos o valores que no está diseñado para controlar. En estos casos, su Format método debe llamar al método de formato adecuado para ese objeto o valor.

Hay dos tipos de ICustomFormatter las implementaciones: intrínseca y extensión.

Las implementaciones intrínsecas son implementaciones que proporcionan el formato personalizado para un objeto definido por la aplicación. En este caso, la implementación debe incluir lo siguiente:

  • Una definición de cadenas de formato que define el formato del objeto. Cadenas de formato son opcionales. Normalmente, una cadena de formato "G" o "g" define el formato general (o utilizado con más frecuencia). Sin embargo, es libre para definir las cadenas de formato que elija. También tiene libertad para decidir si distinguen entre mayúsculas y minúsculas o mayúsculas de minúsculas.

  • Una prueba para asegurarse de que el tipo del objeto pasa a su Format método es el tipo definido por la aplicación. Si no es así, debe llamar el objeto IFormattable implementación, si existe, o su ToString método, si no es así. Debe estar preparado para controlar las excepciones que podrían producir estas llamadas al método.

  • Codifique para administrar una cadena de formato nula, si su implementación admite las cadenas de formato. El enfoque más común consiste en reemplazar una cadena de formato nula con el especificador de formato general.

  • Codifique para administrar cualquier cadena de formato que admite su implementación.

  • Codifique para administrar cadenas de formato que no se admiten. El enfoque más común consiste en iniciar una FormatException, aunque puede proporcionar el formato predeterminado.

Las implementaciones de extensión son implementaciones que proporcionan el formato personalizado para un tipo que ya tiene compatibilidad con el formato. Por ejemplo, puede definir un CustomerNumberFormatter que aplica formato a un tipo integral con guiones entre los dígitos concretos. En este caso, la implementación debe incluir lo siguiente:

  • Una definición de cadenas de formato que extienden el formato del objeto. Estas cadenas de formato son necesarias, pero debe estar en conflicto con cadenas de formato existente del tipo. Por ejemplo, si está ampliando formato para el Int32 tipo, no debería implementar los especificadores de formato "C", "D", "E", "F" y "G", entre otros.

  • Una prueba de que el tipo del objeto pasa a su Format método es un tipo cuyo formato admite su extensión. Si no es así, llame el objeto IFormattable implementación, si existe, o el objeto de parámetros ToString método, si no es así. Debe estar preparado para controlar las excepciones que podrían producir estas llamadas al método.

  • Código para controlar las cadenas de formato que es compatible su extensión.

  • Codifique para administrar cualquier cadena de formato que no es compatible con la extensión. Estos se deberían pasar al tipo IFormattable implementación. Debe estar preparado para controlar las excepciones que podrían producir estas llamadas al método.

En el ejemplo siguiente se implementa ICustomFormatter para permitir que el formato binario, octal y hexadecimal de valores enteros. En este ejemplo, una sola clase, IBinaryFormatter, las implementa ICustomFormatter y IFormatProvider. Su IFormatProvider.GetFormat método determina si el formatType parámetro representa un ICustomFormatter tipo. Si es así, BinaryFormatter devuelve una instancia de sí misma; en caso contrario, devuelve null. Su ICustomFormatter.Format implementación determina si el parámetro de formato es una de las tres cadenas de formato compatibles ("B" para el binario, "O" para octal y "H" de hexadecimal) y da formato a la arg parámetro adecuadamente. De lo contrario, si arg no null, llama el arg del parámetro IFormattable.ToString implementación, si existe, o su sin parámetros ToString método, si no lo hace. Si el valor de arg es null, el método devuelve String.Empty.

using System;
using System.Globalization;
using System.Numerics;

public class BinaryFormatter : IFormatProvider, ICustomFormatter
{
   // IFormatProvider.GetFormat implementation.
   public object GetFormat(Type formatType)
   {
      // Determine whether custom formatting object is requested.
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }   

   // Format number in binary (B), octal (O), or hexadecimal (H).
   public string Format(string format, object arg, IFormatProvider formatProvider)
   {
      // Handle format string.
      int baseNumber;
      // Handle null or empty format string, string with precision specifier.
      string thisFmt = String.Empty;
      // Extract first character of format string (precision specifiers
      // are not supported).
      if (! String.IsNullOrEmpty(format))
         thisFmt = format.Length > 1 ? format.Substring(0, 1) : format;


      // Get a byte array representing the numeric value.
      byte[] bytes;
      if (arg is sbyte)
      {
         string byteString = ((sbyte) arg).ToString("X2");
         bytes = new byte[1] { Byte.Parse(byteString, System.Globalization.NumberStyles.HexNumber ) };
      }
      else if (arg is byte) {
         bytes = new byte[1] { (byte) arg };
      }   
      else if (arg is short) {
         bytes = BitConverter.GetBytes((short) arg);
      }   
      else if (arg is int) {
         bytes = BitConverter.GetBytes((int) arg);
      }   
      else if (arg is long) {
         bytes = BitConverter.GetBytes((long) arg);
      }
      else if (arg is ushort) {
         bytes = BitConverter.GetBytes((ushort) arg);
      }
      else if (arg is uint) {
         bytes = BitConverter.GetBytes((uint) arg);
      }
      else if (arg is ulong) {
         bytes = BitConverter.GetBytes((ulong) arg);                  
      }
      else if (arg is BigInteger) {
         bytes = ((BigInteger) arg).ToByteArray();
      }
      else {
         try {
            return HandleOtherFormats(format, arg); 
         }
         catch (FormatException e) {
            throw new FormatException(String.Format("The format of '{0}' is invalid.", format), e);
         }
      }

      switch (thisFmt.ToUpper())
      {
         // Binary formatting.
         case "B":
            baseNumber = 2;
            break;        
         case "O":
            baseNumber = 8;
            break;
         case "H":
            baseNumber = 16;
            break;
         // Handle unsupported format strings.
         default:
         try {
            return HandleOtherFormats(format, arg); 
         }
         catch (FormatException e) {
            throw new FormatException(String.Format("The format of '{0}' is invalid.", format), e);
         }
      }

      // Return a formatted string.
      string numericString = String.Empty;
      for (int ctr = bytes.GetUpperBound(0); ctr >= bytes.GetLowerBound(0); ctr--)
      {
         string byteString = Convert.ToString(bytes[ctr], baseNumber);
         if (baseNumber == 2)
            byteString = new String('0', 8 - byteString.Length) + byteString;
         else if (baseNumber == 8)
            byteString = new String('0', 4 - byteString.Length) + byteString;
         // Base is 16.
         else     
            byteString = new String('0', 2 - byteString.Length) + byteString;

         numericString +=  byteString + " ";
      }
      return numericString.Trim();
   }

   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;
   }
}

BinaryFormatter puede utilizarse para proporcionar el formato personalizado pasando un BinaryFormatter de objeto como el provider parámetro de la Format (método), como se muestra en el ejemplo siguiente.

public class Example
{
   public static void Main()
   {
      Console.WindowWidth = 100;

      byte byteValue = 124;
      Console.WriteLine(String.Format(new BinaryFormatter(), 
                                      "{0} (binary: {0:B}) (hex: {0:H})", byteValue));

      int intValue = 23045;
      Console.WriteLine(String.Format(new BinaryFormatter(), 
                                      "{0} (binary: {0:B}) (hex: {0:H})", intValue));

      ulong ulngValue = 31906574882;
      Console.WriteLine(String.Format(new BinaryFormatter(), 
                                      "{0}\n   (binary: {0:B})\n   (hex: {0:H})", 
                                      ulngValue));

      BigInteger bigIntValue = BigInteger.Multiply(Int64.MaxValue, 2);
      Console.WriteLine(String.Format(new BinaryFormatter(), 
                                      "{0}\n   (binary: {0:B})\n   (hex: {0:H})", 
                                      bigIntValue));
   }
}
// The example displays the following output:
//    124 (binary: 01111100) (hex: 7c)
//    23045 (binary: 00000000 00000000 01011010 00000101) (hex: 00 00 5a 05)
//    31906574882
//       (binary: 00000000 00000000 00000000 00000111 01101101 11000111 10110010 00100010)
//       (hex: 00 00 00 07 6d c7 b2 22)
//    18446744073709551614
//       (binary: 00000000 11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111110)
//       (hex: 00 ff ff ff ff ff ff ff fe)

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: