Anpassen von Formatzeichenfolgen

Aktualisiert: November 2007

.NET Framework unterstützt das Erweitern des integrierten Formatierungsmechanismus. Sie können daher eine eigene ToString-Methode erstellen, die benutzerdefinierte Formatzeichenfolgen akzeptiert, oder Sie können einen Formatanbieter erstellen, der Ihre eigene Format-Methode zum Durchführen einer benutzerdefinierten Typformatierung aufruft. Sie erstellen eine eigene ToString-Methode, indem Sie die IFormattable-Schnittstelle implementieren. Eine eigene Format-Methode wird durch Implementieren der ICustomFormatter-Schnittstelle und der IFormatProvider-Schnittstelle erstellt.

Die Informationen in diesem Abschnitt beschränken sich auf das Hinzufügen von benutzerdefinierten Formatzeichenfolgen zu benutzerdefinierten Typen und vorhandenen Basistypen. Die beschriebenen Prinzipien können jedoch auf jeden beliebigen Typ angewendet werden.

Wenn Sie einen eigenen benutzerdefinierten Typ erstellen, können Sie Unterstützung für die Verarbeitung der eigenen benutzerdefinierter Formatzeichenfolgen hinzufügen, indem Sie die IFormattable-Schnittstelle und deren ToString-Methode implementieren. Das heißt, Sie können steuern, welche Formatzeichenfolgen vom benutzerdefinierten Typ erkannt werden. Das Implementieren der IFormattable-Schnittstelle hat gegenüber dem bloßen Hinzufügen einer ToString-Methode zum benutzerdefinierten Typ den Vorteil, dass Sie den Benutzern Ihrer ToString-Methode eine vordefinierte Aufrufsyntax sowie einen Rückgabetyp garantieren können.

Die ToString-Methode der IFormattable-Schnittstelle akzeptiert eine Formatzeichenfolge und einen Formatanbieter als Parameter. Wenn der Formatzeichenfolgenparameter eine leere Zeichenfolge oder null (Nothing in Visual Basic) ist, führen Sie eine Standardformatierung aus. Wenn der Formatanbieter null ist, verwenden Sie einen Standardformatanbieter.

Führen Sie beim Übergeben einer benutzerdefinierten Formatzeichenfolge an die benutzerdefinierte Version von ToString die entsprechende Formatierung aus. Andernfalls muss eine geeignete .NET Framework-Methode aufgerufen werden, um die Standardformatierung durchzuführen.

Im folgenden Beispiel implementiert der benutzerdefinierte Typ MyType die IFormattable-Schnittstelle. Wenn Sie eine neue Instanz der MyType-Klasse erstellen und die benutzerdefinierte Formatzeichenfolge "b" an die ToString-Methode der Instanz übergeben, gibt eine Überladung von Convert.ToString die binäre Zeichenfolgenentsprechung (Basis 2) des Werts der Instanz zurück. Wenn "b" nicht übergeben wird, wird der Wert der Instanz mittels der eigenen ToString-Methode formatiert, d. h., die ganze Zahl myValue wird mit der System.Int32.ToString-Methode formatiert.

public class MyType : IFormattable
{
    // Assign a value for the class.
    private int myValue;

    // Add a constructor.
    public MyType( int value )
    {
        myValue = value;
    }
    // Write a custom Format method for the type.
    public string ToString(string format, IFormatProvider fp)
    {
        if (format.Equals ("b"))
            {
            return Convert.ToString (myValue, 2);
            }
        else
            {
            return myValue.ToString(format, fp);
            }
    }
}


Im folgenden Beispiel wird die Verwendung der MyType-Klasse und der "b"-Formatzeichenfolge veranschaulicht.

MyType mtype = new MyType(42);
String myString = mtype.ToString("b", null);
String yourString = mtype.ToString("d", null);
Console.WriteLine(myString);
Console.WriteLine(yourString);
// The example produces the following output:
//       101010
//       42


Sie können das Formatieren eines vorhandenen Basistyps steuern und zusätzlichen Code für die Formatierung bereitstellen, indem Sie eine Formatanbieterklasse erstellen, die ICustomFormatter und IFormatProvider implementiert.

Wenn Sie einen Formatanbieter an die ToString-Methode eines Basistyps übergeben, verwendet der Basistyp zum Definieren der Formatierungsregeln den übergebenen Formatanbieter und nicht den Standardformatanbieter. Zum Erstellen eines benutzerdefinierten Formatanbieters gehen Sie wie folgt vor:

  1. Definieren Sie eine Klasse, die die beiden bereits genannten Schnittstellen implementiert und GetFormat und Format überschreibt.

  2. Übergeben Sie diese Klasse an eine Methode (z. B. String.Format), die IFormatProvider als einen Parameter übernimmt. Dadurch erkennt String.Format das benutzerdefinierte Formatschema, das in der neuen Formatanbieterklasse definiert ist.

Im folgenden Beispiel wird eine Klasse definiert, die eine benutzerdefinierte Format-Methode hinzufügt, mit der unterschiedliche Basiswerte einer ganzen Zahl erstellt werden können.

public class MyFormat : IFormatProvider, ICustomFormatter
{
    // String.Format calls this method to get an instance of an
    // ICustomFormatter to handle the formatting.
    public object GetFormat (Type service)
    {
        if (service == typeof (ICustomFormatter))
        {
            return this;
        }
        else
        {
            return null;
        }
    }
    // After String.Format gets the ICustomFormatter, it calls this format
    // method on each argument.
    public string Format(string format, object arg, IFormatProvider provider) 
    {
        if (format == null)
        {
            return String.Format ("{0}", arg);
        }
        // If the format is not a defined custom code,
        // use the formatting support in ToString.
        if (!format.StartsWith("B")) 
        {
            //If the object to be formatted supports the IFormattable
            //interface, pass the format specifier to the 
            //objects ToString method for formatting.
            if (arg is IFormattable) 
            {
                return ((IFormattable)arg).ToString(format, provider);
            } 
            //If the object does not support IFormattable, 
            //call the objects ToString method with no additional
            //formatting. 
            else if (arg != null) 
            {
                return arg.ToString();
            }
        }
        // Uses the format string to
        // form the output string.
        format = format.Trim (new char [] {'B'});
        int b = Convert.ToInt32 (format);
        return Convert.ToString ((int)arg, b);
    }
}


Im folgenden Beispiel verwendet die Format-Methode die in MyFormat festgelegte benutzerdefinierte Format-Methode, um die Hexadezimaldarstellung von MyInt anzuzeigen.

int MyInt = 42;
string myString = String.Format(new MyFormat(), 
                         "{0} in the custom B16 format is {1:B16}", 
                         new object[] {MyInt, MyInt});
Console.WriteLine(myString);                               
// The example displays the following output: 
//       42 in custom B16 format is 2a


Community-Beiträge

Anzeigen: