ICustomFormatter Schnittstelle

Definition

Namespace:

System

Assemblys:

netstandard.dll, System.Runtime.dll

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

C#

public interface ICustomFormatter

Abgeleitet

System.CommandLine.Rendering.TextSpanFormatter

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, MyFormatter, sowohl als IFormatProviderauch ICustomFormatter . Die - IFormatProvider.GetFormat Methode bestimmt, ob der formatType Parameter einen ICustomFormatter Typ darstellt. Wenn dies der Fall ist, MyFormatter gibt sie eine instance von sich selbst zurück, andernfalls wird zurückgegebennull. 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.

C#

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

public class MyFormatter : 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;
    }
}

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

C#

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

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

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

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

        BigInteger bigIntValue = BigInteger.Multiply(Int64.MaxValue, 2);
        Console.WriteLine(String.Format(new MyFormatter(),
                                        "{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)

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 die folgenden Schritte ausführen:

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 einen instance 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 instance 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-Bibliotheksmethode 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 können.

• 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 beliebiger 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 formatierungsunterstützung hat. 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 die 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, falls 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 können.

• 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 können.

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:

Weitere Informationen

• IFormatProvider