Přehled: Formátování čísel, kalendářních dat, výčtů a dalších typů v .NET

Formátování je proces převodu instance třídy nebo struktury nebo výčtu na řetězcovou reprezentaci. Účelem je zobrazit výsledný řetězec uživatelům nebo deserializovat později k obnovení původního datového typu. Tento článek představuje mechanismy formátování, které poskytuje .NET.

Základní mechanismus pro formátování je výchozí implementace Object.ToString metody, která je popsána v části Výchozí formátování Pomocí ToString Method oddíl dále v tomto tématu. .NET ale nabízí několik způsobů, jak změnit a rozšířit výchozí podporu formátování. Patří mezi ně následující:

• Object.ToString Přepsání metody pro definování vlastní řetězcové reprezentace hodnoty objektu. Další informace naleznete v části Přepsat toString Metoda dále v tomto tématu.

• Definování specifikátorů formátu,kteréchm znakům objektu, které umožňují řetězcovou reprezentaci hodnoty objektu, Například specifikátor formátu "X" v následujícím příkazu převede celé číslo na řetězcovou reprezentaci šestnáctkové hodnoty.

  int integerValue = 60312;
  Console.WriteLine(integerValue.ToString("X"));   // Displays EB98.
  

  Dim integerValue As Integer = 60312
  Console.WriteLine(integerValue.ToString("X"))   ' Displays EB98.
  

  Další informace o specifikátorech formátu naleznete v části ToString Method a Format Strings .

• Použití zprostředkovatelů formátu k implementaci konvencí formátování konkrétní jazykové verze. Následující příkaz například zobrazí hodnotu měny pomocí konvencí formátování jazykové verze en-US.

  double cost = 1632.54;
  Console.WriteLine(cost.ToString("C",
                    new System.Globalization.CultureInfo("en-US")));
  // The example displays the following output:
  //       $1,632.54
  

  Dim cost As Double = 1632.54
  Console.WriteLine(cost.ToString("C", New System.Globalization.CultureInfo("en-US")))
  ' The example displays the following output:
  '       $1,632.54
  

  Další informace o formátování pomocí zprostředkovatelů formátu najdete v části Formát zprostředkovatele .

• IFormattable Implementace rozhraní pro podporu převodu Convert řetězců s třídou a složeným formátováním. Další informace naleznete v části Rozhraní IFormattable.

• Použití složeného formátování k vložení řetězcové reprezentace hodnoty do většího řetězce. Další informace najdete v části Složené formátování .

• Pomocí interpolace řetězců je čitelnější syntaxe pro vložení řetězcové reprezentace hodnoty do většího řetězce. Další informace naleznete v tématu Interpolace řetězců.

• Implementace ICustomFormatter a IFormatProvider poskytnutí kompletního vlastního řešení formátování Další informace najdete v části Vlastní formátování pomocí ICustomFormatter .

Následující části prověřují tyto metody převodu objektu na řetězcovou reprezentaci.

Výchozí formátování pomocí metody ToString

Každý typ odvozený automaticky System.Object dědí bezparametrovou metodu ToString , která ve výchozím nastavení vrátí název typu. Následující příklad znázorňuje výchozí ToString metodu. Definuje třídu s názvem Automobile , která nemá žádnou implementaci. Při vytvoření instance třídy a její ToString metoda je volána, zobrazí název jeho typu. Všimněte si, že ToString metoda není explicitně volána v příkladu. Metoda Console.WriteLine(Object) implicitně volá metodu ToString objektu předaného jako argument.

using System;

public class Automobile
{
   // No implementation. All members are inherited from Object.
}

public class Example9
{
   public static void Main()
   {
      Automobile firstAuto = new Automobile();
      Console.WriteLine(firstAuto);
   }
}
// The example displays the following output:
//       Automobile

Public Class Automobile
    ' No implementation. All members are inherited from Object.
End Class

Module Example9
    Public Sub Main9()
        Dim firstAuto As New Automobile()
        Console.WriteLine(firstAuto)
    End Sub
End Module
' The example displays the following output:
'       Automobile

Vzhledem k tomu, že všechny jiné typy než rozhraní jsou odvozeny Object, tato funkce se automaticky poskytuje vašim vlastním třídám nebo strukturám. Funkce nabízené výchozí ToString metodou je však omezená: Přestože identifikuje typ, neposkytuje žádné informace o instanci typu. Chcete-li poskytnout řetězcové vyjádření objektu, který poskytuje informace o tomto objektu, je nutné přepsat metodu ToString .

Přepsání metody ToString

Zobrazení názvu typu je často omezené a neumožňuje uživatelům typů rozlišovat jednu instanci od druhé. Můžete však přepsat metodu ToString , která poskytuje užitečnější reprezentaci hodnoty objektu. Následující příklad definuje Temperature objekt a přepíše jeho ToString metodu k zobrazení teploty ve stupních Celsia.

public class Temperature
{
    private decimal temp;

    public Temperature(decimal temperature)
    {
        this.temp = temperature;
    }

    public override string ToString()
    {
        return this.temp.ToString("N1") + "°C";
    }
}

public class Example12
{
    public static void Main()
    {
        Temperature currentTemperature = new Temperature(23.6m);
        Console.WriteLine($"The current temperature is {currentTemperature}");
    }
}
// The example displays the following output:
//       The current temperature is 23.6°C.

Public Class Temperature
    Private temp As Decimal

    Public Sub New(temperature As Decimal)
        Me.temp = temperature
    End Sub

    Public Overrides Function ToString() As String
        Return Me.temp.ToString("N1") + "°C"
    End Function
End Class

Module Example13
    Public Sub Main13()
        Dim currentTemperature As New Temperature(23.6D)
        Console.WriteLine("The current temperature is " +
                          currentTemperature.ToString())
    End Sub
End Module
' The example displays the following output:
'       The current temperature is 23.6°C.

V .NET byla metoda každého primitivního typu hodnoty přepsána tak, ToString aby zobrazovala hodnotu objektu místo jejího názvu. Následující tabulka ukazuje přepsání pro každý primitivní typ. Všimněte si, že většina přepsaných metod volá další přetížení metody a předá mu specifikátor formátu "G", který definuje obecný formát pro jeho typ, a IFormatProvider objekt, který představuje aktuální jazykovou verziToString.

ToString – metoda a formátovací řetězce

Spoléhání na výchozí ToString metodu nebo přepsání ToString je vhodné, pokud má objekt jedno řetězcové vyjádření. Hodnota objektu má však často více reprezentací. Například teplota může být vyjádřena ve stupních Fahrenheita, stupňů Celsia nebo kelviny. Podobně může být celočíselná hodnota 10 reprezentována mnoha způsoby, včetně 10, 10,0, 1,0e01 nebo $10,00.

