ICustomFormatter.Format(String, Object, IFormatProvider) Metodo

Definizione

Converte il valore di un oggetto specificato in una rappresentazione di stringa equivalente usando il formato e le informazioni di formattazione specifiche delle impostazioni cultura indicati.

public string Format (string format, object arg, IFormatProvider formatProvider);
public string Format (string? format, object? arg, IFormatProvider? formatProvider);

Parametri

format
String

Stringa di formato contenente specifiche di formato.

arg
Object

Oggetto da formattare.

formatProvider
IFormatProvider

Oggetto che fornisce informazioni sul formato relative all'istanza corrente.

Restituisce

Rappresentazione di stringa del valore di arg, formattato in base a quanto specificato da format e formatProvider.

Esempio

L'esempio seguente implementa ICustomFormatter per consentire la formattazione binaria, ottale ed esadecimale dei valori integrali. L'implementazione ICustomFormatter.Format determina se il parametro di formato è una delle tre stringhe di formato supportate ("B" per binary, "O" per ottale e "H" per esadecimale) e formatta il arg parametro in modo appropriato. In caso contrario, se arg non nullè , chiama l'implementazione arg del IFormattable.ToString parametro, se esistente o il relativo metodo senza ToString parametri, se non ne esiste uno. Se arg è null, il metodo restituisce String.Empty.

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 può quindi essere usato per fornire formattazione personalizzata passando un MyFormatter oggetto come provider parametro del Format metodo , come illustrato nell'esempio seguente.

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)

Commenti

ICustomFormatter.Format è un metodo di callback. Viene chiamato da un metodo che supporta la formattazione personalizzata, ad esempio String.Format(IFormatProvider, String, Object[]) o StringBuilder.AppendFormat(IFormatProvider, String, Object[]). L'implementazione viene chiamata una volta per ogni elemento di formato in una stringa di formato composito. Nell'istruzione seguente, ad esempio, il ICustomFormatter.Format metodo viene chiamato tre volte.

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

Il arg parametro è l'oggetto nell'elenco di oggetti la cui posizione in base zero corrisponde all'indice di un elemento di formato specifico.

Il format parametro contiene una stringa di formato, che è il formatString componente di un elemento di formato. Se l'elemento di formato non ha alcun formatString componente, il valore di format è null. Se format è null, a seconda del tipo di arg, è possibile usare la specifica di formato predefinita di propria scelta.

Il formatProvider parametro è l'implementazione IFormatProvider che fornisce la formattazione per arg. In genere, si tratta di un'istanza dell'implementazione ICustomFormatter . Se formatProvider è null, ignorare il parametro.

L'implementazione del Format metodo deve includere le funzionalità seguenti, in modo che .NET Framework possa fornire la formattazione non supportata. Se il metodo di formato non supporta un formato, determinare se l'oggetto formattato implementa l'interfaccia IFormattable . In tal caso, richiamare il IFormattable.ToString metodo di tale interfaccia. In caso contrario, richiamare il metodo predefinito Object.ToString dell'oggetto sottostante. Il codice seguente illustra questo modello.

if (arg is IFormattable)
    return ((IFormattable)arg).ToString(format, CultureInfo.CurrentCulture);
else if (arg != null)
    return arg.ToString();

Si applica a

Prodotto Versioni
.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

Vedi anche