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 hodnoty výčtu na řetězcovou reprezentaci. Účelem je zobrazit výsledný řetězec uživatelům nebo jej později deserializovat a obnovit původní datový typ. Tento článek představuje mechanismy formátování, které poskytuje rozhraní .NET.

Poznámka

Analýza je inverzní funkce formátování. Operace analýzy vytvoří instanci datového typu z řetězcové reprezentace. Další informace najdete 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í metody ToString dále v tomto tématu. Rozhraní .NET však nabízí několik způsobů, jak upravit a rozšířit výchozí podporu formátování. Mezi ně patří:

• Object.ToString Přepsáním metody definujete vlastní řetězcovou reprezentaci hodnoty objektu. Další informace naleznete v části Přepsání metody ToString dále v tomto tématu.

• Definování specifikátorů formátu, které umožňují řetězcové vyjádření hodnoty objektu na více podob. 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 Metoda ToString a Formát řetězců .

• Použití zprostředkovatelů formátu k implementaci konvencí formátování konkrétní jazykové verze. Například následující příkaz 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 Zprostředkovatelé formátu .

• IFormattable Implementace rozhraní pro podporu převodu Convert řetězců s třídou i složeným formátováním. Další informace najdete 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í .

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

• Implementace ICustomFormatter a IFormatProvider k 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 zkoumají tyto metody pro převod objektu na jeho řetězcovou reprezentaci.

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

Každý typ odvozený od System.Object automaticky dědí metodu bez ToString parametrů, která ve výchozím nastavení vrací název typu. Následující příklad ukazuje výchozí ToString metodu. Definuje třídu s názvem Automobile , která nemá žádnou implementaci. Když je vytvořena instance třídy a je volána její ToString metoda, zobrazí se název jejího typu. Všimněte si ToString , že metoda není v příkladu explicitně volána. Metoda Console.WriteLine(Object) implicitně volá metodu ToString objektu, který je jí předán 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

Upozornění

Počínaje Windows 8.1 prostředí Windows Runtime obsahuje IStringable rozhraní s jedinou metodou, IStringable.ToString, která poskytuje výchozí podporu formátování. Doporučujeme ale, aby spravované typy rozhraní neimplementovaly IStringable . Další informace najdete v části "The prostředí Windows Runtime and the IStringable Interface" (Prostředí Windows Runtime a rozhraní) na stránce s referenčními Object.ToString informacemi.

Vzhledem k tomu, že všechny typy kromě rozhraní jsou odvozeny z Object, je tato funkce automaticky poskytována vašim vlastním třídám nebo strukturám. Funkce nabízené výchozí ToString metodou jsou však omezené: I když identifikuje typ, neposkytne žádné informace o instanci tohoto typu. Chcete-li poskytnout řetězcovou reprezentaci objektu, který poskytuje informace o tomto objektu, je nutné přepsat metodu ToString .

Poznámka

Struktury dědí z ValueTypeobjektu , který je zase odvozen z Object. I když ValueType přepisuje Object.ToString, jeho implementace je identická.

Přepsání metody ToString

Zobrazení názvu typu je často omezené a neumožňuje příjemcům vašich typů rozlišovat jednu instanci od druhé. Můžete však přepsat metodu ToString a poskytnout užitečnější reprezentaci hodnoty objektu. Následující příklad definuje Temperature objekt a přepíše jeho ToString metodu pro 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 jeho 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í ToString metody a předává jí specifikátor formátu "G", který definuje obecný formát pro svůj typ a objekt, který představuje aktuální jazykovou IFormatProvider verzi.

Typ	Přepsání toString
Boolean	Vrátí nebo Boolean.TrueStringBoolean.FalseString.
Byte	Volá Byte.ToString("G", NumberFormatInfo.CurrentInfo) k formátování Byte hodnoty pro aktuální jazykovou verzi.
Char	Vrátí znak jako řetězec.
DateTime	Voláním DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) metody naformátuje hodnotu data a času pro aktuální jazykovou verzi.
Decimal	Volá Decimal.ToString("G", NumberFormatInfo.CurrentInfo) k formátování Decimal hodnoty pro aktuální jazykovou verzi.
Double	Volá Double.ToString("G", NumberFormatInfo.CurrentInfo) k formátování Double hodnoty pro aktuální jazykovou verzi.
Int16	Volá Int16.ToString("G", NumberFormatInfo.CurrentInfo) k formátování Int16 hodnoty pro aktuální jazykovou verzi.
Int32	Volá Int32.ToString("G", NumberFormatInfo.CurrentInfo) k formátování Int32 hodnoty pro aktuální jazykovou verzi.
Int64	Volá Int64.ToString("G", NumberFormatInfo.CurrentInfo) k formátování Int64 hodnoty pro aktuální jazykovou verzi.
SByte	Volá SByte.ToString("G", NumberFormatInfo.CurrentInfo) k formátování SByte hodnoty pro aktuální jazykovou verzi.
Single	Volá Single.ToString("G", NumberFormatInfo.CurrentInfo) k formátování Single hodnoty pro aktuální jazykovou verzi.
UInt16	Volá UInt16.ToString("G", NumberFormatInfo.CurrentInfo) k formátování UInt16 hodnoty pro aktuální jazykovou verzi.
UInt32	Volá UInt32.ToString("G", NumberFormatInfo.CurrentInfo) k formátování UInt32 hodnoty pro aktuální jazykovou verzi.
UInt64	Volá UInt64.ToString("G", NumberFormatInfo.CurrentInfo) k formátování UInt64 hodnoty pro aktuální jazykovou verzi.