Aby jedna hodnota měla více řetězcových reprezentací, používá .NET formátovací řetězce. Formátovací řetězec je řetězec, který obsahuje jeden nebo více předdefinovaných specifikátorů formátu, což jsou jednotlivé znaky nebo skupiny znaků, které definují, jak ToString má metoda formátovat výstup. Formátovací řetězec se pak předá jako parametr metodě objektu ToString a určuje, jak se má zobrazovat řetězcová reprezentace hodnoty daného objektu.

Všechny číselné typy, typy data a času a typy výčtů v .NET podporují předdefinovanou sadu specifikátorů formátu. K definování více řetězcových reprezentací datových typů definovaných aplikací můžete použít také formátovací řetězce.

Standardní formátovací řetězce

Řetězec standardního formátu obsahuje specifikátor jednoho formátu, což je abecední znak definující řetězcovou reprezentaci objektu, na který se používá, spolu s volitelným specifikátorem přesnosti, který ovlivňuje počet číslic zobrazených ve výsledném řetězci. Pokud je specifikátor přesnosti vynechán nebo není podporován, je specifikátor standardního formátu ekvivalentní řetězci standardního formátu.

.NET definuje sadu standardních specifikátorů formátu pro všechny číselné typy, všechny typy data a času a všechny typy výčtů. Každá z těchto kategorií například podporuje specifikátor standardního formátu "G", který definuje obecnou řetězcovou reprezentaci hodnoty tohoto typu.

Standardní formátovací řetězce pro typy výčtu přímo řídí řetězcovou reprezentaci hodnoty. Formátovací řetězce předané metodě výčtové hodnoty ToString určují, zda je hodnota zobrazena pomocí názvu řetězce (specifikátory formátu "G" a "F"), jeho základní celočíselné hodnoty (specifikátor formátu "D") nebo jeho šestnáctkové hodnoty (specifikátor formátu "X"). Následující příklad znázorňuje použití standardních formátových řetězců k formátování hodnoty výčtu DayOfWeek .

DayOfWeek thisDay = DayOfWeek.Monday;
string[] formatStrings = {"G", "F", "D", "X"};

foreach (string formatString in formatStrings)
   Console.WriteLine(thisDay.ToString(formatString));
// The example displays the following output:
//       Monday
//       Monday
//       1
//       00000001

Dim thisDay As DayOfWeek = DayOfWeek.Monday
Dim formatStrings() As String = {"G", "F", "D", "X"}

For Each formatString As String In formatStrings
    Console.WriteLine(thisDay.ToString(formatString))
Next
' The example displays the following output:
'       Monday
'       Monday
'       1
'       00000001

Informace o formátovací řetězce výčtu naleznete v tématu Výčtové formát řetězce.

Standardní formátovací řetězce pro číselné typy obvykle definují výsledný řetězec, jehož přesný vzhled je řízen jednou nebo více hodnotami vlastností. Specifikátor formátu "C" například naformátuje číslo jako hodnotu měny. Při volání ToString metody se specifikátorem formátu "C" jako jediný parametr se k definování řetězcové reprezentace číselné hodnoty použijí následující hodnoty vlastností z objektu aktuální jazykové verze NumberFormatInfo :

• Vlastnost CurrencySymbol , která určuje symbol měny aktuální jazykové verze.

• Nebo CurrencyNegativePattern CurrencyPositivePattern vlastnost, která vrátí celé číslo, které určuje následující:

  • Umístění symbolu měny.

  • Zda jsou záporné hodnoty označeny úvodním záporným znaménkem, koncovým záporným znaménkem nebo závorky.

  • Určuje, jestli se mezera zobrazí mezi číselnou hodnotou a symbolem měny.

• Vlastnost CurrencyDecimalDigits , která definuje počet desetinných číslic ve výsledném řetězci.

• Vlastnost CurrencyDecimalSeparator , která definuje symbol oddělovače desetinných míst ve výsledném řetězci.

• Vlastnost CurrencyGroupSeparator , která definuje symbol oddělovače skupin.

• Vlastnost CurrencyGroupSizes , která definuje počet číslic v každé skupině vlevo od desetinné čárky.

• Vlastnost NegativeSign , která určuje záporné znaménko použité ve výsledném řetězci, pokud závorky nejsou použity k označení záporných hodnot.

Řetězce číselného formátu mohou navíc obsahovat specifikátor přesnosti. Význam tohoto specifikátoru závisí na řetězci formátu, se kterým se používá, ale obvykle označuje celkový počet číslic nebo počet desetinných číslic, které by se měly zobrazit ve výsledném řetězci. Například následující příklad používá standardní číselný řetězec "X4" a specifikátor přesnosti k vytvoření řetězcové hodnoty, která má čtyři šestnáctkové číslice.

byte[] byteValues = { 12, 163, 255 };
foreach (byte byteValue in byteValues)
   Console.WriteLine(byteValue.ToString("X4"));
// The example displays the following output:
//       000C
//       00A3
//       00FF

Dim byteValues() As Byte = {12, 163, 255}
For Each byteValue As Byte In byteValues
    Console.WriteLine(byteValue.ToString("X4"))
Next
' The example displays the following output:
'       000C
'       00A3
'       00FF

Další informace o standardních řetězcích číselného formátování naleznete v tématu Standardní řetězce číselného formátu.

Standardní formátovací řetězce pro hodnoty data a času jsou aliasy pro vlastní formátovací řetězce uložené konkrétní DateTimeFormatInfo vlastností. Například volání ToString metody hodnoty data a času se specifikátorem formátu "D" zobrazí datum a čas pomocí řetězce vlastního formátu uloženého ve vlastnosti aktuální jazykové verze DateTimeFormatInfo.LongDatePattern . (Další informace o řetězcích vlastního formátu najdete v další části.) Následující příklad znázorňuje tuto relaci.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date1 = new DateTime(2009, 6, 30);
      Console.WriteLine("D Format Specifier:     {0:D}", date1);
      string longPattern = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern;
      Console.WriteLine("'{0}' custom format string:     {1}",
                        longPattern, date1.ToString(longPattern));
   }
}
// The example displays the following output when run on a system whose
// current culture is en-US:
//    D Format Specifier:     Tuesday, June 30, 2009
//    'dddd, MMMM dd, yyyy' custom format string:     Tuesday, June 30, 2009

Imports System.Globalization

