ICustomFormatter Schnittstelle

Definition

Definiert eine Methode, die die benutzerdefinierte Formatierung des Werts eines Objekts unterstützt.

public interface class ICustomFormatter
public interface ICustomFormatter
[System.Runtime.InteropServices.ComVisible(true)]
public interface ICustomFormatter
type ICustomFormatter = interface
[<System.Runtime.InteropServices.ComVisible(true)>]
type ICustomFormatter = interface
Public Interface ICustomFormatter
Attribute

Beispiele

Im folgenden Beispiel wird implementiert ICustomFormatter , um die binäre, oktale und hexadezimale Formatierung von integralen Werten zuzulassen. In diesem Beispiel implementiert eine einzelne Klasse, IBinaryFormatter, sowohl als IFormatProviderauch ICustomFormatter . Die - IFormatProvider.GetFormat Methode bestimmt, ob der formatType Parameter einen ICustomFormatter Typ darstellt. Wenn dies der Fall ist, BinaryFormatter gibt sie eine Instanz von sich selbst zurück, andernfalls wird zurückgegeben null. Die ICustomFormatter.Format Implementierung bestimmt, ob der Formatparameter eine der drei unterstützten Formatzeichenfolgen ("B" für Binärdatei, "O" für oktale und "H" für Hexadezimalstellen) ist, und formatiert den arg Parameter entsprechend. Andernfalls, wenn arg nicht ist, ruft er die arg Implementierung des IFormattable.ToString Parameters auf, sofern vorhanden, oder seine parameterlose ToString Methode, wenn dies nicht der Fall nullist. Wenn arg gleich null ist, gibt die Methode String.Empty zurück.

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;
   }
}
open System
open System.Globalization
open System.Numerics

type BinaryFormatter() =
    interface IFormatProvider with
        // IFormatProvider.GetFormat implementation.
        member this.GetFormat(formatType: Type) =
            // Determine whether custom formatting object is requested.
            if formatType = typeof<ICustomFormatter> then
                this
            else
                null

    interface ICustomFormatter with
        // Format number in binary (B), octal (O), or hexadecimal (H).
        member this.Format(format, arg: obj, formatProvider: IFormatProvider) =
            // Handle null or empty format string, string with precision specifier.
            let thisFmt =
                // Extract first character of format string (precision specifiers
                // are not supported).
                if String.IsNullOrEmpty format |> not then
                    if format.Length > 1 then 
                        format.Substring(0, 1) 
                    else 
                        format
                else
                    String.Empty

            // Get a byte array representing the numeric value.
            let bytes =
                match arg with
                | :? sbyte as arg ->
                    let byteString = arg.ToString "X2"
                    Some [| Byte.Parse(byteString, NumberStyles.HexNumber) |]
                | :? byte as arg ->
                    Some [| arg |]
                | :? int16 as arg ->
                    BitConverter.GetBytes arg
                    |> Some
                | :? int as arg ->
                    BitConverter.GetBytes arg
                    |> Some
                | :? int64 as arg ->
                    BitConverter.GetBytes arg
                    |> Some
                | :? uint16 as arg ->
                    BitConverter.GetBytes arg
                    |> Some
                | :? uint as arg ->
                    BitConverter.GetBytes arg
                    |> Some
                | :? uint64 as arg ->
                    BitConverter.GetBytes arg
                    |> Some
                | :? bigint as arg ->
                    arg.ToByteArray()
                    |> Some
                | _ ->
                    None
            let baseNumber =
                match thisFmt.ToUpper() with
                    // Binary formatting.
                    | "B" -> Some 2
                    | "O" -> Some 8
                    | "H" -> Some 16
                    // Handle unsupported format strings.
                    | _ -> None

            match bytes, baseNumber with
            | Some bytes, Some baseNumber ->
                // Return a formatted string.
                let mutable numericString = String.Empty
                for i = bytes.GetUpperBound 0 to bytes.GetLowerBound 0 do
                    let byteString = Convert.ToString(bytes[i], baseNumber)
                    let byteString =
                        match baseNumber with
                        | 2 ->
                            String('0', 8 - byteString.Length) + byteString
                        | 8 ->
                            String('0', 4 - byteString.Length) + byteString
                        // Base is 16.
                        | _ ->
                            String('0', 2 - byteString.Length) + byteString
                    numericString <- numericString + byteString + " "
                numericString.Trim()
            | _ ->
                try
                    this.HandleOtherFormats(format, arg)
                with :? FormatException as e ->
                    raise (FormatException($"The format of '{format}' is invalid.", e))
                    
    member private this.HandleOtherFormats(format, arg: obj) =
        match arg with
        | :? IFormattable as arg ->
            arg.ToString(format, CultureInfo.CurrentCulture)
        | null ->
            String.Empty
        | _ ->
            string arg
