ICustomFormatter Rozhraní

Definice

Definuje metodu, která podporuje vlastní formátování hodnoty objektu.

C#
public interface ICustomFormatter
C#
[System.Runtime.InteropServices.ComVisible(true)]
public interface ICustomFormatter
Atributy

Příklady

Následující příklad umožňuje ICustomFormatter binární, osmičkové a šestnáctkové formátování integrálních hodnot. V tomto příkladu jedna třída MyFormatter, implementuje a ICustomFormatterIFormatProvider. Jeho IFormatProvider.GetFormat metoda určuje, zda formatType parametr představuje ICustomFormatter typ. Pokud ano, MyFormatter vrátí instanci sebe sama, v opačném případě vrátí null. Jeho ICustomFormatter.Format implementace určuje, zda je parametr format jedním ze tří podporovaných formátových řetězců ("B" pro binární, "O" pro osmičkový a "H" pro hexadecimální) a formátuje arg parametr odpovídajícím způsobem. V opačném případě, pokud arg není null, volá implementaci parametru IFormattable.ToStringarg, pokud existuje, nebo jeho bezparametrovou ToString metodu, pokud není. Pokud arg je null, vrátí String.Emptymetoda .

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 pak lze použít k poskytnutí vlastního formátování předáním objektu MyFormatterprovider jako parametru Format metody, jak ukazuje následující příklad.

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)

Poznámky

Rozhraní ICustomFormatter obsahuje jednu metodu, ICustomFormatter.Format. Když je toto rozhraní implementováno odkazem nebo hodnotovým typem Format , vrátí metoda vlastní formátovanou řetězcovou reprezentaci hodnoty objektu.

Rozhraní ICustomFormatter je obvykle implementováno s rozhraním IFormatProvider pro přizpůsobení chování dvou metod formátování složeného řetězce rozhraní .NET Framework, které obsahují IFormatProvider parametr. Konkrétně ICustomFormatter může rozhraní poskytovat vlastní formátování hodnoty objektu předané metodám String.Format(IFormatProvider, String, Object[]) a StringBuilder.AppendFormat(IFormatProvider, String, Object[]) .

Poskytnutí vlastní reprezentace hodnoty objektu vyžaduje, abyste udělali následující:

  1. Definujte třídu, která implementuje ICustomFormatter rozhraní a jeho jediný člen, metodu Format .

  2. Definujte třídu, která implementuje IFormatProvider rozhraní a jeho jediný člen, metodu GetFormat . Metoda GetFormat vrátí instanci vaší ICustomFormatter implementace. Jedna třída často implementuje i ICustomFormatterIFormatProvider. V takovém případě implementace třídy GetFormat pouze vrátí instanci sama o sobě.

  3. Předejte implementaci IFormatProvider jako provider argument String.Format(IFormatProvider, String, Object[]) metody nebo srovnatelné metody.

Metoda knihovny .NET pak místo vlastního formátování použije vlastní formátování.

Poznámky pro implementátory

Modul CLR (Common Language Runtime) se pokusí použít vaši ICustomFormatter implementaci pro každou položku formátu ve složené řetězci formátu. V důsledku toho byste měli očekávat, že vaše ICustomFormatter implementace bude volána, aby poskytovala služby formátování pro objekty nebo hodnoty, které nejsou navrženy pro zpracování. V těchto případech musí metoda Format(String, Object, IFormatProvider) volat odpovídající metodu formátování pro daný objekt nebo hodnotu.

Existují dva druhy ICustomFormatter implementací: vnitřní a rozšiřující.

Vnitřní implementace jsou implementace, které poskytují vlastní formátování pro objekt definovaný aplikací. V takovém případě by vaše implementace měla zahrnovat následující:

  • Definice formátovací řetězce, které definují formátování objektu. Formátovací řetězce jsou volitelné. Řetězec formátu "G" nebo "g" obvykle definuje obecný (nebo nejčastěji používaný) formát. Můžete ale definovat libovolné formátovací řetězce, které zvolíte. Můžete se také rozhodnout, jestli rozlišují malá a malá písmena nebo nerozlišují malá a malá písmena.

  • Test, který zajistí, že typ objektu předaný vaší Format(String, Object, IFormatProvider) metodě je typem definovaným vaší aplikací. Pokud není, měli byste volat implementaci objektu IFormattable , pokud existuje, nebo jeho ToString() metodu, pokud neexistuje. Měli byste být připraveni zpracovat všechny výjimky, které by tato volání metody mohla vyvolat.

  • Kód pro zpracování řetězce formátu null, pokud vaše implementace podporuje formátovací řetězce. Nejběžnějším přístupem je nahrazení řetězce formátu null obecným specifikátorem formátu.

  • Kód pro zpracování všech formátových řetězců, které vaše implementace podporuje.

  • Kód pro zpracování formátových řetězců, které nepodporujete. Nejběžnějším přístupem je vyvolání FormatExceptionpříkazu , i když můžete zadat výchozí formátování.

Implementace rozšíření jsou implementace, které poskytují vlastní formátování pro typ, který už má podporu formátování. Můžete například definovat CustomerNumberFormatter , který formátuje celočíselný typ pomocí spojovníků mezi konkrétními číslicemi. V takovém případě by vaše implementace měla zahrnovat následující:

  • Definice formátovací řetězce, které rozšiřují formátování objektu. Tyto formátovací řetězce jsou povinné, ale nesmí být v konfliktu s existujícími formátovacími řetězci typu. Pokud například rozšiřujete formátování pro Int32 typ, neměli byste implementovat mimo jiné specifikátory formátu "C", "D", "E", "F" a "G".

  • Test, že typ objektu předaný vaší Format(String, Object, IFormatProvider) metodě je typ, jehož formátování rozšíření podporuje. Pokud tomu tak není, zavolejte implementaci objektu IFormattable , pokud existuje, nebo metodu bez ToString() parametrů objektu, pokud neexistuje. Měli byste být připraveni zpracovat všechny výjimky, které by tato volání metody mohla vyvolat.

  • Kód pro zpracování všech formátových řetězců, které vaše rozšíření podporuje.

  • Kód pro zpracování všech formátových řetězců, které vaše rozšíření nepodporuje. Ty by se měly předat implementaci typu IFormattable . Měli byste být připraveni zpracovat všechny výjimky, které by tato volání metody mohla vyvolat.

Metody

Format(String, Object, IFormatProvider)

Převede hodnotu zadaného objektu na ekvivalentní řetězcovou reprezentaci pomocí zadaného formátu a informací o formátování specifické pro jazykovou verzi.

Platí pro

Produkt Verze
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

Viz také