Module Example
    Public Sub Main0()
        Dim date1 As Date = #6/30/2009#
        Console.WriteLine("D Format Specifier:     {0:D}", date1)
        Dim longPattern As String = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern
        Console.WriteLine("'{0}' custom format string:     {1}",
                          longPattern, date1.ToString(longPattern))
    End Sub
End Module
' The example displays the following output when run on a system whose
' current culture is en-US:
'    D Format Specifier:     Tuesday, June 30, 2009
'    'dddd, MMMM dd, yyyy' custom format string:     Tuesday, June 30, 2009

Další informace o standardních řetězcích formátu data a času naleznete v tématu Standardní řetězce formátu data a času.

Standardní formátovací řetězce můžete také použít k definování řetězcové reprezentace objektu definovaného aplikací, který je vytvořen metodou objektu ToString(String) . Můžete definovat konkrétní specifikátory standardního formátu, které objekt podporuje, a můžete určit, zda se rozlišují malá a velká písmena nebo nerozlišují malá a velká písmena. Vaše implementace ToString(String) metody by měla podporovat následující:

• Specifikátor formátu "G", který představuje vlastní nebo běžný formát objektu. Přetížení bez parametrů metody objektu ToString by mělo volat jeho ToString(String) přetížení a předat "G" standardní formátovací řetězec.

• Podpora specifikátoru formátu, který se rovná odkazu null (Nothing v jazyce Visual Basic). Specifikátor formátu, který se rovná odkazu null, by se měl považovat za ekvivalent specifikátoru formátu "G".

Třída může například Temperature interně uložit teplotu ve stupních Celsia a použít specifikátory formátu k reprezentaci hodnoty objektu Temperature ve stupních Celsia, stupňů Fahrenheita a kelvins. V následujícím příkladu je uvedena ukázka.

using System;

public class Temperature
{
   private decimal m_Temp;

   public Temperature(decimal temperature)
   {
      this.m_Temp = temperature;
   }

   public decimal Celsius
   {
      get { return this.m_Temp; }
   }

   public decimal Kelvin
   {
      get { return this.m_Temp + 273.15m; }
   }

   public decimal Fahrenheit
   {
      get { return Math.Round(((decimal) (this.m_Temp * 9 / 5 + 32)), 2); }
   }

   public override string ToString()
   {
      return this.ToString("C");
   }

   public string ToString(string format)
   {
      // Handle null or empty string.
      if (String.IsNullOrEmpty(format)) format = "C";
      // Remove spaces and convert to uppercase.
      format = format.Trim().ToUpperInvariant();

      // Convert temperature to Fahrenheit and return string.
      switch (format)
      {
         // Convert temperature to Fahrenheit and return string.
         case "F":
            return this.Fahrenheit.ToString("N2") + " °F";
         // Convert temperature to Kelvin and return string.
         case "K":
            return this.Kelvin.ToString("N2") + " K";
         // return temperature in Celsius.
         case "G":
         case "C":
            return this.Celsius.ToString("N2") + " °C";
         default:
            throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
      }
   }
}

public class Example1
{
   public static void Main()
   {
      Temperature temp1 = new Temperature(0m);
      Console.WriteLine(temp1.ToString());
      Console.WriteLine(temp1.ToString("G"));
      Console.WriteLine(temp1.ToString("C"));
      Console.WriteLine(temp1.ToString("F"));
      Console.WriteLine(temp1.ToString("K"));

      Temperature temp2 = new Temperature(-40m);
      Console.WriteLine(temp2.ToString());
      Console.WriteLine(temp2.ToString("G"));
      Console.WriteLine(temp2.ToString("C"));
      Console.WriteLine(temp2.ToString("F"));
      Console.WriteLine(temp2.ToString("K"));

      Temperature temp3 = new Temperature(16m);
      Console.WriteLine(temp3.ToString());
      Console.WriteLine(temp3.ToString("G"));
      Console.WriteLine(temp3.ToString("C"));
      Console.WriteLine(temp3.ToString("F"));
      Console.WriteLine(temp3.ToString("K"));

      Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3));
   }
}
// The example displays the following output:
//       0.00 °C
//       0.00 °C
//       0.00 °C
//       32.00 °F
//       273.15 K
//       -40.00 °C
//       -40.00 °C
//       -40.00 °C
//       -40.00 °F
//       233.15 K
//       16.00 °C
//       16.00 °C
//       16.00 °C
//       60.80 °F
//       289.15 K
//       The temperature is now 16.00 °C.

Public Class Temperature
    Private m_Temp As Decimal

    Public Sub New(temperature As Decimal)
        Me.m_Temp = temperature
    End Sub

    Public ReadOnly Property Celsius() As Decimal
        Get
            Return Me.m_Temp
        End Get
    End Property

    Public ReadOnly Property Kelvin() As Decimal
        Get
            Return Me.m_Temp + 273.15D
        End Get
    End Property

    Public ReadOnly Property Fahrenheit() As Decimal
        Get
            Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
        End Get
    End Property

    Public Overrides Function ToString() As String
        Return Me.ToString("C")
    End Function

    Public Overloads Function ToString(format As String) As String
        ' Handle null or empty string.
        If String.IsNullOrEmpty(format) Then format = "C"
        ' Remove spaces and convert to uppercase.
        format = format.Trim().ToUpperInvariant()

        Select Case format
            Case "F"
                ' Convert temperature to Fahrenheit and return string.
                Return Me.Fahrenheit.ToString("N2") & " °F"
            Case "K"
                ' Convert temperature to Kelvin and return string.
                Return Me.Kelvin.ToString("N2") & " K"
            Case "C", "G"
                ' Return temperature in Celsius.
                Return Me.Celsius.ToString("N2") & " °C"
            Case Else
                Throw New FormatException(String.Format("The '{0}' format string is not supported.", format))
        End Select
    End Function
End Class

Public Module Example1
    Public Sub Main1()
        Dim temp1 As New Temperature(0D)
        Console.WriteLine(temp1.ToString())
        Console.WriteLine(temp1.ToString("G"))
        Console.WriteLine(temp1.ToString("C"))
        Console.WriteLine(temp1.ToString("F"))
        Console.WriteLine(temp1.ToString("K"))

        Dim temp2 As New Temperature(-40D)
        Console.WriteLine(temp2.ToString())
        Console.WriteLine(temp2.ToString("G"))
        Console.WriteLine(temp2.ToString("C"))
        Console.WriteLine(temp2.ToString("F"))
        Console.WriteLine(temp2.ToString("K"))

        Dim temp3 As New Temperature(16D)
        Console.WriteLine(temp3.ToString())
        Console.WriteLine(temp3.ToString("G"))
        Console.WriteLine(temp3.ToString("C"))
        Console.WriteLine(temp3.ToString("F"))
        Console.WriteLine(temp3.ToString("K"))

        Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3))
    End Sub
