Typy formátů v .NET

Formátování je proces převodu instance třídy, struktury nebo výčtové hodnoty na její řetězcové vyjádření, často tak aby výsledný řetězec mohl být zobrazen uživatelům nebo deserializovat, aby obnovil původní datový typ. Tento převod může představovat množství problémů:

  • Způsob, jakým se hodnoty ukládají interně, nemusí nutně odrážet způsob, jakým uživatelé chtějí zobrazit. Například telefonní číslo může být uloženo ve formě 8009999999, což není uživatelsky přívětivé. Místo toho by se mělo zobrazit jako 800-999-9999. V části Vlastní řetězce formátu najdete příklad, který tímto způsobem formátuje číslo.

  • V některých případech není převod objektu na jeho řetězcovou reprezentaci intuitivní. Například není jasné, jak by se měla zobrazit řetězcová reprezentace objektu teploty nebo objektu Person. Příklad, který formátuje objekt teploty v různých způsobech, naleznete v oddílu standardní formátovací řetězce .

  • Hodnoty často vyžadují formátování zohledňující jazykovou verzi. Například v aplikaci, která používá čísla k zohlednění peněžních hodnot, musí číselné řetězce zahrnovat symbol měny aktuální jazykové verze, oddělovač skupin (ve většině kultur je oddělovač tisíců) a symbol desetinné čárky. Příklad naleznete v části formátování zohledňující jazykovou verzi s poskytovateli formátu .

  • Aplikace může být muset zobrazit stejnou hodnotu různými způsoby. Například aplikace může představovat člen výčtu zobrazením řetězcové reprezentace jeho názvu nebo zobrazením jeho základní hodnoty. Příklad, který formátuje člen DayOfWeek výčtu různými způsoby, naleznete v oddílu standardní formátovací řetězce .

Poznámka

Formátování převede hodnotu typu na řetězcovou reprezentaci. Analýza je inverzní k formátování. Operace analýzy vytvoří instanci datového typu z jeho řetězcové reprezentace. Informace o převodu řetězců na jiné datové typy naleznete v tématu Analýza řetězců.

Rozhraní .NET poskytuje bohatou podporu formátování, která vývojářům umožňuje řešit tyto požadavky.

Formátování 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 zvětšit výchozí podporu formátování. Patří mezi ně:

  • Přepsání Object.ToString metody pro definování vlastní řetězcové reprezentace 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, aby bylo možné převzít více formulářů. Například specifikátor formátu "X" v následujícím příkazu převede celé číslo na řetězcovou reprezentaci hexadecimální 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átovací řetězce .

  • Použití poskytovatelů formátu k využití 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í s poskytovateli formátu najdete v části poskytovatelé formátu .

  • Implementace IFormattable rozhraní pro podporu převodu řetězce s použitím Convert třídy i složeného formátování. Další informace najdete v části rozhraní IFormattable .

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

  • 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 prozkoumají tyto metody pro převod objektu na jeho řetězcovou reprezentaci.

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

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

using System;

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

public class Example
{
   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 Example
    Public Sub Main()
        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í. Nicméně doporučujeme, aby spravované typy neimplementovaly IStringable rozhraní. Další informace naleznete v části prostředí Windows Runtime a IStringable rozhraní na Object.ToString referenční stránce.

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

Poznámka

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

Přepsat metodu ToString

Zobrazení názvu typu je často omezeného použití a neumožňuje příjemcům vašich typů odlišit jednu instanci od druhé. Můžete však přepsat ToString metodu a poskytnout tak užitečnější reprezentace hodnoty objektu. Následující příklad definuje Temperature objekt a Přepisuje jeho ToString metodu pro zobrazení teploty ve stupních Celsia.

using System;

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 Example
{
   public static void Main()
   {
      Temperature currentTemperature = new Temperature(23.6m);
      Console.WriteLine("The current temperature is " +
                        currentTemperature.ToString());
   }
}
// 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 Example
    Public Sub Main()
        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 rozhraní .NET byla ToString Metoda každého primitivního typu hodnoty přepsána tak, aby zobrazila hodnotu objektu namísto 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á jiné přetížení ToString metody a předá jí specifikátor formátu "G", který definuje obecný formát pro svůj typ a IFormatProvider objekt, který představuje aktuální jazykovou verzi.

Typ Přepsání ToString
Boolean Vrátí buď Boolean.TrueString nebo Boolean.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á DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) k formátování hodnoty 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átovací řetězce