Imports System.Globalization
Imports System.Numerics

Public Class BinaryFormatter : Implements IFormatProvider, ICustomFormatter
   ' IFormatProvider.GetFormat implementation.
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      ' Determine whether custom formatting object is requested.
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function   

   ' Format number in binary (B), octal (O), or hexadecimal (H).
   Public Function Format(fmt As String, arg As Object, _
                          formatProvider As IFormatProvider) As String _
                   Implements ICustomFormatter.Format

     ' Handle format string.
      Dim base As Integer
      ' Handle null or empty format string, string with precision specifier.
      Dim thisFmt As String = String.Empty
      ' Extract first character of format string (precision specifiers
      ' are not supported by BinaryFormatter).
      If Not String.IsNullOrEmpty(fmt) Then
         thisFmt = CStr(IIf(fmt.Length > 1, fmt.Substring(0, 1), fmt))
      End If
         


      ' Get a byte array representing the numeric value.
      Dim bytes() As Byte
      If TypeOf(arg) Is SByte Then
         Dim byteString As String = CType(arg, SByte).ToString("X2")
         bytes = New Byte(0) { Byte.Parse(byteString, System.Globalization.NumberStyles.HexNumber ) }
      ElseIf TypeOf(arg) Is Byte Then
         bytes = New Byte(0) { CType(arg, Byte) }
      ElseIf TypeOf(arg) Is Int16 Then
         bytes = BitConverter.GetBytes(CType(arg, Int16))
      ElseIf TypeOf(arg) Is Int32 Then
         bytes = BitConverter.GetBytes(CType(arg, Int32))
      ElseIf TypeOf(arg) Is Int64 Then
         bytes = BitConverter.GetBytes(CType(arg, Int64))
      ElseIf TypeOf(arg) Is UInt16 Then
         bytes = BitConverter.GetBytes(CType(arg, UInt16))
      ElseIf TypeOf(arg) Is UInt32 Then
         bytes = BitConverter.GetBytes(CType(arg, UInt64))
      ElseIf TypeOf(arg) Is UInt64 Then
         bytes = BitConverter.GetBytes(CType(arg, UInt64))                  
      ElseIf TypeOf(arg) Is BigInteger Then
         bytes = CType(arg, BigInteger).ToByteArray()
      Else
         Try 
            Return HandleOtherFormats(fmt, arg) 
         Catch e As FormatException 
            Throw New FormatException(String.Format("The format of '{0}' is invalid.", fmt), e)
         End Try
      End If

      Select Case thisFmt.ToUpper()
         ' Binary formatting.
         Case "B"
            base = 2        
         Case "O"
            base = 8
         Case "H"
            base = 16
         ' Handle unsupported format strings.
         Case Else
            Try 
               Return HandleOtherFormats(fmt, arg) 
            Catch e As FormatException 
               Throw New FormatException(String.Format("The format of '{0}' is invalid.", fmt), e)
            End Try
      End Select
      
      ' Return a formatted string.
      Dim numericString As String = String.Empty
      For ctr As Integer = bytes.GetUpperBound(0) To bytes.GetLowerBound(0) Step -1
         Dim byteString As String = Convert.ToString(bytes(ctr), base)
         If base = 2 Then
            byteString = New String("0"c, 8 - byteString.Length) + byteString
         ElseIf base = 8 Then
            byteString = New String("0"c, 4 - byteString.Length) + byteString
         ' Base is 16.
         Else     
            byteString = New String("0"c, 2 - byteString.Length) + byteString
         End If
         numericString +=  byteString + " "
      Next
      Return numericString.Trim()
   End Function
   
   Private Function HandleOtherFormats(fmt As String, arg As Object) As String
      If TypeOf arg Is IFormattable Then
         Return DirectCast(arg, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
      ElseIf arg IsNot Nothing Then
         Return arg.ToString()
      Else
         Return String.Empty
      End If
   End Function
End Class

BinaryFormatter kann dann verwendet werden, um benutzerdefinierte Formatierung bereitzustellen, indem ein BinaryFormatter -Objekt als provider Parameter der Format -Methode übergeben wird, wie im folgenden Beispiel gezeigt.

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)
Console.WindowWidth <- 100