End Module
' The example displays the following output:
'       0.00 °C
'       0.00 °C
'       0.00 °C
'       32.00 °F
'       273.15 K
'       -40.00 °C
'       -40.00 °C
'       -40.00 °C
'       -40.00 °F
'       233.15 K
'       16.00 °C
'       16.00 °C
'       16.00 °C
'       60.80 °F
'       289.15 K
'       The temperature is now 16.00 °C.

Vlastní formátovací řetězce

Kromě standardních formátových řetězců definuje .NET vlastní formátovací řetězce pro číselné hodnoty i hodnoty data a času. Řetězec vlastního formátu se skládá z jednoho nebo více specifikátorů vlastního formátu, které definují řetězcovou reprezentaci hodnoty. Například řetězec vlastního formátu data a času "rrrr/mm/dd hh:mm:ss.ffff t zzz" převede datum na řetězcovou reprezentaci ve formátu "2008/11/15 07:45:00.0000 P -08:000" pro jazykovou verzi en-US. Podobně řetězec vlastního formátu "0000" převede celočíselnou hodnotu 12 na "0012". Úplný seznam řetězců vlastního formátu najdete v tématu Vlastní řetězce formátu data a času a vlastní řetězce číselného formátu.

Pokud se řetězec formátu skládá z jednoho specifikátoru vlastního formátu, měl by specifikátor formátu předcházet symbol procenta (%), aby nedocházelo k nejasnostem se specifikátorem standardního formátu. Následující příklad používá specifikátor vlastního formátu "M" k zobrazení jednociferného nebo dvoumístného čísla měsíce konkrétního data.

DateTime date1 = new DateTime(2009, 9, 8);
Console.WriteLine(date1.ToString("%M"));       // Displays 9

Dim date1 As Date = #09/08/2009#
Console.WriteLine(date1.ToString("%M"))      ' Displays 9

Mnoho standardních formátových řetězců pro hodnoty data a času jsou aliasy pro vlastní formátovací řetězce, které jsou definovány vlastnostmi objektu DateTimeFormatInfo . Řetězce vlastního formátu také nabízejí značnou flexibilitu při poskytování formátování definovaného aplikací pro číselné hodnoty nebo hodnoty data a času. Vlastní výsledné řetězce můžete definovat pro číselné hodnoty i hodnoty data a času kombinováním více specifikátorů vlastního formátu do jednoho řetězce vlastního formátu. Následující příklad definuje řetězec vlastního formátu, který zobrazuje den v týdnu v závorkách za názvem měsíce, dnem a rokem.

string customFormat = "MMMM dd, yyyy (dddd)";
DateTime date1 = new DateTime(2009, 8, 28);
Console.WriteLine(date1.ToString(customFormat));
// The example displays the following output if run on a system
// whose language is English:
//       August 28, 2009 (Friday)

Dim customFormat As String = "MMMM dd, yyyy (dddd)"
Dim date1 As Date = #8/28/2009#
Console.WriteLine(date1.ToString(customFormat))
' The example displays the following output if run on a system
' whose language is English:
'       August 28, 2009 (Friday)      

Následující příklad definuje řetězec vlastního formátu, který zobrazuje Int64 hodnotu jako standardní sedmiciferné telefonní číslo USA spolu s kódem oblasti.

using System;

public class Example17
{
   public static void Main()
   {
      long number = 8009999999;
      string fmt = "000-000-0000";
      Console.WriteLine(number.ToString(fmt));
   }
}
// The example displays the following output:
//        800-999-9999

Module Example18
    Public Sub Main18()
        Dim number As Long = 8009999999
        Dim fmt As String = "000-000-0000"
        Console.WriteLine(number.ToString(fmt))
    End Sub
End Module
' The example displays the following output:

' The example displays the following output:
'       800-999-9999

Přestože standardní formátovací řetězce můžou obecně zpracovávat většinu potřeb formátování pro typy definované aplikací, můžete také definovat specifikátory vlastního formátu pro formátování typů.

Formátování řetězců a typů .NET

Všechny číselné typy (tj. Byte, , Decimal, DoubleInt16, Int32, Int64, SByte, Single, UInt16UInt32, UInt64a BigInteger typy), a také DateTime, , DateTimeOffset, TimeSpan, Guida všechny typy výčtů, podporují formátování pomocí formátových řetězců. Informace o konkrétních formátových řetězcích podporovaných jednotlivými typy najdete v následujících tématech:

Formátování citlivé na jazykovou verzi pomocí zprostředkovatelů formátů

Přestože specifikátory formátu umožňují přizpůsobit formátování objektů, vytváření smysluplné řetězcové reprezentace objektů často vyžaduje další informace o formátování. Například formátování čísla jako hodnoty měny pomocí standardního řetězce formátu "C" nebo vlastního formátovacího řetězce, například "$ #,#.00", vyžaduje minimálně informace o správném symbolu měny, oddělovači skupin a oddělovači desetinných míst, které mají být k dispozici pro zahrnutí do formátovaného řetězce. V rozhraní .NET jsou tyto další informace o formátování zpřístupněny prostřednictvím IFormatProvider rozhraní, které je poskytováno jako parametr jedné nebo více přetížení ToString metody číselných typů a typů data a času. IFormatProvider implementace se v .NET používají k podpoře formátování specifického pro jazykovou verzi. Následující příklad ukazuje, jak se řetězcová reprezentace objektu změní, když je formátována třemi IFormatProvider objekty, které představují různé jazykové verze.

using System;
using System.Globalization;

public class Example18
{
   public static void Main()
   {
      decimal value = 1603.42m;
      Console.WriteLine(value.ToString("C3", new CultureInfo("en-US")));
      Console.WriteLine(value.ToString("C3", new CultureInfo("fr-FR")));
      Console.WriteLine(value.ToString("C3", new CultureInfo("de-DE")));
   }
}
// The example displays the following output:
//       $1,603.420
//       1 603,420 €
//       1.603,420 €

Imports System.Globalization

Public Module Example11
    Public Sub Main11()
        Dim value As Decimal = 1603.42D
        Console.WriteLine(value.ToString("C3", New CultureInfo("en-US")))
        Console.WriteLine(value.ToString("C3", New CultureInfo("fr-FR")))
        Console.WriteLine(value.ToString("C3", New CultureInfo("de-DE")))
    End Sub
End Module
' The example displays the following output:
'       $1,603.420
'       1 603,420 €
'       1.603,420 €

