ICustomFormatter Schnittstelle
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Definiert eine Methode, die die benutzerdefinierte Formatierung des Werts eines Objekts unterstützt.
public interface class ICustomFormatterpublic interface ICustomFormatter[System.Runtime.InteropServices.ComVisible(true)]
public interface ICustomFormattertype ICustomFormatter = interface[<System.Runtime.InteropServices.ComVisible(true)>]
type ICustomFormatter = interfacePublic Interface ICustomFormatter- Attribute
Beispiele
Das folgende Beispiel implementiert, um die binäre, oktale und hexadezimale Formatierung von integralen ICustomFormatter Werten zuzulassen. In diesem Beispiel implementiert eine einzelne Klasse, BinaryFormatter, sowohl als auch ICustomFormatterIFormatProvider. Seine IFormatProvider.GetFormat Methode bestimmt, ob der formatType Parameter einen ICustomFormatter Typ darstellt. Wenn dies der Fall ist, BinaryFormatter gibt sie eine Instanz von sich zurück, andernfalls wird zurückgegeben null. Die ICustomFormatter.Format Implementierung bestimmt, ob der Formatparameter eine der drei unterstützten Formatzeichenfolgen ist ("B" für Binärdatei, "O" für Oktale und "H" für hexadezimal) und formatiert den arg Parameter entsprechend. Andernfalls arg wird die Implementierung des argIFormattable.ToString Parameters , falls vorhanden, oder die parameterlose ToString Methode aufgerufen, falls dies nicht der Fall istnull. 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 das folgende Beispiel zeigt.
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.
Das Bereitstellen einer benutzerdefinierten Darstellung des Werts eines Objekts erfordert Folgendes:
Definieren Sie eine Klasse, die die ICustomFormatter Schnittstelle und ihr einzelnes Element, die Format -Methode, implementiert.
Definieren Sie eine Klasse, die die IFormatProvider Schnittstelle und ihr einzelnes Element, die GetFormat -Methode, implementiert. Die GetFormat -Methode gibt eine Instanz Ihrer ICustomFormatter Implementierung zurück. Häufig implementiert eine einzelne Klasse sowohl als auch ICustomFormatterIFormatProvider. In diesem Fall gibt die Implementierung der
GetFormatKlasse nur eine Instanz von sich selbst zurück.Übergeben Sie die IFormatProvider Implementierung als
providerArgument 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 Ihre Format(String, Object, IFormatProvider) Methode die entsprechende Formatierungsmethode für dieses Objekt oder diesen Wert aufrufen.
Es gibt zwei Arten von ICustomFormatter Implementierungen: systeminterne und erweiterungsinterne Implementierungen.
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 "G"- oder "g"-Formatzeichenfolge das allgemeine (oder am häufigsten verwendete) Format. Sie können jedoch alle Formatzeichenfolgen definieren, die Sie auswählen. Sie können auch entscheiden, ob die Groß-/Kleinschreibung beachtet oder nicht 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, falls vorhanden, oder die ToString() -Methode, falls dies nicht der Fall ist. Sie sollten bereit sein, alle Ausnahmen zu behandeln, die von diesen Methodenaufrufen ausgelöst werden könnten.
Code zum Behandeln einer NULL-Formatzeichenfolge, wenn Ihre Implementierung Formatzeichenfolgen unterstützt. Der häufigste Ansatz besteht darin, eine NULL-Formatzeichenfolge durch den allgemeinen Formatbezeichner zu ersetzen.
Code zum Verarbeiten beliebiger Formatzeichenfolgen, die ihre Implementierung unterstützt.
Code zum Verarbeiten von Formatzeichenfolgen, die Sie nicht unterstützen. Der gängigste Ansatz besteht darin, ein FormatExceptionauszulösen, obwohl Sie die Standardformatierung angeben können.
Erweiterungsimplementierungen sind Implementierungen, die eine benutzerdefinierte Formatierung für einen Typ bereitstellen, der bereits Formatierungsunterstützung hat. Sie könnten beispielsweise 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 Objekts, der an Ihre Format(String, Object, IFormatProvider) Methode übergeben wird, ein Typ ist, dessen Formatierung die Erweiterung unterstützt. Wenn dies nicht der Fall ist, rufen Sie die Implementierung des IFormattable Objekts auf, falls vorhanden, oder die parameterlose ToString() Methode des Objekts, falls dies nicht der Fall ist. Sie sollten bereit sein, alle Ausnahmen zu behandeln, die von diesen Methodenaufrufen ausgelöst werden könnten.
Code zum Verarbeiten beliebiger Formatzeichenfolgen, die ihre Erweiterung unterstützt.
Code zum Verarbeiten von Formatzeichenfolgen, die ihre Erweiterung nicht unterstützt. Diese sollten an die Implementierung des Typs IFormattable übergeben werden. Sie sollten bereit sein, alle Ausnahmen zu behandeln, die von diesen Methodenaufrufen ausgelöst werden könnten.
Methoden
| Format(String, Object, IFormatProvider) |
Konvertiert den Wert eines angegebenen Objekts unter Verwendung des angegebenen Formats sowie der kulturspezifischen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung. |