Spoléhání se na výchozí ToString metodu nebo přepsání ToString je vhodné, pokud objekt obsahuje jedinou řetězcovou reprezentaci. Hodnota objektu má však často více reprezentace. Například je možné vyjádřit teplotu ve stupních Fahrenheita, stupních Celsia nebo kelvinech. Podobně může být celočíselná hodnota 10 reprezentovaná mnoha způsoby, včetně 10, 10,0, 1.0 E01 nebo $10,00.

Pokud chcete povolit, aby jedna hodnota měla více řetězcových reprezentací, používá rozhraní .NET řetězce formátu. 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 svůj výstup. Formátovací řetězec je pak předán jako parametr ToString metodě objektu a určuje, jak se má zobrazit řetězcová reprezentace hodnoty daného objektu.

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

Standardní formátovací řetězce

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

Rozhraní .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. Například každá z těchto kategorií podporuje standardní specifikátor formátu "G", který definuje obecnou řetězcovou reprezentaci hodnoty tohoto typu.

Standardní formátovací řetězce pro typy výčtu přímo ovládají řetězcovou reprezentaci hodnoty. Formátovací řetězce předané metodě hodnoty výčtu určují, ToString zda je hodnota zobrazena pomocí názvu řetězce (specifikátory formátu "G" a "F"), její základní celočíselné hodnoty (specifikátor formátu "D") nebo její hexadecimální hodnota (specifikátor formátu "X"). Následující příklad ilustruje použití standardního formátovacího řetězce k formátování DayOfWeek hodnoty výčtu.

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

foreach (string formatString in formatStrings)
   Console.WriteLine(thisDay.ToString(formatString));
// The example displays the following output:
//       Monday
//       Monday
//       1
//       00000001
Dim thisDay As DayOfWeek = DayOfWeek.Monday
Dim formatStrings() As String = {"G", "F", "D", "X"}

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

Informace o formátovacích řetězcích výčtů naleznete v tématu výčty 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, NumberFormatInfo jsou pro definování řetězcové reprezentace číselné hodnoty použity následující hodnoty vlastností z objektu aktuální jazykové verze:

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

  • CurrencyNegativePatternVlastnost 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ávorkami.

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

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

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

  • CurrencyGroupSeparatorVlastnost, která definuje symbol oddělovače skupiny.

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

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

Kromě toho číselné formátovací řetězce můžou obsahovat specifikátor přesnosti. Význam tohoto specifikátoru závisí na formátovacím řetězci, se kterým je použit, ale obvykle označuje buď celkový počet číslic, nebo počet zlomkových číslic, které se mají 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 pro vytvoření řetězcové hodnoty se čtyřmi šestnáctkovými číslicemi.

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 naleznete v tématu Standardní číselné formátovací řetězce.