let byteValue = 124uy
String.Format(BinaryFormatter(), "{0} (binary: {0:B}) (hex: {0:H})", byteValue)
|> printfn "%s"

let intValue = 23045
String.Format(BinaryFormatter(), "{0} (binary: {0:B}) (hex: {0:H})", intValue)
|> printfn "%s"

let ulngValue = 31906574882uL
String.Format(BinaryFormatter(), "{0}\n   (binary: {0:B})\n   (hex: {0:H})", ulngValue)
|> printfn "%s"

let bigIntValue = BigInteger.Multiply(Int64.MaxValue, 2)
String.Format(BinaryFormatter(), "{0}\n   (binary: {0:B})\n   (hex: {0:H})", bigIntValue)
|> printfn "%s"

// 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)
Public Module Example
   Public Sub Main
      Console.WindowWidth = 100
      
      Dim byteValue As Byte = 124
      Console.WriteLine(String.Format(New BinaryFormatter(), _
                                      "{0} (binary: {0:B}) (hex: {0:H})", byteValue))
      
      Dim intValue As Integer = 23045
      Console.WriteLine(String.Format(New BinaryFormatter(), _
                                      "{0} (binary: {0:B}) (hex: {0:H})", intValue))
      
      Dim ulngValue As ULong = 31906574882
      Console.WriteLine(String.Format(New BinaryFormatter(), _
                                      "{0} {1}   (binary: {0:B}) {1}   (hex: {0:H})", _
                                      ulngValue, vbCrLf))

      Dim bigIntValue As BigInteger = BigInteger.Multiply(Int64.MaxValue, 2)
      Console.WriteLine(String.Format(New BinaryFormatter(), _
                                      "{0} {1}   (binary: {0:B}) {1}   (hex: {0:H})", _
                                      bigIntValue, vbCrLf))
   End Sub
End Module
' 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)

Hinweise

Die ICustomFormatter -Schnittstelle enthält eine einzelne Methode: ICustomFormatter.Format. Wenn diese Schnittstelle durch einen Verweis oder Werttyp implementiert wird, gibt die Format Methode eine benutzerdefinierte Zeichenfolgendarstellung des Werts eines Objekts zurück.

In der Regel wird die ICustomFormatter Schnittstelle mit der IFormatProvider -Schnittstelle implementiert, um das Verhalten von zwei .NET Framework zusammengesetzten Zeichenfolgenformatierungsmethoden anzupassen, die einen IFormatProvider Parameter enthalten. Insbesondere kann die Schnittstelle eine ICustomFormatter benutzerdefinierte Formatierung des Werts eines Objekts bereitstellen, das an die String.Format(IFormatProvider, String, Object[]) Methoden und StringBuilder.AppendFormat(IFormatProvider, String, Object[]) übergeben wird.

Um eine benutzerdefinierte Darstellung des Werts eines Objekts bereitzustellen, müssen Sie wie folgt vorgehen:

  1. Definieren Sie eine Klasse, die die -Schnittstelle und ihren ICustomFormatter einzelnen Member, die Format -Methode, implementiert.

  2. Definieren Sie eine Klasse, die die -Schnittstelle und ihren IFormatProvider einzelnen Member, die GetFormat -Methode, implementiert. Die GetFormat -Methode gibt eine Instanz Ihrer ICustomFormatter Implementierung zurück. Häufig implementiert eine einzelne Klasse sowohl als IFormatProviderauch ICustomFormatter . In diesem Fall gibt die -Implementierung der GetFormat -Klasse nur eine Instanz von sich selbst zurück.

  3. Übergeben Sie die IFormatProvider Implementierung als provider Argument der String.Format(IFormatProvider, String, Object[]) -Methode oder einer vergleichbaren Methode.

Die .NET Framework-Methode verwendet dann Ihre benutzerdefinierte Formatierung anstelle ihrer eigenen.

Hinweise für Ausführende