Rozhraní IFormatProvider obsahuje jednu metodu, GetFormat(Type)která má jeden parametr, který určuje typ objektu, který poskytuje informace o formátování. Pokud metoda může poskytnout objekt tohoto typu, vrátí jej. V opačném případě vrátí nulový odkaz (Nothing v jazyce Visual Basic).

IFormatProvider.GetFormat je metoda zpětného volání. Při volání ToString přetížení metody, která obsahuje IFormatProvider parametr, volá GetFormat metodu tohoto IFormatProvider objektu. Metoda GetFormat je zodpovědná za vrácení objektu, který poskytuje nezbytné informace o formátování, jak je specifikováno jeho formatType parametrem, metodě ToString .

Řada metod formátování nebo převodu řetězců zahrnuje parametr typu IFormatProvider, ale v mnoha případech je hodnota parametru ignorována při zavolání metody. Následující tabulka uvádí některé z metod formátování, které používají parametr a typ objektu Type , který předávají metodě IFormatProvider.GetFormat .

.NET poskytuje tři třídy, které implementují IFormatProvider:

• DateTimeFormatInfo, třída, která poskytuje informace o formátování pro hodnoty data a času pro konkrétní jazykovou verzi. Její IFormatProvider.GetFormat implementace vrátí instanci sebe sama.

• NumberFormatInfo, třída, která poskytuje informace o číselném formátování pro konkrétní jazykovou verzi. Její IFormatProvider.GetFormat implementace vrátí instanci sebe sama.

• CultureInfo. Jeho IFormatProvider.GetFormat implementace může vrátit objekt, NumberFormatInfo který poskytuje informace o číselném formátování, nebo DateTimeFormatInfo objekt, který poskytuje informace o formátování pro hodnoty data a času.

Můžete také implementovat vlastního zprostředkovatele formátu, který nahradí některou z těchto tříd. Metoda vaší implementace GetFormat však musí vrátit objekt typu uvedeného v předchozí tabulce, pokud musí poskytnout informace o formátování metody ToString .

Formátování číselných hodnot citlivých na jazykovou verzi

Ve výchozím nastavení je formátování číselných hodnot citlivé na jazykovou verzi. Pokud při volání metody formátování nezadáte jazykovou verzi, použijí se konvence formátování aktuální jazykové verze. To je znázorněno v následujícím příkladu, který změní aktuální jazykovou verzi čtyřikrát a potom volá metodu Decimal.ToString(String) . V každém případě se ve výsledném řetězci zobrazí konvence formátování aktuální jazykové verze. Důvodem je to, že ToString metody a ToString(String) metody zalamují volání metody každého číselného ToString(String, IFormatProvider) typu.

using System.Globalization;

public class Example6
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
      Decimal value = 1043.17m;

      foreach (var cultureName in cultureNames) {
         // Change the current culture.
         CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}");
         Console.WriteLine(value.ToString("C2"));
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       The current culture is en-US
//       $1,043.17
//
//       The current culture is fr-FR
//       1 043,17 €
//
//       The current culture is es-MX
//       $1,043.17
//
//       The current culture is de-DE
//       1.043,17 €

Imports System.Globalization

Module Example6
    Public Sub Main6()
        Dim cultureNames() As String = {"en-US", "fr-FR", "es-MX", "de-DE"}
        Dim value As Decimal = 1043.17D

        For Each cultureName In cultureNames
            ' Change the current culture.
            CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
            Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}")
            Console.WriteLine(value.ToString("C2"))
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       The current culture is en-US
'       $1,043.17
'       
'       The current culture is fr-FR
'       1 043,17 €
'       
'       The current culture is es-MX
'       $1,043.17
'       
'       The current culture is de-DE
'       1.043,17 €

Číselnou hodnotu pro konkrétní jazykovou verzi můžete také naformátovat voláním ToString přetížení, které má provider parametr, a předáním některé z následujících možností:

• Objekt CultureInfo , který představuje jazykovou verzi, jejíž konvence formátování se mají použít. Jeho CultureInfo.GetFormat metoda vrátí hodnotu CultureInfo.NumberFormat vlastnosti, což je NumberFormatInfo objekt, který poskytuje informace o formátování specifické pro jazykovou verzi pro číselné hodnoty.

• Objekt NumberFormatInfo , který definuje konvence formátování specifické pro jazykovou verzi, které se mají použít. Jeho GetFormat metoda vrátí instanci sebe sama.

Následující příklad používá NumberFormatInfo objekty, které představují jazykové verze angličtiny (USA) a angličtiny (Spojené království) a francouzské a ruské neutrální jazykové verze k formátování čísla s plovoucí desetinou čárkou.

using System.Globalization;

public class Example7
{
    public static void Main()
    {
        double value = 1043.62957;
        string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };

        foreach (string? name in cultureNames)
        {
            NumberFormatInfo nfi = CultureInfo.CreateSpecificCulture(name).NumberFormat;
            Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi));
        }
    }
}
// The example displays the following output:
//       en-US: 1,043.630
//       en-GB: 1,043.630
//       ru:    1 043,630
//       fr:    1 043,630

Imports System.Globalization

Module Example7
    Public Sub Main7()
        Dim value As Double = 1043.62957
        Dim cultureNames() As String = {"en-US", "en-GB", "ru", "fr"}

        For Each name In cultureNames
            Dim nfi As NumberFormatInfo = CultureInfo.CreateSpecificCulture(name).NumberFormat
            Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi))
        Next
    End Sub
End Module
' The example displays the following output:
'       en-US: 1,043.630
'       en-GB: 1,043.630
'       ru:    1 043,630
'       fr:    1 043,630

Formátování hodnot data a času citlivé na jazykovou verzi

Ve výchozím nastavení je formátování hodnot data a času citlivé na jazykovou verzi. Pokud při volání metody formátování nezadáte jazykovou verzi, použijí se konvence formátování aktuální jazykové verze. To je znázorněno v následujícím příkladu, který změní aktuální jazykovou verzi čtyřikrát a potom volá metodu DateTime.ToString(String) . V každém případě se ve výsledném řetězci zobrazí konvence formátování aktuální jazykové verze. Důvodem je to, že DateTime.ToString()volání a metody , DateTime.ToString(String), DateTimeOffset.ToString()a DateTimeOffset.ToString(String) metody zabalit DateTime.ToString(String, IFormatProvider) volání a DateTimeOffset.ToString(String, IFormatProvider) metody.

using System.Globalization;