Metoda ToString a formátování řetězců

Spoléhání na výchozí ToString metodu nebo přepsání ToString je vhodné, pokud má objekt reprezentaci s jedním řetězcem. 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 kelvinech. Podobně může být celočíselná hodnota 10 reprezentována mnoha způsoby, včetně 10, 10,0, 1,0e01 nebo 10,00 Kč.

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čí, jak by měla vypadat řetězcová reprezentace hodnoty tohoto objektu.

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

Řetězce standardního formátu

Řetězec standardního formátu obsahuje jeden specifikátor formátu, což je abecední znak, který definuje řetězcovou reprezentaci objektu, na který je použit, spolu s volitelným specifikátorem přesnosti, který má vliv na 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ýčtu. Každá z těchto kategorií například podporuje specifikátor standardního formátu "G", který definuje obecné řetězcové vyjádření 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ě hodnoty ToString výčtu určují, jestli se hodnota zobrazí pomocí názvu řetězce (specifikátorů formátu "G" a "F"), její základní celočíselné hodnoty (specifikátor formátu "D") nebo její šestnáctkové hodnoty (specifikátor formátu "X"). Následující příklad ukazuje použití standardní formátovací řetězce 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 výčtových formátových řetězcích najdete v tématu Řetězce formátu 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í. Například specifikátor formátu "C" formátuje číslo jako hodnotu měny. Při volání ToString metody se specifikátorem formátu "C" jako jediným parametrem se k definování řetězcové reprezentace číselné hodnoty použijí následující hodnoty vlastností z objektu aktuální jazykové NumberFormatInfo verze:

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

• Vlastnost CurrencyNegativePattern nebo CurrencyPositivePattern , která vrací celé číslo, které určuje následující:

  • Umístění symbolu měny

  • Určuje, zda jsou záporné hodnoty označeny počátečním záporným znaménkem, koncovým záporným znaménkem nebo závorkou.

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

• Vlastnost CurrencyDecimalDigits , která definuje počet desetinných míst 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ě nalevo od desetinné čárky.

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

