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 deserializovat ho později k obnovení původního datového typu. Tento článek představuje mechanismy formátování, které poskytuje .NET.

Poznámka

Analýza je inverzní k formátování. Operace analýzy vytvoří instanci datového typu z jeho ř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ím mechanismem formátování je výchozí implementace Object.ToString metody, která je popsána v části Výchozí formátování pomocí toString Method oddíl dále v tomto tématu. .NET 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 najdete v části Přepsání metody ToString dále v tomto tématu.

  • Definování specifikátorů formátu, které umožňují řetězcové znázornění hodnoty objektu, má několik formulářů. Specifikátor formátu "X" například 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 najdete v části ToString – metoda 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 Poskytovatelé formátu .

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

  • Pomocí složeného formátování můžete vložit řetězcovou reprezentaci hodnoty do většího řetězce. Další informace najdete v části Složené formátování .

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

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

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

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

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

using System;

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

public class Example9
{
   public static void Main()
   {
      Automobile firstAuto = new Automobile();
      Console.WriteLine(firstAuto);
   }
}
// The example displays the following output:
//       Automobile
Public Class Automobile
    ' No implementation. All members are inherited from Object.
End Class

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

Upozornění

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

Vzhledem k tomu, že všechny typy jiné než rozhraní jsou odvozeny od Object, tato funkce se automaticky poskytuje vašim vlastním třídám nebo strukturám. Funkce, které nabízí výchozí ToString metoda, je však omezená: I když identifikuje typ, neposkytuje žádné informace o instanci 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 ValueType, které jsou odvozeny z Object. I když ValueType přepsání Object.ToString, jeho implementace je identická.

Přepsání metody ToString

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

public class Temperature
{
    private decimal temp;

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

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

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

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

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

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

V .NET byla metoda každého primitivního typu hodnoty přepsána tak, ToString aby místo názvu objektu zobrazila hodnotu objektu. 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á specifikátor formátu "G", který definuje obecný formát pro jeho typ a IFormatProvider objekt, který představuje aktuální jazykovou verzi.

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

Metoda ToString a formátovací řetězce

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

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

Všechny číselné typy, typy data a času a výčty v .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 reprezentací vašich datových typů definovaných aplikací.

Standardní formátovací řetězce

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

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

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

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

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

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

Informace o řetězcích formátu výčtu naleznete 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 vlastnosti. Specifikátor formátu "C" například formátuje číslo jako hodnotu měny. Při volání ToString metody se specifikátorem formátu "C" jako jediný parametr se používají následující hodnoty vlastností z objektu aktuální jazykové verze NumberFormatInfo k definování řetězcové reprezentace číselné hodnoty:

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

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

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

    • Ať už jsou záporné hodnoty označené úvodním záporným znakem, koncovým záporným znakem nebo závorky.

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

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

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

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

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

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

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

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

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

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

using System;
using System.Globalization;

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

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

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

Pomocí standardních formátovaných řetězců můžete také definovat řetězcovou reprezentaci objektu definovaného aplikací, který je vytvořen metodou objektu ToString(String) . Můžete definovat specifikátory konkrétního standardního formátu, které váš objekt podporuje, a určit, jestli se rozlišují malá a velká písmena nebo nerozlišují malá a velká písmena. Vaše implementace ToString(String) metody by měla podporovat následující:

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