public class Example4
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
      DateTime dateToFormat = new DateTime(2012, 5, 28, 11, 30, 0);

      foreach (var cultureName in cultureNames) {
         // Change the current culture.
         CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}");
         Console.WriteLine(dateToFormat.ToString("F"));
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       The current culture is en-US
//       Monday, May 28, 2012 11:30:00 AM
//
//       The current culture is fr-FR
//       lundi 28 mai 2012 11:30:00
//
//       The current culture is es-MX
//       lunes, 28 de mayo de 2012 11:30:00 a.m.
//
//       The current culture is de-DE
//       Montag, 28. Mai 2012 11:30:00

Imports System.Globalization
Imports System.Threading

Module Example4
    Public Sub Main4()
        Dim cultureNames() As String = {"en-US", "fr-FR", "es-MX", "de-DE"}
        Dim dateToFormat As Date = #5/28/2012 11:30AM#

        For Each cultureName In cultureNames
            ' Change the current culture.
            CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
            Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}")
            Console.WriteLine(dateToFormat.ToString("F"))
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       The current culture is en-US
'       Monday, May 28, 2012 11:30:00 AM
'       
'       The current culture is fr-FR
'       lundi 28 mai 2012 11:30:00
'       
'       The current culture is es-MX
'       lunes, 28 de mayo de 2012 11:30:00 a.m.
'       
'       The current culture is de-DE
'       Montag, 28. Mai 2012 11:30:00 

Hodnotu data a času pro konkrétní jazykovou verzi můžete také naformátovat voláním DateTime.ToString nebo DateTimeOffset.ToString přetížením, které má provider parametr, a předáním některé z následujících možností:

• Objekt CultureInfo , který představuje jazykovou verzi, jejíž konvence formátování se mají použít. Jeho CultureInfo.GetFormat metoda vrátí hodnotu CultureInfo.DateTimeFormat vlastnosti, což je DateTimeFormatInfo objekt, který poskytuje informace o formátování specifické pro jazykovou verzi pro hodnoty data a času.

• Objekt DateTimeFormatInfo , který definuje konvence formátování specifické pro jazykovou verzi, které se mají použít. Jeho GetFormat metoda vrátí instanci sebe sama.

Následující příklad používá DateTimeFormatInfo objekty, které představují jazykové verze angličtiny (USA) a angličtiny (Spojené království) a francouzské a ruské neutrální jazykové verze k formátování data.

using System.Globalization;

public class Example5
{
   public static void Main()
   {
      DateTime dat1 = new(2012, 5, 28, 11, 30, 0);
      string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };

      foreach (var name in cultureNames) {
         DateTimeFormatInfo dtfi = CultureInfo.CreateSpecificCulture(name).DateTimeFormat;
         Console.WriteLine($"{name}: {dat1.ToString(dtfi)}");
      }
   }
}
// The example displays the following output:
//       en-US: 5/28/2012 11:30:00 AM
//       en-GB: 28/05/2012 11:30:00
//       ru: 28.05.2012 11:30:00
//       fr: 28/05/2012 11:30:00

Imports System.Globalization

Module Example5
    Public Sub Main5()
        Dim dat1 As Date = #5/28/2012 11:30AM#
        Dim cultureNames() As String = {"en-US", "en-GB", "ru", "fr"}

        For Each name In cultureNames
            Dim dtfi As DateTimeFormatInfo = CultureInfo.CreateSpecificCulture(name).DateTimeFormat
            Console.WriteLine($"{name}: {dat1.ToString(dtfi)}")
        Next
    End Sub
End Module
' The example displays the following output:
'       en-US: 5/28/2012 11:30:00 AM
'       en-GB: 28/05/2012 11:30:00
'       ru: 28.05.2012 11:30:00
'       fr: 28/05/2012 11:30:00

Rozhraní IFormattable

Obvykle typy, které přetěžují metodu ToString řetězcem formátu a IFormatProvider parametrem IFormattable také implementují rozhraní. Toto rozhraní má jeden člen , IFormattable.ToString(String, IFormatProvider)který zahrnuje formátovací řetězec i zprostředkovatele formátu jako parametry.

IFormattable Implementace rozhraní pro třídu definovanou aplikací nabízí dvě výhody:

• Podpora převodu řetězců podle Convert třídy. Volání metod Convert.ToString(Object) a Convert.ToString(Object, IFormatProvider) volání vaší IFormattable implementace automaticky.

• Podpora složeného formátování Pokud se k naformátování vlastního typu použije položka formátu obsahující formátovací řetězec, modul CLR (Common Language Runtime) automaticky zavolá vaši IFormattable implementaci a předá jí řetězec formátu. Další informace o složeného formátování pomocí metod, jako String.Format je nebo Console.WriteLine, naleznete v oddílu Složené formátování .

Následující příklad definuje Temperature třídu, která implementuje IFormattable rozhraní. Podporuje specifikátory formátu "C" nebo "G" pro zobrazení teploty ve stupních Celsia, specifikátor formátu "F" pro zobrazení teploty ve formátu Fahrenheita a specifikátor formátu "K" pro zobrazení teploty v Kelvinu.

using System;
using System.Globalization;

namespace HotAndCold
{

    public class Temperature : IFormattable
    {
        private decimal m_Temp;

        public Temperature(decimal temperature)
        {
            this.m_Temp = temperature;
        }

        public decimal Celsius
        {
            get { return this.m_Temp; }
        }

        public decimal Kelvin
        {
            get { return this.m_Temp + 273.15m; }
        }

        public decimal Fahrenheit
        {
            get { return Math.Round((decimal)this.m_Temp * 9 / 5 + 32, 2); }
        }

        public override string ToString()
        {
            return this.ToString("G", null);
        }

        public string ToString(string format)
        {
            return this.ToString(format, null);
        }

        public string ToString(string format, IFormatProvider provider)
        {
            // Handle null or empty arguments.
            if (String.IsNullOrEmpty(format))
                format = "G";
            // Remove any white space and covert to uppercase.
            format = format.Trim().ToUpperInvariant();

            if (provider == null)
                provider = NumberFormatInfo.CurrentInfo;

            switch (format)
            {
                // Convert temperature to Fahrenheit and return string.
                case "F":
                    return this.Fahrenheit.ToString("N2", provider) + "°F";
                // Convert temperature to Kelvin and return string.
                case "K":
                    return this.Kelvin.ToString("N2", provider) + "K";
                // Return temperature in Celsius.
                case "C":
                case "G":
                    return this.Celsius.ToString("N2", provider) + "°C";
                default:
                    throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
            }
        }
    }

Public Class Temperature : Implements IFormattable
    Private m_Temp As Decimal

    Public Sub New(temperature As Decimal)
        Me.m_Temp = temperature
    End Sub