Standardní formátovací řetězce pro hodnoty data a času jsou aliasy pro vlastní formátovací řetězce uložené určitou DateTimeFormatInfo vlastností. Například volání ToString metody hodnoty data a času s specifikátorem formátu "D" zobrazí datum a čas pomocí vlastního formátovacího řetězce uloženého ve vlastnosti aktuální jazykové verze DateTimeFormatInfo.LongDatePattern . (Další informace o vlastních formátovacích řetězcích naleznete 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 Main()
        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 formátovacích řetězcích data a času naleznete 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 ToString(String) metodou objektu. Můžete definovat konkrétní standardní specifikátory formátu, které váš objekt podporuje, a můžete určit, zda rozlišují velká a malá písmena. Vaše implementace ToString(String) metody by měla podporovat následující:

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

  • Podpora specifikátoru formátu, který je roven nulovému odkazu ( Nothing v Visual Basic). Specifikátor formátu, který je roven nulovému odkazu, by měl být považován za ekvivalent specifikátoru formátu "G".

TemperatureTřída například může interně uchovávat teplotu ve stupních Celsia a používat specifikátory formátu k vyjádření hodnoty Temperature objektu 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 Example
{
   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 Example
    Public Sub Main()
        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ě standardních formátovacích řetězců definuje rozhraní .NET řetězce vlastního formátu pro číselné hodnoty a hodnoty data a času. Vlastní formátovací řetězec se skládá z jednoho nebo více vlastních specifikátorů formátu, které definují řetězcovou reprezentaci hodnoty. Například vlastní řetězec formátu data a času "rrrr/MM/DD hh: mm: ss. FFFF t ZZZ" převede datum na jeho řetězcovou reprezentaci ve formátu "2008/11/15 07:45:00.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 vlastních formátovacích řetězců naleznete v tématu Vlastní řetězce formátu data a času a vlastní číselné formátovací řetězce.

Pokud formátovací řetězec se skládá z jednoho vlastního specifikátoru formátu, před specifikátorem formátu by měl předcházet procentuální hodnota (%) symbol, aby nedocházelo k záměně se standardním specifikátorem formátu. V následujícím příkladu je použit Specifikátor vlastního formátu "M" k zobrazení jednociferného nebo dvoumístné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átovacích řetězců pro hodnoty data a času jsou aliasy pro vlastní formátovací řetězce, které jsou definovány vlastnostmi DateTimeFormatInfo objektu. Vlastní řetězce 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. Můžete definovat vlastní výsledné řetězce pro číselné hodnoty a hodnoty data a času kombinací více specifikátorů vlastního formátu do jednoho vlastního formátovacího řetězce. Následující příklad definuje vlastní formátovací řetězec, který zobrazuje den v týdnu v závorkách po názvu měsíce, den a rok.

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 vlastní formátovací řetězec, který zobrazí Int64 hodnotu jako standardní, sedmé číslo telefonního čísla USA spolu s jeho kódem oblasti.

using System;

public class Example
{
   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 Example
    Public Sub Main()
        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ž standardní formátovací řetězce mohou obecně zpracovat většinu formátovacích potřeb pro aplikace definované uživatelem, můžete také definovat vlastní specifikátory formátu pro formátování typů.

Řetězce formátu a typy .NET

Všechny číselné typy (tj.,,,, Byte Decimal Double Int16 Int32 , Int64 , SByte , Single , UInt16 ,,,,,,,,,,, UInt32 UInt64 a BigInteger také typy výčtu,,, DateTime DateTimeOffset TimeSpan Guid a všechny) podporují formátování pomocí formátovacích řetězců. Informace o konkrétních formátovacích řetězcích podporovaných jednotlivými typy naleznete 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 číselných hodnot specifické pro danou aplikaci.
Řetězce standardního formátu data a času Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace DateTime a DateTimeOffset hodnoty.
Vlastní řetězce formátu data a času Popisuje vlastní formátovací řetězce, které vytvářejí formáty a hodnoty specifické pro aplikaci DateTime 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 časových intervalů specifické pro danou aplikaci.
Řetězce formátu výčtu 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.

Formátování zohledňující jazykovou verzi s poskytovateli formátu

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

using System;
using System.Globalization;

public class Example
{
   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 Example
    Public Sub Main()
        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 €

IFormatProviderRozhraní zahrnuje 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 daného typu, vrátí jej. V opačném případě vrátí odkaz s hodnotou null ( Nothing v Visual Basic).

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

Několik metod formátování nebo převodu řetězce obsahuje parametr typu IFormatProvider , ale v mnoha případech je hodnota parametru při volání metody ignorována. V následující tabulce jsou uvedeny některé metody formátování, které používají parametr a typ Type objektu, který předávají IFormatProvider.GetFormat metodě.

Metoda Typ formatType parametru
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

ToStringMetody číselných typů a typů data a času jsou přetíženy a pouze některá z přetížení obsahují IFormatProvider parametr. Pokud metoda nemá parametr typu IFormatProvider , CultureInfo.CurrentCulture je místo toho předán objekt vrácený vlastností. Například volání výchozí Int32.ToString() metody nakonec má za následek volání metody, jako je následující: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture) .

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

Můžete také implementovat vlastního poskytovatele formátu a nahradit jednu z těchto tříd. Nicméně metoda vaší implementace GetFormat musí vracet objekt typu, který je uveden v předchozí tabulce, pokud má poskytnout informace o formátování ToString metodě.

Formátování číselných hodnot zohledňující jazykovou verzi

Ve výchozím nastavení je formátování číselných hodnot závislé na jazykové verzi. Pokud nezadáte jazykovou verzi při volání metody formátování, jsou použity konvence formátování aktuální jazykové verze vlákna. To je znázorněno v následujícím příkladu, který čtyřikrát změní aktuální jazykovou verzi vlákna a poté volá Decimal.ToString(String) metodu. V každém případě výsledný řetězec odráží konvence formátování aktuální jazykové verze. Důvodem je, že ToString ToString(String) metody a zabalí volání do jednotlivých metod číselného typu ToString(String, IFormatProvider) .

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   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 thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("The current culture is {0}",
                           Thread.CurrentThread.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
Imports System.Threading

Module Example
    Public Sub Main()
        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 thread culture.
            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
            Console.WriteLine("The current culture is {0}",
                              Thread.CurrentThread.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 €

Můžete také formátovat číselnou hodnotu pro konkrétní jazykovou verzi voláním ToString přetížení obsahujícího provider parametr a předáním některého z následujících:

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

  • NumberFormatInfoObjekt definující konvence formátování specifické pro jazykovou verzi, které mají být použity. Jeho GetFormat Metoda vrátí instanci sebe sama.

V následujícím příkladu jsou použity NumberFormatInfo objekty, které reprezentují jazykové verze English (USA) a angličtina (Velká Británie) a francouzské a ruské neutrální kultury pro formátování čísla s plovoucí desetinnou čárkou.

using System;
using System.Globalization;

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

      foreach (var 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 Example
    Public Sub Main()
        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 zohledňující jazykovou verzi

Ve výchozím nastavení je formátování hodnot data a času závislé na jazykové verzi. Pokud nezadáte jazykovou verzi při volání metody formátování, jsou použity konvence formátování aktuální jazykové verze vlákna. To je znázorněno v následujícím příkladu, který čtyřikrát změní aktuální jazykovou verzi vlákna a poté volá DateTime.ToString(String) metodu. V každém případě výsledný řetězec odráží konvence formátování aktuální jazykové verze. To je způsobeno tím DateTime.ToString() , že metody,, DateTime.ToString(String) DateTimeOffset.ToString() a DateTimeOffset.ToString(String) balí volání DateTime.ToString(String, IFormatProvider) DateTimeOffset.ToString(String, IFormatProvider) metod a.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   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 thread culture.
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("The current culture is {0}",
                           Thread.CurrentThread.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 Example
    Public Sub Main()
        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 thread culture.
            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
            Console.WriteLine("The current culture is {0}",
                              Thread.CurrentThread.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 

Můžete také naformátovat hodnotu data a času pro konkrétní jazykovou verzi voláním DateTime.ToString DateTimeOffset.ToString metody nebo přetížení s provider parametrem a předáním některého z následujících:

V následujícím příkladu jsou použity DateTimeFormatInfo objekty, které reprezentují jazykové verze English (USA) a angličtina (Velká Británie), a francouzská a ruština neutrální kultury k formátování data.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dat1 = new DateTime(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("{0}: {1}", 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 Example
    Public Sub Main()
        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("{0}: {1}", 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í ToString metodu s formátovacím řetězcem a IFormatProvider parametr také implementují IFormattable rozhraní. Toto rozhraní má jediný člen, IFormattable.ToString(String, IFormatProvider) , který zahrnuje formátovací řetězec i poskytovatele formátu jako parametry.

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

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

using System;
using System.Globalization;

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));
      }
   }
}
Imports System.Globalization

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 '{0}' format string is not supported.", format))
        End Select
    End Function
End Class

Následující příklad vytvoří instanci Temperature objektu. Pak zavolá ToString metodu a použije několik složených formátovacích řetězců k získání různých řetězcových reprezentace Temperature objektu. Každé z těchto volání metod zase volá IFormattable implementaci Temperature třídy.

public class Example
{
   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 Example
    Public Sub Main()
        Dim temp As New Temperature(22d)
        CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US")
        Console.WriteLine(Convert.ToString(temp1, 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))
    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 nuly, jednoho nebo více objektů. Jednotlivé objekty jsou reprezentovány ve složeném formátovacím řetězci pomocí položky indexovaného formátu. Index položky formátu odpovídá pozici objektu, který představuje v seznamu parametrů metody. Indexy jsou počítány od nuly. Například v následujícím volání String.Format metody je první položka formátu {0:D} nahrazena řetězcovou reprezentací thatDate ; druhá položka formátu {1} je nahrazena řetězcovou reprezentací item1 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 je také možné řídit následující:

  • Konkrétní způsob, jakým je objekt reprezentován jako řetězec, pokud objekt implementuje IFormattable rozhraní a podporuje řetězce formátu. To provedete tak, že použijete index položky formátu s : (dvojtečkou) následovaný platným formátovacím řetězcem. Předchozí příklad vystupoval pomocí formátovací hodnoty data s formátovacím řetězcem "d" (vzor krátkého formátu data) (například {0:d} ) a formátováním číselné hodnoty s formátovacím řetězcem "C2" (např. {2:C2} aby představovalo číslo jako hodnotu měny se dvěma zlomky desítkových čísel.

  • Šířka pole obsahujícího řetězcovou reprezentaci objektu a zarovnání řetězcové reprezentace v tomto poli. Provedete to tak, že použijete index položky formátu s , (čárka) následovaný šířkou pole. Řetězec je zarovnán vpravo v poli, pokud je šířka pole kladná hodnota a je zarovnána doleva, pokud je šířka pole záporná. Následující příklad Zarovná hodnoty data do pole o 20 znacích a v poli se 11 znaky Zarovná desítkové číslo s jednou zlomkovou hodnotou.

    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 jsou přítomny buď komponenty řetězce zarovnání, a formátovací řetězec komponenty, předchozí předchází druhý (například {0,-20:g} .

Další informace o složeném formátování najdete v tématu složené formátování.

Vlastní formátování pomocí ICustomFormatter

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

ICustomFormatterRozhraní má jedinou 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ém formátovacím řetězci. Format(String, Object, IFormatProvider)Metoda 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 odkazem na vlastní třídu vlastního formátování. Metoda vrátí vlastní formátovanou řetězcovou reprezentaci objektu, který má být formátován. Pokud metoda nemůže objekt naformátovat, měl by vrátit odkaz s hodnotou null ( Nothing v Visual Basic).

Následující příklad poskytuje ICustomFormatter implementaci s názvem ByteByByteFormatter , která zobrazuje celočíselné hodnoty jako posloupnost hexadecimálních hodnot se dvěma číslicemi 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 pro formátování celočíselných hodnot. Všimněte si, že ICustomFormatter.Format Metoda je volána více než jednou ve druhém String.Format(IFormatProvider, String, Object[]) volání metody a že výchozí NumberFormatInfo zprostředkovatel je použit ve třetí volání metody, protože.ByteByByteFormatter.Format Metoda nerozpozná formátovací řetězec "N0" a vrátí odkaz s hodnotou null ( Nothing v Visual Basic).

public class Example
{
   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 Example
    Public Sub Main()
        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
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 číselných hodnot specifické pro danou aplikaci.
Řetězce standardního 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 pro hodnoty specifické pro aplikaci DateTime .
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 časových intervalů specifické pro danou aplikaci.
Řetězce formátu výčtu 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 pro hodnoty, které jsou popsány řetězcovými reprezentacemi těchto objektů. Analýza je inverzní operace formátování.

Reference