  • Podpora specifikátoru formátu, který se rovná odkazu null (Nothingv Visual Basic). Specifikátor formátu, který se rovná odkazu null, by měl být považován za ekvivalent specifikátoru formátu "G".

Třída může například Temperature interně uložit teplotu ve stupních Celsia a pomocí specifikátorů formátu znázornit hodnotu Temperature objektu ve stupních Celsia, stupňů Fahrenheit a kelvins. V následujícím příkladu je uvedena ukázka.

using System;

public class Temperature
{
   private decimal m_Temp;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Vlastní řetězce formátování

Kromě standardních řetězců formátu .NET definuje řetězce vlastního formátu pro číselné hodnoty i hodnoty data a času. Řetězec vlastního formátu se skládá z jednoho nebo více specifikátorů vlastního formátu, které definují řetězcovou reprezentaci hodnoty. Například řetězec vlastního formátu data a času "rrrr/mm/dd hh:mm:ss.ffff t zzz" převede datum na 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 řetězců vlastního formátu najdete v tématu Vlastní řetězce formátu data a času a vlastní řetězce číselného formátu.

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

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

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

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

Následující příklad definuje řetězec vlastního formátu, který zobrazuje Int64 hodnotu jako standardní sedmimístné americké telefonní číslo spolu s plošným kódem.

using System;

public class Example17
{
   public static void Main()
   {
      long number = 8009999999;
      string fmt = "000-000-0000";
      Console.WriteLine(number.ToString(fmt));
   }
}
// The example displays the following output:
//        800-999-9999
Module Example18
    Public Sub Main18()
        Dim number As Long = 8009999999
        Dim fmt As String = "000-000-0000"
        Console.WriteLine(number.ToString(fmt))
    End Sub
End Module
' The example displays the following output:

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

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

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

Všechny číselné typy (tj. Byte, , Int32Int64DecimalSingleSByteUInt32UInt16DoubleInt16, UInt64a BigInteger typy), a DateTimetaké typy , DateTimeOffsetTimeSpan, Guida všechny typy výčtů, podporují formátování pomocí formátových řetězců. Informace o konkrétních formátových řetězcích podporovaných jednotlivými typy najdete v následujících tématech:

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 řetězce vlastního formátu, 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 hodnoty.
Vlastní řetězce formátu data a času Popisuje řetězce vlastního formátu, které vytvářejí formáty specifické pro DateTime aplikaci a DateTimeOffset 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 řetězce vlastního formátu, 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ých reprezentací hodnot výčtu.
Guid.ToString(String) Popisuje standardní formátovací řetězce pro Guid hodnoty.

Formátování citlivé na jazykovou verzi s poskytovateli formátů

I když specifikátory formátu umožňují přizpůsobit formátování objektů, vytváření smysluplné řetězcové reprezentace objektů často vyžaduje další informace o formátování. Například formátování čísla jako hodnoty měny pomocí standardního řetězce formátu "C" nebo vlastního ř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 bylo možné zahrnout do formátovaného řetězce. V .NET jsou tyto další informace o formátování dostupné prostřednictvím IFormatProvider rozhraní, které je poskytováno jako parametr jedné nebo více přetížení ToString metody číselných typů a typů data a času. IFormatProvider implementace se používají v .NET k podpoře formátování specifické pro jazykovou verzi. Následující příklad ukazuje, jak se změní řetězcová reprezentace objektu při formátování se třemi IFormatProvider objekty, které představují různé jazykové verze.

using System;
using System.Globalization;

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

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

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

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

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

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

Poznámka

Metody ToString číselných typů a typů data a času jsou přetížené a pouze některé přetížení zahrnují IFormatProvider parametr. Pokud metoda nemá parametr typu IFormatProvider, objekt, který je vrácen CultureInfo.CurrentCulture vlastností, je předán místo toho. 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:

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í poskytnout informace o ToString formátování metody.

Formátování číselné hodnoty citlivé na jazykovou verzi

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

using System.Globalization;

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

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

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

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

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

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

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

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

using System.Globalization;

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

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

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

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

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

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

using System.Globalization;

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

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

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

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

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

Následující příklad používá DateTimeFormatInfo objekty, které představují jazykové verze angličtiny (USA) a angličtiny (Velká Británie) 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

IFormattable – rozhraní

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

IFormattable Implementace 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", které zobrazí teplotu ve stupních Celsia, specifikátor formátu "F", který zobrazí teplotu ve formátu Fahrenheit a specifikátor formátu "K", který zobrazí teplotu v Kelvinu.

using System;
using System.Globalization;

namespace HotAndCold
{

    public class Temperature : IFormattable
    {
        private decimal m_Temp;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        If provider Is Nothing Then provider = NumberFormatInfo.CurrentInfo

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

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

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

Složené formátování

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

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

Kromě nahrazení položky formátu řetězcovou reprezentací odpovídajícího objektu vám položky formátu také umožňují ří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 pomocí indexu položky formátu s : (dvojtečka) následovaným platným řetězcem formátu. Předchozí příklad to udělal formátováním hodnoty data pomocí řetězce formátu "d" (krátký vzor data) (např {0:d}. ) a formátováním číselné hodnoty pomocí řetězce formátu "C2" (např {2:C2} . k reprezentaci čísla jako hodnoty měny se dvěma desetinnými desetinnými číslicemi).

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

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

    Všimněte si, že pokud existuje komponenta řetězce zarovnání i komponenta řetězce formátu, předchází tomu dříve (například {0,-20:g}.

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

Vlastní formátování pomocí ICustomFormatter

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

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

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

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

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

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

      byte[] bytes;
      string output = null;

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

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

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

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

        If Not formatProvider.Equals(Me) Then Return Nothing

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

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

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

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

        Return output.Trim()
    End Function
End Class

Následující příklad používá ByteByByteFormatter třídu k formátování celočíselné hodnoty. Všimněte si, že ICustomFormatter.Format metoda je volána více než jednou ve druhém String.Format(IFormatProvider, String, Object[]) volání metody a že výchozí NumberFormatInfo zprostředkovatel se používá ve třetím volání metody, protože .ByteByByteFormatter.Formatmetoda nerozpozná řetězec formátu "N0" a vrátí nulový odkaz (Nothing v 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 řetězce vlastního formátu, 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 řetězce vlastního formátu, 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 řetězce vlastního formátu, 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ých reprezentací hodnot výčtu.
Složené formátování Popisuje, jak vložit jednu nebo více formátovaných hodnot do řetězce. Řetězec lze následně zobrazit v konzole nebo zapsat do datového proudu.
Analýza řetězců Popisuje, jak inicializovat objekty na hodnoty popsané řetězcovou reprezentací těchto objektů. Analýza je inverzní operace formátování.

Reference