Die Common Language Runtime versucht, Ihre ICustomFormatter Implementierung für jedes Formatelement in einer zusammengesetzten Formatzeichenfolge zu verwenden. Daher sollten Sie davon ausgehen, dass Ihre ICustomFormatter Implementierung aufgerufen wird, um Formatierungsdienste für Objekte oder Werte bereitzustellen, für die sie nicht konzipiert ist. In diesen Fällen muss Die Format(String, Object, IFormatProvider) -Methode die entsprechende Formatierungsmethode für dieses Objekt oder diesen Wert aufrufen.

Es gibt zwei Arten von ICustomFormatter Implementierungen: systeminterne Implementierungen und Erweiterungen.

Systeminterne Implementierungen sind Implementierungen, die eine benutzerdefinierte Formatierung für ein anwendungsdefiniertes Objekt bereitstellen. In diesem Fall sollte Ihre Implementierung Folgendes umfassen:

  • Eine Definition von Formatzeichenfolgen, die die Formatierung des Objekts definieren. Formatzeichenfolgen sind optional. In der Regel definiert eine Zeichenfolge im Format "G" oder "g" das allgemeine (oder am häufigsten verwendete) Format. Sie können jedoch beliebige Formatzeichenfolgen definieren, die Sie auswählen. Sie können auch entscheiden, ob die Groß- und Kleinschreibung beachtet wird.

  • Ein Test, um sicherzustellen, dass der Typ des objekts, das an Ihre Format(String, Object, IFormatProvider) Methode übergeben wird, Ihr anwendungsdefinierter Typ ist. Wenn dies nicht der Fall ist, sollten Sie die -Implementierung des IFormattable Objekts aufrufen, sofern vorhanden, oder die - ToString() Methode, wenn dies nicht der Fall ist. Sie sollten darauf vorbereitet sein, alle Ausnahmen zu behandeln, die von diesen Methodenaufrufen ausgelöst werden.

  • Code zum Behandeln einer NULL-Formatzeichenfolge, wenn Ihre Implementierung Formatzeichenfolgen unterstützt. Der gebräuchlichste Ansatz besteht darin, eine NULL-Formatzeichenfolge durch den allgemeinen Formatbezeichner zu ersetzen.

  • Code zum Verarbeiten von Formatzeichenfolgen, die von Ihrer Implementierung unterstützt werden.

  • Code zum Verarbeiten von Formatzeichenfolgen, die Sie nicht unterstützen. Der gebräuchlichste Ansatz besteht darin, eine FormatExceptionauszulösen, obwohl Sie eine Standardformatierung angeben können.

Erweiterungsimplementierungen sind Implementierungen, die eine benutzerdefinierte Formatierung für einen Typ bereitstellen, der bereits Über Formatierungsunterstützung verfügt. Sie können z. B. einen CustomerNumberFormatter definieren, der einen integralen Typ mit Bindestrichen zwischen bestimmten Ziffern formatiert. In diesem Fall sollte Ihre Implementierung Folgendes umfassen:

  • Eine Definition von Formatzeichenfolgen, die die Formatierung des Objekts erweitern. Diese Formatzeichenfolgen sind erforderlich, dürfen aber nicht mit den vorhandenen Formatzeichenfolgen des Typs in Konflikt stehen. Wenn Sie beispielsweise die Formatierung für den Int32 Typ erweitern, sollten Sie nicht unter anderem die Formatbezeichner "C", "D", "E", "F" und "G" implementieren.

  • Ein Test, bei dem der Typ des an ihre Format(String, Object, IFormatProvider) Methode übergebenen Objekts ein Typ ist, dessen Formatierung die Erweiterung unterstützt. Wenn dies nicht der Fall ist, rufen Sie die Implementierung des IFormattable Objekts auf, sofern vorhanden, oder die parameterlose ToString() Methode des Objekts, falls dies nicht der Fall ist. Sie sollten darauf vorbereitet sein, alle Ausnahmen zu behandeln, die von diesen Methodenaufrufen ausgelöst werden.

  • Code zum Verarbeiten beliebiger Formatzeichenfolgen, die von der Erweiterung unterstützt werden.

  • Code zum Verarbeiten von Formatzeichenfolgen, die von der Erweiterung nicht unterstützt werden. Diese sollten an die Implementierung des Typs IFormattable übergeben werden. Sie sollten darauf vorbereitet sein, alle Ausnahmen zu behandeln, die von diesen Methodenaufrufen ausgelöst werden.

Methoden

Format(String, Object, IFormatProvider)

Konvertiert den Wert eines angegebenen Objekts unter Verwendung des angegebenen Formats sowie der kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

Gilt für

Siehe auch