Kromě toho mohou řetězce číselného formátu obsahovat specifikátor přesnosti. Význam tohoto specifikátoru závisí na formátovacím řetězci, se kterým se používá, ale obvykle označuje buď celkový počet číslic, nebo počet desetinných míst, které by se měly objevit 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 formátovacích řetězcích čísel najdete v tématu Řetězce standardního čí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í vlastního řetězce formátu uloženého ve vlastnosti aktuální jazykové verze DateTimeFormatInfo.LongDatePattern . (Další informace o vlastních formátovacích řetězcích 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 najdete v tématu Standardní řetězce formátu data a času.

Můžete také použít standardní formátovací řetězce k definování řetězcové reprezentace objektu definovaného aplikací, který je vytvořen metodou objektu ToString(String) . Můžete definovat konkrétní standardní specifikátory formátu, které váš objekt podporuje, a můžete určit, zda rozlišují malá a velká písmena nebo nerozlišují malá a velká písmena. ToString(String) Implementace 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 přetížení ToString(String) a předat mu řetězec standardního formátu "G".

• Podpora specifikátoru formátu, který se rovná odkazu s hodnotou null (Nothing v jazyce Visual Basic). Specifikátor formátu, který se rovná nulovému odkazu, by měl být považován za ekvivalentní specifikátoru formátu "G".

Třída může například Temperature interně ukládat teplotu ve stupních Celsia a pomocí specifikátorů formátu znázornit hodnotu objektu Temperature ve stupních Celsia, stupních Fahrenheita a kelvinech. 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í řetězce formátování

Kromě řetězců standardního formátu definuje rozhraní .NET vlastní formátovací řetězce pro číselné hodnoty a 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ězcové vyjádření hodnoty. Například vlastní řetězec formátu data a času "yyyy/mm/dd hh:mm:ss.ffff t zzz" převede datum na řetězcovou reprezentaci ve formátu "2008/11/15 07:45:0000 P -08:00" 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ématech 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, specifikátoru formátu by měl předcházet symbol procenta (%), aby se zabránilo záměně 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 dvouciferného čísla měsíce určité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átovaných řetězců pro hodnoty data a času je aliasy pro vlastní formátovací řetězce, které jsou definovány vlastnostmi objektu DateTimeFormatInfo . Vlastní formátovací řetězce také nabízejí značnou flexibilitu při poskytování formátování definovaného aplikací pro číselné hodnoty nebo hodnoty data a času. Můžete definovat vlastní výsledné řetězce pro číselné hodnoty i hodnoty data a času tak, že zkombinujete více specifikátorů vlastního formátu do jednoho vlastního řetězce 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í sedmimístné americké telefonní číslo 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

Ačkoli standardní formátovací řetězce mohou obecně zvládnout většinu požadavků na formátování pro typy definované aplikací, můžete také definovat vlastní specifikátory formátu pro formátování vašich typů.

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

Všechny číselné typy (to znamená , , , , DoubleInt64SByteInt16Int32, Single, , UInt16, UInt64UInt32, a) a BigInteger typy výčtu DateTime, GuidDateTimeOffsetTimeSpana všechny typy výčtu podporují formátování pomocí formátových řetězců. DecimalByte Informace o konkrétních formátových řetězcích podporovaných jednotlivými typy najdete v následujících tématech:

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.
Standardní řetězce formátu data a času	Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace DateTime a DateTimeOffset hodnot.
Vlastní řetězce formátu data a času	Popisuje vlastní formátovací řetězce, které vytvářejí formáty specifické pro aplikaci pro DateTime hodnoty 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.
Výčet řetězců formátu	Popisuje standardní formátovací řetězce, které se používají k vytvoření řetězcové reprezentace výčtu hodnot.
Guid.ToString(String)	Popisuje standardní formátovací řetězce pro Guid hodnoty.

Formátování závislé na jazykové verzi se zprostředkovateli formátů

Přestože specifikátory formátu umožňují přizpůsobit formátování objektů, vytváření smysluplného řetězcového vyjádření objektů často vyžaduje další informace o formátování. Například formátování čísla jako hodnoty měny pomocí řetězce standardního formátu "C" nebo vlastního řetězce formátu, 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, aby byly k dispozici pro zahrnutí do formátovaného řetězce. V .NET jsou tyto další informace o formátování k dispozici prostřednictvím IFormatProvider rozhraní, které je poskytováno jako parametr pro jedno 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 změní řetězcová reprezentace objektu, když je formátován pomocí tří IFormatProvider objektů, 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í ho. V opačném případě vrátí odkaz s hodnotou null (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á metodu GetFormat tohoto IFormatProvider objektu. Metoda GetFormat je zodpovědná za vrácení objektu, který poskytuje potřebné informace o formátování, jak je uvedeno v parametru formatTypeToString metody.

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

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íženy a pouze některá přetížení obsahují IFormatProvider parametr. Pokud metoda nemá parametr typu IFormatProvider, předá se místo toho objekt vrácený CultureInfo.CurrentCulture vlastností . Například volání výchozí Int32.ToString() metody nakonec vede k volání metody, jako je například následující: 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í hodnot data a času pro konkrétní jazykovou verzi. Jeho 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. Jeho IFormatProvider.GetFormat implementace vrátí instanci sebe sama.

• CultureInfo. Jeho IFormatProvider.GetFormat implementace může vrátit buď objekt, který NumberFormatInfo poskytuje informace o číselném DateTimeFormatInfo formátování, nebo objekt poskytující 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 implementace GetFormat však musí vrátit objekt typu uvedeného v předchozí tabulce, pokud musí metodě poskytnout informace o ToString formátování.

Formátování číselných hodnot závislé na jazykové verzi

Ve výchozím nastavení je formátování číselných hodnot závislé na jazykové 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ý čtyřikrát změní aktuální jazykovou verzi a pak zavolá metodu Decimal.ToString(String) . Ve všech případech výsledný řetězec odráží konvence formátování aktuální jazykové verze. Důvodem je to, že ToString metody a ToString(String) 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 zavoláním ToString přetížení s parametrem provider 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í mají být použity. 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é mají být použity. Jeho GetFormat metoda vrátí instanci sebe sama.

Následující příklad používá NumberFormatInfo objekty, které představují anglické (USA) a anglické jazykové verze (Spojené království) a francouzské a ruské neutrální jazykové verze k formátování čísla s plovoucí desetinnou čá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 závislé na jazykové verzi

Ve výchozím nastavení je formátování hodnot data a času závislé na jazykové 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ý čtyřikrát změní aktuální jazykovou verzi a pak zavolá metodu DateTime.ToString(String) . V každém případě výsledný řetězec odráží konvence formátování aktuální jazykové verze. Je to proto, že DateTime.ToString()metody , DateTime.ToString(String), DateTimeOffset.ToString()a DateTimeOffset.ToString(String) zabalí 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 voláním DateTime.ToStringDateTimeOffset.ToString nebo přetížením, které má provider parametr, a předáním jedné z následujících možností:

• Objekt CultureInfo , který představuje jazykovou verzi, jejíž konvence formátování mají být použity. 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čtina (USA) a angličtina (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 parametrem IFormatProvider , také implementují IFormattable rozhraní. Toto rozhraní má jeden člen , IFormattable.ToString(String, IFormatProvider)který jako parametry zahrnuje formátovací řetězec i zprostředkovatele formátu.

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

• Podpora pro převod řetězců podle Convert třídy. Convert.ToString(Object) Volání metod a Convert.ToString(Object, IFormatProvider) volají vaši implementaci IFormattable automaticky.

• Podpora složeného formátování. Pokud se k formátování vašeho vlastního typu použije položka formátu, která obsahuje formátovací řetězec, modul CLR (Common Language Runtime) automaticky zavolá vaši implementaci IFormattable 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, najdete v části 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 v 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 . Pak volá metodu ToString a používá několik řetězců složeného formátu k získání různých řetězcových reprezentací objektu Temperature . Každá z těchto metod volá naopak 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: {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í. Řetězec složeného formátu je druh šablony, která vrací jeden řetězec, který zahrnuje řetězcovou reprezentaci nula, jednoho nebo více objektů. Každý objekt je v řetězci složeného formátu reprezentován položkou indexovaného 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 je první položka {0:D}formátu , nahrazena řetězcovou reprezentací thatDate. Druhá položka formátu, {1}, se nahradí řetězcovou reprezentací item1metody a třetí položka formátu , {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í položky formátování také řídit 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 řetězcem : (dvojtečka) následovaným platným formátovacím řetězcem. Předchozí příklad to udělal tak, {0:d}{2:C2} že naformátoval hodnotu data pomocí řetězce formátu "d" (krátký vzor kalendářního data) (např. ) a naformátoval číselnou hodnotu pomocí řetězce formátu "C2" (např. aby číslo představovalo hodnotu měny se dvěma desetinnými desetinnými desetinnými číslicemi).

• Šířka pole, které obsahuje řetězcovou reprezentaci objektu, a zarovnání řetězcové reprezentace v daném poli. Provedete to tak, že se za indexem , položky formátu zobrazí čárka za šířkou pole. Řetězec je v poli zarovnaný doprava, pokud je šířka pole kladná hodnota, a je zarovnán doleva, pokud je šířka pole záporná hodnota. Následující příklad zarovná hodnoty kalendářních dat do 20místného pole a zarovná desetinné hodnoty doprava s jednou desetinnou číslicí v 11znakovém poli.

  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 k dispozici komponenta řetězce zarovnání i komponenta formátovací řetězec, předchází první komponenta druhé (například {0,-20:g}.

Další informace o složeného formátování najdete 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[])obsahují parametr zprostředkovatele formátu, který podporuje vlastní formátování. Když je volána kterákoliv z těchto metod formátování, předá Type objekt, který představuje ICustomFormatter rozhraní do 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 metodou složeného formátování, 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 k formátování a IFormatProvider objekt, který poskytuje služby formátování. Třída, která implementuje ICustomFormatter , obvykle také implementuje IFormatProvider, takže tento poslední parametr je odkazem na vlastní třídu formátování samotné. Metoda vrátí vlastní formátovanou řetězcovou reprezentaci objektu, který se má formátovat. Pokud metoda nemůže formá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 dvoumístný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ých hodnot. Všimněte si ICustomFormatter.Format , že 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 se používá 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é

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.
Standardní řetězce formátu data a času	Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace DateTime hodnot.
Vlastní řetězce 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átu výčtu	Popisuje standardní formátovací řetězce, které se používají 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 může být následně zobrazen na konzole nebo zapsán do datového proudu.
Analýza řetězců	Popisuje, jak inicializovat objekty na hodnoty popsané řetězcové reprezentace těchto objektů. Analýza je inverzní operace formátování.

Reference

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