    Public ReadOnly Property Celsius() As Decimal
        Get
            Return Me.m_Temp
        End Get
    End Property

    Public ReadOnly Property Kelvin() As Decimal
        Get
            Return Me.m_Temp + 273.15D
        End Get
    End Property

    Public ReadOnly Property Fahrenheit() As Decimal
        Get
            Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
        End Get
    End Property

    Public Overrides Function ToString() As String
        Return Me.ToString("G", Nothing)
    End Function

    Public Overloads Function ToString(format As String) As String
        Return Me.ToString(format, Nothing)
    End Function

    Public Overloads Function ToString(format As String, provider As IFormatProvider) As String _
       Implements IFormattable.ToString

        ' Handle null or empty arguments.
        If String.IsNullOrEmpty(format) Then format = "G"
        ' Remove any white space and convert to uppercase.
        format = format.Trim().ToUpperInvariant()

        If provider Is Nothing Then provider = NumberFormatInfo.CurrentInfo

        Select Case format
     ' Convert temperature to Fahrenheit and return string.
            Case "F"
                Return Me.Fahrenheit.ToString("N2", provider) & "°F"
     ' Convert temperature to Kelvin and return string.
            Case "K"
                Return Me.Kelvin.ToString("N2", provider) & "K"
     ' Return temperature in Celsius.
            Case "C", "G"
                Return Me.Celsius.ToString("N2", provider) & "°C"
            Case Else
                Throw New FormatException(String.Format($"The '{format}' format string is not supported."))
        End Select
    End Function
End Class

Následující příklad vytvoří instanci objektu Temperature . Potom volá metodu ToString a používá několik složených formátových řetězců k získání různých řetězcových reprezentací objektu Temperature . Každá z těchto volání metod následně volá implementaci IFormattable Temperature třídy.

public class Example11
{
    public static void Main()
    {
        CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
        Temperature temp = new Temperature(22m);
        Console.WriteLine(Convert.ToString(temp, new CultureInfo("ja-JP")));
        Console.WriteLine("Temperature: {0:K}", temp);
        Console.WriteLine("Temperature: {0:F}", temp);
        Console.WriteLine(String.Format(new CultureInfo("fr-FR"), "Temperature: {0:F}", temp));
    }
}
// The example displays the following output:
//       22.00°C
//       Temperature: 295.15K
//       Temperature: 71.60°F
//       Temperature: 71,60°F

Public Module Example12
    Public Sub Main12()
        Dim temp As New Temperature(22D)
        CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US")
        Console.WriteLine(Convert.ToString(temp, New CultureInfo("ja-JP")))
        Console.WriteLine($"Temperature: {temp:K}")
        Console.WriteLine($"Temperature: {temp:F}")
        Console.WriteLine(String.Format(New CultureInfo("fr-FR"), $"Temperature: {temp:F}"))
    End Sub
End Module
' The example displays the following output:
'       22.00°C
'       Temperature: 295.15K
'       Temperature: 71.60°F
'       Temperature: 71,60°F

Složené formátování

Některé metody, například String.Format a StringBuilder.AppendFormat, podporují složené formátování. Složený formátovací řetězec je druh šablony, která vrací jeden řetězec, který zahrnuje řetězcovou reprezentaci nula, jednoho nebo více objektů. Každý objekt je reprezentován v řetězci složeného formátu indexovanou položkou formátu. Index položky formátu odpovídá pozici objektu, který představuje v seznamu parametrů metody. Indexy jsou založené na nule. Například v následujícím volání String.Format metody, první formát položka , {0:D}je nahrazen řetězcovou thatDatereprezentací ; druhé formát položky , {1}je nahrazen řetězcovou reprezentací item1; a třetí formát položka , {2:C2}je nahrazena řetězcovou reprezentací item1.Value.

result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.",
                       thatDate, item1, item1.Value);
Console.WriteLine(result);
// The example displays output like the following if run on a system
// whose current culture is en-US:
//       On 5/1/2009, the inventory of WidgetA was worth $107.44.

result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.",
                       thatDate, item1, item1.Value)
Console.WriteLine(result)
' The example displays output like the following if run on a system
' whose current culture is en-US:
'       On 5/1/2009, the inventory of WidgetA was worth $107.44.

Kromě nahrazení položky formátu řetězcovou reprezentací odpovídajícího objektu umožňují formátovat položky také následující:

• Konkrétní způsob, jakým je objekt reprezentován jako řetězec, pokud objekt implementuje IFormattable rozhraní a podporuje formátovací řetězce. Provedete to podle indexu položky formátu s : (dvojtečku) následovanou platným řetězcem formátu. V předchozím příkladu jsme to udělali tak, {0:d}že naformátujete hodnotu data pomocí řetězce formátu "d" (například krátký vzor data) a naformátujete číselnou hodnotu pomocí řetězce formátu "C2" (například tak, {2:C2} aby představovalo číslo jako hodnotu měny se dvěma desetinnými desetinnými číslicemi).

• Šířka pole, které obsahuje řetězcovou reprezentaci objektu, a zarovnání řetězcové reprezentace v tomto poli. Provedete to podle indexu položky formátu s čárkou následovanou , šířkou pole. Řetězec je v poli zarovnaný doprava, pokud je šířka pole kladnou hodnotou a je zarovnaná doleva, pokud je šířka pole zápornou hodnotou. Následující příklad zarovná hodnoty kalendářních dat do pole s 20 znaky a zarovná desetinné hodnoty doprava s jednou desetinnou číslicí v poli s 11 znaky.

  DateTime startDate = new DateTime(2015, 8, 28, 6, 0, 0);
  decimal[] temps = { 73.452m, 68.98m, 72.6m, 69.24563m,
                     74.1m, 72.156m, 72.228m };
  Console.WriteLine("{0,-20} {1,11}\n", "Date", "Temperature");
  for (int ctr = 0; ctr < temps.Length; ctr++)
     Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps[ctr]);
  
  // The example displays the following output:
  //       Date                 Temperature
  //
  //       8/28/2015 6:00 AM           73.5
  //       8/29/2015 6:00 AM           69.0
  //       8/30/2015 6:00 AM           72.6
  //       8/31/2015 6:00 AM           69.2
  //       9/1/2015 6:00 AM            74.1
  //       9/2/2015 6:00 AM            72.2
  //       9/3/2015 6:00 AM            72.2
  

  Dim startDate As New Date(2015, 8, 28, 6, 0, 0)
  Dim temps() As Decimal = {73.452, 68.98, 72.6, 69.24563,
                             74.1, 72.156, 72.228}
  Console.WriteLine("{0,-20} {1,11}", "Date", "Temperature")
  Console.WriteLine()
  For ctr As Integer = 0 To temps.Length - 1
      Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps(ctr))
  Next
  ' The example displays the following output:
  '       Date                 Temperature
  '
  '       8/28/2015 6:00 AM           73.5
  '       8/29/2015 6:00 AM           69.0
  '       8/30/2015 6:00 AM           72.6
  '       8/31/2015 6:00 AM           69.2
  '       9/1/2015 6:00 AM            74.1
  '       9/2/2015 6:00 AM            72.2
  '       9/3/2015 6:00 AM            72.2
  

  Všimněte si, že pokud je přítomna komponenta řetězce zarovnání i komponenta řetězce formátu, předchází předchozí část (například {0,-20:g}.

Další informace o složeného formátování naleznete v tématu Složené formátování.

Vlastní formátování pomocí ICustomFormatter

Dvě metody String.Format(IFormatProvider, String, Object[]) složeného formátování a StringBuilder.AppendFormat(IFormatProvider, String, Object[])zahrnují parametr zprostředkovatele formátu, který podporuje vlastní formátování. Pokud je volána některé z těchto metod formátování, předá Type objekt, který představuje ICustomFormatter rozhraní metody zprostředkovatele GetFormat formátu. Metoda GetFormat je pak zodpovědná za vrácení ICustomFormatter implementace, která poskytuje vlastní formátování.

Rozhraní ICustomFormatter má jednu metodu, Format(String, Object, IFormatProvider)která je volána automaticky složenou formátovací metodou, jednou pro každou položku formátu ve složené formátovací řetězec. Metoda Format(String, Object, IFormatProvider) má tři parametry: formátovací řetězec, který představuje formatString argument v položce formátu, objekt pro formátování a IFormatProvider objekt, který poskytuje služby formátování. Obvykle třída, která implementuje také implementuje ICustomFormatter IFormatProvider, takže tento poslední parametr je odkaz na vlastní formát třídy samotné. Metoda vrátí vlastní formátovanou řetězcovou reprezentaci objektu, který má být formátován. Pokud metoda nemůže naformátovat objekt, měla by vrátit odkaz null (Nothing v jazyce Visual Basic).

Následující příklad poskytuje ICustomFormatter implementaci s názvem ByteByByteFormatter , která zobrazuje celočíselné hodnoty jako posloupnost dvouciferných šestnáctkových hodnot následovaných mezerou.

public class ByteByByteFormatter : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }

   public string Format(string format, object arg,
                          IFormatProvider formatProvider)
   {
      if (! formatProvider.Equals(this)) return null;

      // Handle only hexadecimal format string.
      if (! format.StartsWith("X")) return null;

      byte[] bytes;
      string output = null;

      // Handle only integral types.
      if (arg is Byte)
         bytes = BitConverter.GetBytes((Byte) arg);
      else if (arg is Int16)
         bytes = BitConverter.GetBytes((Int16) arg);
      else if (arg is Int32)
         bytes = BitConverter.GetBytes((Int32) arg);
      else if (arg is Int64)
         bytes = BitConverter.GetBytes((Int64) arg);
      else if (arg is SByte)
         bytes = BitConverter.GetBytes((SByte) arg);
      else if (arg is UInt16)
         bytes = BitConverter.GetBytes((UInt16) arg);
      else if (arg is UInt32)
         bytes = BitConverter.GetBytes((UInt32) arg);
      else if (arg is UInt64)
         bytes = BitConverter.GetBytes((UInt64) arg);
      else
         return null;

      for (int ctr = bytes.Length - 1; ctr >= 0; ctr--)
         output += String.Format("{0:X2} ", bytes[ctr]);

      return output.Trim();
   }
}

Public Class ByteByByteFormatter : Implements IFormatProvider, ICustomFormatter
    Public Function GetFormat(formatType As Type) As Object _
                    Implements IFormatProvider.GetFormat
        If formatType Is GetType(ICustomFormatter) Then
            Return Me
        Else
            Return Nothing
        End If
    End Function

    Public Function Format(fmt As String, arg As Object,
                           formatProvider As IFormatProvider) As String _
                           Implements ICustomFormatter.Format

        If Not formatProvider.Equals(Me) Then Return Nothing

        ' Handle only hexadecimal format string.
        If Not fmt.StartsWith("X") Then
            Return Nothing
        End If

        ' Handle only integral types.
        If Not typeof arg Is Byte AndAlso
           Not typeof arg Is Int16 AndAlso
           Not typeof arg Is Int32 AndAlso
           Not typeof arg Is Int64 AndAlso
           Not typeof arg Is SByte AndAlso
           Not typeof arg Is UInt16 AndAlso
           Not typeof arg Is UInt32 AndAlso
           Not typeof arg Is UInt64 Then _
              Return Nothing

        Dim bytes() As Byte = BitConverter.GetBytes(arg)
        Dim output As String = Nothing

        For ctr As Integer = bytes.Length - 1 To 0 Step -1
            output += String.Format("{0:X2} ", bytes(ctr))
        Next

        Return output.Trim()
    End Function
End Class

Následující příklad používá ByteByByteFormatter třídu k formátování celočíselné hodnoty. Všimněte si, že ICustomFormatter.Format metoda je volána více než jednou ve druhém String.Format(IFormatProvider, String, Object[]) volání metody a že výchozí NumberFormatInfo zprostředkovatel je používán ve třetím volání metody, protože .ByteByByteFormatter.Format metoda nerozpozná řetězec formátu "N0" a vrátí odkaz null (Nothing v jazyce Visual Basic).

public class Example10
{
   public static void Main()
   {
      long value = 3210662321;
      byte value1 = 214;
      byte value2 = 19;

      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X}", value));
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})",
                                      value1, value2, value1 & value2));
      Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0,10:N0}", value));
   }
}
// The example displays the following output:
//       00 00 00 00 BF 5E D1 B1
//       00 D6 And 00 13 = 00 12 (018)
//       3,210,662,321

Public Module Example10
    Public Sub Main10()
        Dim value As Long = 3210662321
        Dim value1 As Byte = 214
        Dim value2 As Byte = 19

        Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X}", value)))
        Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})",
                                        value1, value2, value1 And value2)))
        Console.WriteLine(String.Format(New ByteByByteFormatter(), "{0,10:N0}", value))
    End Sub
End Module
' The example displays the following output:
'       00 00 00 00 BF 5E D1 B1
'       00 D6 And 00 13 = 00 12 (018)
'       3,210,662,321

Viz také

Reference

• System.IFormattable
• System.IFormatProvider
• System.ICustomFormatter