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.

Poznámka:

Analýza je inverzní k formátování. Operace analýzy vytvoří instanci datového typu z řetězcové reprezentace. Další informace naleznete v tématu Analýza řetězců. Informace o serializaci a deserializaci naleznete v tématu Serializace v .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 článku. .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í:

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

• Definování specifikátorů formátu, které umožňují řetězcovou reprezentaci hodnoty objektu v několika různých formách. 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í kultury. 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í poskytovatelů formátu najdete v části Poskytovatelé formátu.

• Implementace rozhraní pro podporu převodu řetězců pomocí třídy IFormattable a složeného formátování. Další informace naleznete v 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 možné čitelnějším způsobem vložit řetězcovou reprezentaci hodnoty do většího řetězce. Další informace naleznete v tématu Interpolace řetězců.

• Implementace ICustomFormatter a IFormatProvider pro poskytnutí kompletního řešení vlastního 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ý od System.Object automaticky 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, je-li volána její metoda ToString, zobrazí název jejího typu. Metoda ToString 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

Varování

Počínaje Windows 8.1 obsahuje prostředí Windows Runtime rozhraní s jednou metodou IStringable, která poskytuje výchozí formátovací podporu. Doporučujeme ale, aby spravované typy neimplementovaly IStringable rozhraní. Další informace naleznete v tématu Windows Runtime a rozhraní IStringable.

Jelikož všechny typy kromě rozhraní jsou odvozeny od 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 .

Poznámka:

Struktury dědí z ValueType, které samy jsou odvozeny z Object. Ačkoli ValueType přepisuje Object.ToString, jeho implementace je identická.

Přepište metodu ToString

Zobrazení názvu typu je často omezené a neumožňuje uživatelům typů rozlišovat jednu instanci od jiného. 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, aby ToString zobrazovala hodnotu objektu místo názvu objektu. Následující tabulka ukazuje předdefinování pro každý primitivní typ. Většina přepsaných metod volá jiné přetížení metody ToString a předává mu specifikátor formátu "G", který definuje obecný formát pro daný datový typ, a objekt IFormatProvider, který představuje aktuální jazykovou verzi.

Typ	Přepsání metody ToString
Boolean	Vrátí buď Boolean.TrueString nebo Boolean.FalseString.
Byte	Formátování hodnoty Byte.ToString("G", NumberFormatInfo.CurrentInfo) voláním Byte pro aktuální kulturní nastavení.
Char	Vrátí znak jako řetězec.
DateTime	Zavolá DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) pro formátování hodnoty data a času pro aktuální jazykovou verzi.
Decimal	Formátování hodnoty Decimal.ToString("G", NumberFormatInfo.CurrentInfo) voláním Decimal pro aktuální kulturní nastavení.
Double	Formátování hodnoty Double.ToString("G", NumberFormatInfo.CurrentInfo) voláním Double pro aktuální kulturní nastavení.
Int16	Formátování hodnoty Int16.ToString("G", NumberFormatInfo.CurrentInfo) voláním Int16 pro aktuální kulturní nastavení.
Int32	Formátování hodnoty Int32.ToString("G", NumberFormatInfo.CurrentInfo) voláním Int32 pro aktuální kulturní nastavení.
Int64	Formátování hodnoty Int64.ToString("G", NumberFormatInfo.CurrentInfo) voláním Int64 pro aktuální kulturní nastavení.
SByte	Formátování hodnoty SByte.ToString("G", NumberFormatInfo.CurrentInfo) voláním SByte pro aktuální kulturní nastavení.
Single	Formátování hodnoty Single.ToString("G", NumberFormatInfo.CurrentInfo) voláním Single pro aktuální kulturní nastavení.
UInt16	Formátování hodnoty UInt16.ToString("G", NumberFormatInfo.CurrentInfo) voláním UInt16 pro aktuální kulturní nastavení.
UInt32	Formátování hodnoty UInt32.ToString("G", NumberFormatInfo.CurrentInfo) voláním UInt32 pro aktuální kulturní nastavení.
UInt64	Formátování hodnoty UInt64.ToString("G", NumberFormatInfo.CurrentInfo) voláním UInt64 pro aktuální kulturní nastavení.

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žije, 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í podporovaný, je specifikátor standardního formátu ekvivalentní standardnímu řetězci 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

Pro více informací o formátovacích řetězcích výčtu vizte Formátovací řetězce výčtu.

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í metody ToString s formátovacím specifikátorem "C" jako jediným parametrem se pro definování řetězcové reprezentace číselné hodnoty použijí následující hodnoty vlastností z objektu aktuální kulturní verze NumberFormatInfo.

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

• Vlastnost CurrencyNegativePattern nebo CurrencyPositivePattern, která vrátí celé číslo určující 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 se závorky nepoužívají 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, které jsou uloženy vlastností DateTimeFormatInfo. Například volání metody ToString pro hodnotu data a času se specifikátorem formátu "D" zobrazí datum a čas s použitím ř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:     {date1:D}");
      string longPattern = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern;
      Console.WriteLine($"'{longPattern}' custom format string:     {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é váš objekt podporuje, a můžete určit, zda rozlišují malá a velká písmena, nebo ne. 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í metody ToString vašeho objektu bez parametrů by mělo volat přetížení ToString(String) a předat mu standardní formátovací řetězec "G".

• 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:00" pro kulturu 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

I když řetězce standardního formátu 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 článcích:

Nadpis	Definice
Standardní řetězce pro formátování čísel	Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace číselných hodnot.
Vlastní řetězce číselného formátu	Popisuje vlastní formátovací řetězce, které vytvářejí formáty specifické pro aplikaci pro číselné hodnoty.
Řetězce standardního formátu data a času	Popisuje standardní formátovací řetězce, které vytvářejí běžně používaná řetězcová zobrazení hodnot DateTime a DateTimeOffset.
Řetězce vlastního formátu data a času	Popisuje řetězce vlastního formátu, které vytvářejí formáty specifické pro aplikaci pro hodnoty DateTime a DateTimeOffset.
Standardní řetězce formátu TimeSpan	Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace časových intervalů.
Vlastní řetězce formátu TimeSpan	Popisuje vlastní formátovací řetězce, které vytvářejí formáty specifické pro aplikaci pro časové intervaly.
Řetězce formátování výčtů	Popisuje standardní formátovací řetězce, které slouží k vytvoření řetězcové reprezentace hodnot výčtu.
Guid.ToString(String)	Popisuje standardní formátovací řetězce pro Guid hodnoty.

Kulturně citlivé formátování 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 dodatečné informace o formátování dostupné prostřednictvím rozhraní IFormatProvider, které se poskytuje jako parametr pro jednu nebo více verzí přetížení metody ToString číselných typů a typů data a času. IFormatProvider implementace se v .NET používají k podpoře formátování specifického pro konkrétní jazykové verze. 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í přetížené metody ToString, která obsahuje parametr IFormatProvider, se volá metoda GetFormat toho objektu IFormatProvider. 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 .

Několik formátovací nebo řetězcové metody převodu zahrnují 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 .

metoda	Typ parametru formatType
ToString metoda číselných typů	System.Globalization.NumberFormatInfo
ToString metoda typů data a času	System.Globalization.DateTimeFormatInfo
String.Format	System.ICustomFormatter
StringBuilder.AppendFormat	System.ICustomFormatter

Poznámka:

Metody ToString číselných typů a typů data a času jsou přetížené a pouze některé z přetížení zahrnují IFormatProvider parametr. Pokud metoda nemá parametr typu IFormatProvider, objekt vrácený CultureInfo.CurrentCulture vlastností se místo toho předá. Například volání výchozí Int32.ToString() metody nakonec vede k volání metody, například: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture).

.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í kulturu. 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 s ohledem na kulturní rozdíly

Ve výchozím nastavení je formátování číselných hodnot citlivé na kulturu. Pokud při volání metody formátování nezadáte kulturu, použijí se konvence formátování aktuální kultury. To je znázorněno v následujícím příkladu, který změní aktuální kulturu. Tato změna proběhne čtyřikrát a potom volá metodu Decimal.ToString(String). V každém případě se ve výsledném řetězci zobrazí formátovací pravidla aktuální kultury. 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í kulturu můžete také naformátovat voláním ToString přetížení, které má parametr provider, a předáním některé z následujících možností:

• Objekt CultureInfo, který představuje kulturu, 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 formátování specifické pro danou kulturní oblast pro číselné hodnoty.

• Objekt NumberFormatInfo, který definuje konvence formátování specifické pro danou kulturu, 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í kultury angličtiny (USA) a angličtiny (Spojené království) a francouzské a ruské neutrální kultury pro formátování desetinného čísla.

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 kulturu

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

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 zavoláním přetížení DateTime.ToString nebo DateTimeOffset.ToString s parametrem provider a předáním jedné z následujících hodnot:

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

• Objekt DateTimeFormatInfo, který definuje konvence formátování specifické pro danou kulturu, 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 pomocí formátovacího řetězce a parametru IFormatProvider, také implementují rozhraní IFormattable. 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ém formátování pomocí metod, jako jsou String.Format 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 IFormattableTemperature 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: {temp:K}");
        Console.WriteLine($"Temperature: {temp:F}");
        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í metody String.Format, první formátová položka {0:D} je nahrazena řetězcovou reprezentací thatDate; druhá formátová položka {1} je nahrazena řetězcovou reprezentací item1; a třetí formátová 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 vám formátové položky také umožňují ovládat 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. Toho dosáhnete následováním indexu položky formátu pomocí : dvojtečky, po níž následuje platný formátovací řetězec. Předchozí příklad to udělal formátováním hodnoty data pomocí řetězce formátu "d" (krátký vzor data) (například {0:d}) a formátováním číselné hodnoty pomocí řetězce formátu "C2" (například {2:C2}) představující čí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, následovanou čárkou , a šíř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ává hodnoty dat doleva v poli s 20 znaky a zarovnává desetinné hodnoty s jednou desetinnou číslicí doprava 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
  

  Pokud je přítomna komponenta zarovnávacího řetězce i komponenta formátovacího řetězce, první z nich předchází druhé (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 jedna z těchto metod formátování, předá objekt Type, který představuje rozhraní ICustomFormatter metodě zprostředkovatele formátu GetFormat. 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 v složeném formátovacím řetězci. 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 ICustomFormatter, také implementuje IFormatProvider, takže tento poslední parametr je odkaz na vlastní formátovací třídu samotnou. 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 nulový odkaz (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 is not null) && !formatProvider.Equals(this)) return "";

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

        byte[] bytes;

        // Handle only integral types.
        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 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 "";

        string output= "";
        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. Metoda ICustomFormatter.Format je volána vícekrát při druhém volání metody String.Format(IFormatProvider, String, Object[]), a ve třetím volání se používá výchozí zprostředkovatel NumberFormatInfo, protože... (complete the sentence based on additional content not provided here). 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é

Nadpis	Definice
Standardní řetězce pro formátování čísel	Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace číselných hodnot.
Vlastní řetězce číselného formátu	Popisuje vlastní formátovací řetězce, které vytvářejí formáty specifické pro aplikaci pro číselné hodnoty.
Řetězce standardního formátu data a času	Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové DateTime reprezentace hodnot.
Řetězce vlastního formátu data a času	Popisuje vlastní formátovací řetězce, které vytvářejí formáty specifické pro aplikaci pro DateTime hodnoty.
Standardní řetězce formátu TimeSpan	Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace časových intervalů.
Vlastní řetězce formátu TimeSpan	Popisuje vlastní formátovací řetězce, které vytvářejí formáty specifické pro aplikaci pro časové intervaly.
Řetězce formátování výčtů	Popisuje standardní formátovací řetězce, které slouží k vytvoření řetězcové reprezentace hodnot výčtu.
Složené formátování	Popisuje, jak vložit jednu nebo více formátovaných hodnot do řetězce. Řetězec lze následně zobrazit v konzole nebo zapsat do datového proudu.
Analýza řetězců	Popisuje, jak inicializovat objekty na hodnoty popsané řetězcovou reprezentací těchto objektů. Analýza je inverzní operace formátování.

Odkazy

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