Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

ICustomFormatter (Interfaz)

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

El tipo ICustomFormatter expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA FrameworkCompatible con Biblioteca de clases portableCompatible con .NET para aplicaciones de la Tienda WindowsFormatConvierte el valor de un objeto especificado en una representación en forma de cadena equivalente, utilizando el formato especificado y la información de formato específica de la referencia cultural.
Arriba

La interfaz ICustomFormatter incluye un solo método: ICustomFormatter.Format. Cuando esta interfaz se implementa mediante un tipo de referencia o valor, el método Format devuelve una cadena de formato personalizado que representa el valor de un objeto.

Normalmente, la interfaz de ICustomFormatter se implementa con la interfaz de IFormatProvider para personalizar el comportamiento de dos métodos compuestos de formato de la cadena de .NET Framework que incluyen un parámetro de IFormatProvider . Específicamente, la interfaz de ICustomFormatter puede proporcionar el formato personalizado del valor de un objeto pasa a los métodos de String.Format(IFormatProvider, String, Object[]) y de StringBuilder.AppendFormat(IFormatProvider, String, Object[]) .

Proporcionar una representación personalizada del valor de un objeto requiere hacer lo siguiente:

  1. Defina una clase que implemente la interfaz ICustomFormatter y su miembro simple, el método Format.

  2. Defina una clase que implemente la interfaz IFormatProvider y su miembro simple, el método GetFormat. El método GetFormat devuelve una instancia de su implementación ICustomFormatter. A menudo, una clase única implementa ICustomFormatter y IFormatProvider. En ese caso, la implementación de la clase GetFormat solo devuelve una instancia de sí misma.

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

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

Notas para los implementadores

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

Hay dos tipos de implementaciones ICustomFormatter: 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, su implementación debería incluir lo siguiente:

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

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

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

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

  • Codifique para administrar cadenas de formato que no admita. El enfoque más común es producir FormatException, aunque puede proporcionar el formato predeterminado.

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

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

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

  • Codifique para administrar cualquier cadena de formato que su extensión admita.

  • Codifique para administrar cualquier cadena de formato que su extensión no admita. Éstos se deberían pasar en la implementación IFormattable del tipo. Hay que estar preparado para tratar las excepciones que podrían producir estas llamadas a métodos.

En el siguiente ejemplo se implementa ICustomFormatter para permitir un formato binario, octal y hexadecimal de valores integrales. En este ejemplo, una clase única, IBinaryFormatter, implementa ICustomFormatter y IFormatProvider. Su método IFormatProvider.GetFormat determina si el parámetro formatType representa un tipo ICustomFormatter. Si es así, BinaryFormatter devuelve una instancia de sí misma; de lo contrario, devuelve null. Su implementación ICustomFormatter.Format determina si el parámetro de formato es una de las tres cadenas de formato compatibles ("B" para el binario, "O" para el octal y "H" para el hexadecimal) y da formato al parámetro arg apropiadamente. De lo contrario, si arg no es null, llama a la implementación del parámetro arg, la implementación de IFormattable.ToString, si existe, o su método ToString sin parámetros, si no existe. 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 se puede utilizar a continuación para proporcionar el formato personalizado pasando un objeto BinaryFormatter como el parámetro provider del método Format, como se muestra en los siguientes ejemplos.


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)


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft