Formátování typů v .NETFormatting types in .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.Formatting is the process of converting an instance of a class, structure, or enumeration value to its string representation, often so that the resulting string can be displayed to users or deserialized to restore the original data type. Tento převod může představovat množství problémů:This conversion can pose a number of challenges:

  • Způsob, jakým se hodnoty ukládají interně, nemusí nutně odrážet způsob, jakým uživatelé chtějí zobrazit.The way that values are stored internally does not necessarily reflect the way that users want to view them. Například telefonní číslo může být uloženo ve formě 8009999999, což není uživatelsky přívětivé.For example, a telephone number might be stored in the form 8009999999, which is not user-friendly. Místo toho by se mělo zobrazit jako 800-999-9999.It should instead be displayed as 800-999-9999. V části Vlastní řetězce formátu najdete příklad, který tímto způsobem formátuje číslo.See the Custom Format Strings section for an example that formats a number in this way.

  • V některých případech není převod objektu na jeho řetězcovou reprezentaci intuitivní.Sometimes the conversion of an object to its string representation is not intuitive. Například není jasné, jak by se měla zobrazit řetězcová reprezentace objektu teploty nebo objektu Person.For example, it is not clear how the string representation of a Temperature object or a Person object should appear. Příklad, který formátuje objekt teploty v různých způsobech, naleznete v oddílu standardní formátovací řetězce .For an example that formats a Temperature object in a variety of ways, see the Standard Format Strings section.

  • Hodnoty často vyžadují formátování zohledňující jazykovou verzi.Values often require culture-sensitive formatting. 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.For example, in an application that uses numbers to reflect monetary values, numeric strings should include the current culture’s currency symbol, group separator (which, in most cultures, is the thousands separator), and decimal symbol. Příklad naleznete v části formátování zohledňující jazykovou verzi s použitím poskytovatelů formátu a rozhraní IFormatProvider .For an example, see the Culture-Sensitive Formatting with Format Providers and the IFormatProvider Interface section.

  • Aplikace může být muset zobrazit stejnou hodnotu různými způsoby.An application may have to display the same value in different ways. 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.For example, an application may represent an enumeration member by displaying a string representation of its name or by displaying its underlying value. Příklad, který formátuje člen DayOfWeek výčtu různými způsoby, naleznete v oddílu standardní formátovací řetězce .For an example that formats a member of the DayOfWeek enumeration in different ways, see the Standard Format Strings section.

Poznámka

Formátování převede hodnotu typu na řetězcovou reprezentaci.Formatting converts the value of a type into a string representation. Analýza je inverzní k formátování.Parsing is the inverse of formatting. Operace analýzy vytvoří instanci datového typu z jeho řetězcové reprezentace.A parsing operation creates an instance of a data type from its string representation. Informace o převodu řetězců na jiné datové typy naleznete v tématu Analýza řetězců.For information about converting strings to other data types, see Parsing Strings.

Rozhraní .NET poskytuje bohatou podporu formátování, která vývojářům umožňuje řešit tyto požadavky..NET provides rich formatting support that enables developers to address these requirements.

Tento přehled obsahuje následující oddíly:This overview contains the following sections:

Formátování v .NETFormatting in .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.The basic mechanism for formatting is the default implementation of the Object.ToString method, which is discussed in the Default Formatting Using the ToString Method section later in this topic. Rozhraní .NET však nabízí několik způsobů, jak upravit a zvětšit výchozí podporu formátování.However, .NET provides several ways to modify and extend its default formatting support. Patří mezi ně například:These include the following:

  • Object.ToString Přepsání metody pro definování vlastní řetězcové reprezentace hodnoty objektu.Overriding the Object.ToString method to define a custom string representation of an object’s value. Další informace naleznete v části přepsání metody ToString dále v tomto tématu.For more information, see the Overriding the ToString Method section later in this topic.

  • 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ářů.Defining format specifiers that enable the string representation of an object’s value to take multiple forms. 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.For example, the "X" format specifier in the following statement converts an integer to the string representation of a hexadecimal value.

    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 .For more information about format specifiers, see the ToString Method and Format Strings section.

  • Použití poskytovatelů formátu k využití konvencí formátování konkrétní jazykové verze.Using format providers to take advantage of the formatting conventions of a specific culture. Například následující příkaz zobrazí hodnotu měny pomocí konvencí formátování jazykové verze en-US.For example, the following statement displays a currency value by using the formatting conventions of the en-US culture.

    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 naleznete v části poskytovatelé formátu a rozhraní IFormatProvider .For more information about formatting with format providers, see the Format Providers and the IFormatProvider Interface section.

  • Implementace rozhraní pro podporu převodu řetězce Convert s použitím třídy i složeného formátování. IFormattableImplementing the IFormattable interface to support both string conversion with the Convert class and composite formatting. Další informace najdete v části rozhraní IFormattable .For more information, see the IFormattable Interface section.

  • Použití složeného formátování pro vložení řetězcové reprezentace hodnoty do většího řetězce.Using composite formatting to embed the string representation of a value in a larger string. Další informace najdete v oddílu složené formátování .For more information, see the Composite Formatting section.

  • Implementace ICustomFormatter aIFormatProvider k poskytnutí kompletního řešení vlastního formátování.Implementing ICustomFormatter and IFormatProvider to provide a complete custom formatting solution. Další informace najdete v části vlastní formátování pomocí ICustomFormatter .For more information, see the Custom Formatting with ICustomFormatter section.

Následující části prozkoumají tyto metody pro převod objektu na jeho řetězcovou reprezentaci.The following sections examine these methods for converting an object to its string representation.

Výchozí formátování pomocí metody ToStringDefault Formatting Using the ToString Method

Každý typ, který je odvozen System.Object z automaticky dědí ToString metodu bez parametrů, která ve výchozím nastavení vrací název typu.Every type that is derived from System.Object automatically inherits a parameterless ToString method, which returns the name of the type by default. Následující příklad ilustruje výchozí ToString metodu.The following example illustrates the default ToString method. Definuje třídu s názvem Automobile , která nemá žádnou implementaci.It defines a class named Automobile that has no implementation. Když je vytvořena instance třídy a je volána ToString její metoda, zobrazí se její název typu.When the class is instantiated and its ToString method is called, it displays its type name. Všimněte si, ToString že metoda není explicitně volána v příkladu.Note that the ToString method is not explicitly called in the example. Metoda implicitně volá metodu objektu předanou do něj jako argument. ToString Console.WriteLine(Object)The Console.WriteLine(Object) method implicitly calls the ToString method of the object passed to it as an 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

Varování

Počínaje verzí prostředí Windows Runtime IStringable obsahuje rozhraní s jedinou metodou, IStringable. ToString, která poskytuje výchozí podporu formátování. Windows 8.1Windows 8.1Starting with Windows 8.1Windows 8.1, the Windows Runtime includes an IStringable interface with a single method, IStringable.ToString, which provides default formatting support. Nicméně doporučujeme, aby spravované typy neimplementovaly IStringable rozhraní.However, we recommend that managed types do not implement the IStringable interface. Další informace naleznete v části prostředí Windows Runtime a IStringable rozhraní Object.ToString na referenční stránce.For more information, see "The Windows Runtime and the IStringable Interface" section on the Object.ToString reference page.

Vzhledem k tomu, že všechny typy kromě rozhraní Objectjsou odvozeny z, tato funkce je automaticky poskytována vašim vlastním třídám nebo strukturám.Because all types other than interfaces are derived from Object, this functionality is automatically provided to your custom classes or structures. Funkce nabízené výchozí ToString metodou je však omezená: I když identifikuje typ, nemůže poskytnout žádné informace o instanci typu.However, the functionality offered by the default ToString method, is limited: Although it identifies the type, it fails to provide any information about an instance of the type. Chcete-li poskytnout řetězcovou reprezentaci objektu, který poskytuje informace o tomto objektu, je nutné ToString přepsat metodu.To provide a string representation of an object that provides information about that object, you must override the ToString method.

Poznámka

Struktury dědí z ValueType, který je zase odvozen z. ObjectStructures inherit from ValueType, which in turn is derived from Object. I ValueType když Object.ToStringPřepisuje, je jeho implementace identická.Although ValueType overrides Object.ToString, its implementation is identical.

Přepsání metody ToStringOverriding the ToString Method

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é.Displaying the name of a type is often of limited use and does not allow consumers of your types to differentiate one instance from another. Můžete však přepsat ToString metodu a poskytnout tak užitečnější reprezentace hodnoty objektu.However, you can override the ToString method to provide a more useful representation of an object’s value. Následující příklad definuje Temperature objekt a Přepisuje jeho ToString metodu pro zobrazení teploty ve stupních Celsia.The following example defines a Temperature object and overrides its ToString method to display the temperature in degrees Celsius.

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 ToString byla metoda každého primitivního typu hodnoty přepsána tak, aby zobrazila hodnotu objektu namísto názvu.In .NET, the ToString method of each primitive value type has been overridden to display the object’s value instead of its name. Následující tabulka ukazuje přepsání pro každý primitivní typ.The following table shows the override for each primitive type. 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 IFormatProvider a objekt, který představuje aktuální jazykovou verzi.Note that most of the overridden methods call another overload of the ToString method and pass it the "G" format specifier, which defines the general format for its type, and an IFormatProvider object that represents the current culture.

typeType Přepsání ToStringToString override
Boolean Vrátí buď Boolean.TrueString nebo Boolean.FalseString.Returns either Boolean.TrueString or Boolean.FalseString.
Byte Volá Byte.ToString("G", NumberFormatInfo.CurrentInfo) kByte formátování hodnoty pro aktuální jazykovou verzi.Calls Byte.ToString("G", NumberFormatInfo.CurrentInfo) to format the Byte value for the current culture.
Char Vrátí znak jako řetězec.Returns the character as a string.
DateTime Volá DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) k formátování hodnoty data a času pro aktuální jazykovou verzi.Calls DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) to format the date and time value for the current culture.
Decimal Volá Decimal.ToString("G", NumberFormatInfo.CurrentInfo) kDecimal formátování hodnoty pro aktuální jazykovou verzi.Calls Decimal.ToString("G", NumberFormatInfo.CurrentInfo) to format the Decimal value for the current culture.
Double Volá Double.ToString("G", NumberFormatInfo.CurrentInfo) kDouble formátování hodnoty pro aktuální jazykovou verzi.Calls Double.ToString("G", NumberFormatInfo.CurrentInfo) to format the Double value for the current culture.
Int16 Volá Int16.ToString("G", NumberFormatInfo.CurrentInfo) kInt16 formátování hodnoty pro aktuální jazykovou verzi.Calls Int16.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int16 value for the current culture.
Int32 Volá Int32.ToString("G", NumberFormatInfo.CurrentInfo) kInt32 formátování hodnoty pro aktuální jazykovou verzi.Calls Int32.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int32 value for the current culture.
Int64 Volá Int64.ToString("G", NumberFormatInfo.CurrentInfo) kInt64 formátování hodnoty pro aktuální jazykovou verzi.Calls Int64.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int64 value for the current culture.
SByte Volá SByte.ToString("G", NumberFormatInfo.CurrentInfo) kSByte formátování hodnoty pro aktuální jazykovou verzi.Calls SByte.ToString("G", NumberFormatInfo.CurrentInfo) to format the SByte value for the current culture.
Single Volá Single.ToString("G", NumberFormatInfo.CurrentInfo) kSingle formátování hodnoty pro aktuální jazykovou verzi.Calls Single.ToString("G", NumberFormatInfo.CurrentInfo) to format the Single value for the current culture.
UInt16 Volá UInt16.ToString("G", NumberFormatInfo.CurrentInfo) kUInt16 formátování hodnoty pro aktuální jazykovou verzi.Calls UInt16.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt16 value for the current culture.
UInt32 Volá UInt32.ToString("G", NumberFormatInfo.CurrentInfo) kUInt32 formátování hodnoty pro aktuální jazykovou verzi.Calls UInt32.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt32 value for the current culture.
UInt64 Volá UInt64.ToString("G", NumberFormatInfo.CurrentInfo) kUInt64 formátování hodnoty pro aktuální jazykovou verzi.Calls UInt64.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt64 value for the current culture.

Metoda ToString a formátovací řetězceThe ToString Method and Format Strings

Spoléhání se na výchozí ToString metodu nebo přepsání ToString je vhodné, pokud objekt obsahuje jedinou řetězcovou reprezentaci.Relying on the default ToString method or overriding ToString is appropriate when an object has a single string representation. Hodnota objektu má však často více reprezentace.However, the value of an object often has multiple representations. Například je možné vyjádřit teplotu ve stupních Fahrenheita, stupních Celsia nebo kelvinech.For example, a temperature can be expressed in degrees Fahrenheit, degrees Celsius, or kelvins. Podobně může být celočíselná hodnota 10 reprezentovaná mnoha způsoby, včetně 10, 10,0, 1.0 E01 nebo $10,00.Similarly, the integer value 10 can be represented in numerous ways, including 10, 10.0, 1.0e01, or $10.00.

Pokud chcete povolit, aby jedna hodnota měla více řetězcových reprezentací, používá rozhraní .NET řetězce formátu.To enable a single value to have multiple string representations, .NET uses format strings. 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.A format string is a string that contains one or more predefined format specifiers, which are single characters or groups of characters that define how the ToString method should format its output. 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.The format string is then passed as a parameter to the object's ToString method and determines how the string representation of that object's value should appear.

Všechny číselné typy, typy data a času a výčtové typy v rozhraní .NET podporují předdefinovanou sadu specifikátorů formátu.All numeric types, date and time types, and enumeration types in .NET support a predefined set of format specifiers. Můžete také použít formátovací řetězce k definování více řetězcových reprezentace datových typů definovaných aplikací.You can also use format strings to define multiple string representations of your application-defined data types.

Standardní formátovací řetězceStandard Format Strings

Řetězec standardního formátu obsahuje specifikátor jednoho 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í v Výsledný řetězecA standard format string contains a single format specifier, which is an alphabetic character that defines the string representation of the object to which it is applied, along with an optional precision specifier that affects how many digits are displayed in the result string. 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.If the precision specifier is omitted or is not supported, a standard format specifier is equivalent to a standard format string.

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..NET defines a set of standard format specifiers for all numeric types, all date and time types, and all enumeration types. Například každá z těchto kategorií podporuje standardní specifikátor formátu "G", který definuje obecnou řetězcovou reprezentaci hodnoty tohoto typu.For example, each of these categories supports a "G" standard format specifier, which defines a general string representation of a value of that type.

Standardní formátovací řetězce pro typy výčtu přímo ovládají řetězcovou reprezentaci hodnoty.Standard format strings for enumeration types directly control the string representation of a value. Formátovací řetězce předané ToString metodě hodnoty výčtu určují, zda se hodnota zobrazuje 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 ("X specifikátor formátu).The format strings passed to an enumeration value’s ToString method determine whether the value is displayed using its string name (the "G" and "F" format specifiers), its underlying integral value (the "D" format specifier), or its hexadecimal value (the "X" format specifier). Následující příklad ilustruje použití standardního formátovacího řetězce k formátování DayOfWeek hodnoty výčtu.The following example illustrates the use of standard format strings to format a DayOfWeek enumeration value.

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.For information about enumeration format strings, see Enumeration Format Strings.

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í.Standard format strings for numeric types usually define a result string whose precise appearance is controlled by one or more property values. Například specifikátor formátu "C" formátuje číslo jako hodnotu měny.For example, the "C" format specifier formats a number as a currency value. Při volání ToString metody se specifikátorem formátu "C" jako jediným parametrem, jsou pro definování řetězcové reprezentace číselné hodnoty použity následující hodnoty NumberFormatInfo vlastností z objektu aktuální jazykové verze:When you call the ToString method with the "C" format specifier as the only parameter, the following property values from the current culture’s NumberFormatInfo object are used to define the string representation of the numeric value:

  • CurrencySymbol Vlastnost, která určuje symbol měny aktuální jazykové verze.The CurrencySymbol property, which specifies the current culture’s currency symbol.

  • Vlastnost CurrencyNegativePattern neboCurrencyPositivePattern , která vrací celé číslo, které určuje následující:The CurrencyNegativePattern or CurrencyPositivePattern property, which returns an integer that determines the following:

    • Umístění symbolu měny.The placement of the currency symbol.

    • 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.Whether negative values are indicated by a leading negative sign, a trailing negative sign, or parentheses.

    • Určuje, zda se mezi číselnou hodnotou a symbolem měny zobrazí mezera.Whether a space appears between the numeric value and the currency symbol.

  • CurrencyDecimalDigits Vlastnost, která definuje počet zlomkových číslic ve výsledném řetězci.The CurrencyDecimalDigits property, which defines the number of fractional digits in the result string.

  • CurrencyDecimalSeparator Vlastnost, která definuje symbol oddělovače desetinných míst ve výsledném řetězci.The CurrencyDecimalSeparator property, which defines the decimal separator symbol in the result string.

  • CurrencyGroupSeparator Vlastnost, která definuje symbol oddělovače skupiny.The CurrencyGroupSeparator property, which defines the group separator symbol.

  • CurrencyGroupSizes Vlastnost, která definuje počet číslic v každé skupině nalevo od desetinné čárky.The CurrencyGroupSizes property, which defines the number of digits in each group to the left of the decimal.

  • NegativeSign Vlastnost, 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.The NegativeSign property, which determines the negative sign used in the result string if parentheses are not used to indicate negative values.

Kromě toho číselné formátovací řetězce můžou obsahovat specifikátor přesnosti.In addition, numeric format strings may include a precision specifier. 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.The meaning of this specifier depends on the format string with which it is used, but it typically indicates either the total number of digits or the number of fractional digits that should appear in the result string. 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.For example, the following example uses the "X4" standard numeric string and a precision specifier to create a string value that has four hexadecimal digits.

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.For more information about standard numeric formatting strings, see Standard Numeric Format Strings.

Standardní formátovací řetězce pro hodnoty data a času jsou aliasy pro vlastní formátovací řetězce uložené určitou DateTimeFormatInfo vlastností.Standard format strings for date and time values are aliases for custom format strings stored by a particular DateTimeFormatInfo property. 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 DateTimeFormatInfo.LongDatePattern vlastnosti aktuální jazykové verze.For example, calling the ToString method of a date and time value with the "D" format specifier displays the date and time by using the custom format string stored in the current culture’s DateTimeFormatInfo.LongDatePattern property. (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.(For more information about custom format strings, see the next section.) The following example illustrates this relationship.

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.For more information about standard date and time format strings, see Standard Date and Time Format Strings.

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.You can also use standard format strings to define the string representation of an application-defined object that is produced by the object’s ToString(String) method. 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.You can define the specific standard format specifiers that your object supports, and you can determine whether they are case-sensitive or case-insensitive. Vaše implementace ToString(String) metody by měla podporovat následující:Your implementation of the ToString(String) method should support the following:

  • Specifikátor formátu "G", který představuje vlastní nebo běžný formát objektu.A "G" format specifier that represents a customary or common format of the object. Přetížení ToString metody vašeho objektu bez parametrů by mělo ToString(String) volat přetížení a předat standardní formátovací řetězec "G".The parameterless overload of your object's ToString method should call its ToString(String) overload and pass it the "G" standard format string.

  • Podpora specifikátoru formátu, který je roven nulovému odkazu (Nothing v Visual Basic).Support for a format specifier that is equal to a null reference (Nothing in 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".A format specifier that is equal to a null reference should be considered equivalent to the "G" format specifier.

Temperature Tří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.For example, a Temperature class can internally store the temperature in degrees Celsius and use format specifiers to represent the value of the Temperature object in degrees Celsius, degrees Fahrenheit, and kelvins. V následujícím příkladu je uvedena ukázka.The following example provides an illustration.

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átuCustom Format Strings

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.In addition to the standard format strings, .NET defines custom format strings for both numeric values and date and time values. 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.A custom format string consists of one or more custom format specifiers that define the string representation of a value. 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.For example, the custom date and time format string "yyyy/mm/dd hh:mm:ss.ffff t zzz" converts a date to its string representation in the form "2008/11/15 07:45:00.0000 P -08:00" for the en-US culture. Podobně řetězec vlastního formátu "0000" Převede celočíselnou hodnotu 12 na "0012".Similarly, the custom format string "0000" converts the integer value 12 to "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.For a complete list of custom format strings, see Custom Date and Time Format Strings and Custom Numeric Format Strings.

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.If a format string consists of a single custom format specifier, the format specifier should be preceded by the percent (%) symbol to avoid confusion with a standard format specifier. 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.The following example uses the "M" custom format specifier to display a one-digit or two-digit number of the month of a particular date.

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.Many standard format strings for date and time values are aliases for custom format strings that are defined by properties of the DateTimeFormatInfo object. 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.Custom format strings also offer considerable flexibility in providing application-defined formatting for numeric values or date and time values. 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.You can define your own custom result strings for both numeric values and date and time values by combining multiple custom format specifiers into a single custom format string. 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.The following example defines a custom format string that displays the day of the week in parentheses after the month name, day, and year.

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.The following example defines a custom format string that displays an Int64 value as a standard, seven-digit U.S. telephone number along with its area code.

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ů.Although standard format strings can generally handle most of the formatting needs for your application-defined types, you may also define custom format specifiers to format your types.

Řetězce formátu a typy .NETFormat Strings and .NET Types

Všechny číselné typy Byte(tj Int64 SByte .,Single, Int32, ,,UInt16,,, ,UInt32, ,UInt64a Int16 Decimal Double BigIntegertypy) a DateTimetaké, DateTimeOffset, TimeSpan, Guida všechny typy výčtu, podporují formátování pomocí formátovacích řetězců.All numeric types (that is, the Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64, and BigInteger types), as well as the DateTime, DateTimeOffset, TimeSpan, Guid, and all enumeration types, support formatting with format strings. Informace o konkrétních formátovacích řetězcích podporovaných jednotlivými typy naleznete v následujících tématech:For information on the specific format strings supported by each type, see the following topics:

NázevTitle DefiniceDefinition
Standardní řetězce číselného formátuStandard Numeric Format Strings Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace číselných hodnot.Describes standard format strings that create commonly used string representations of numeric values.
Vlastní řetězce číselného formátuCustom Numeric Format Strings Popisuje vlastní formátovací řetězce, které vytvářejí formáty číselných hodnot specifické pro danou aplikaci.Describes custom format strings that create application-specific formats for numeric values.
Standardní řetězce formátu data a časuStandard Date and Time Format Strings Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace DateTime a DateTimeOffset hodnoty.Describes standard format strings that create commonly used string representations of DateTime and DateTimeOffset values.
Vlastní řetězce formátu data a časuCustom Date and Time Format Strings Popisuje vlastní formátovací řetězce, které vytvářejí formáty a DateTime DateTimeOffset hodnoty specifické pro aplikaci.Describes custom format strings that create application-specific formats for DateTime and DateTimeOffset values.
Standardní řetězce formátu TimeSpanStandard TimeSpan Format Strings Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace časových intervalů.Describes standard format strings that create commonly used string representations of time intervals.
Vlastní řetězce formátu TimeSpanCustom TimeSpan Format Strings Popisuje vlastní formátovací řetězce, které vytvářejí formáty časových intervalů specifické pro danou aplikaci.Describes custom format strings that create application-specific formats for time intervals.
Výčet řetězců formátuEnumeration Format Strings Popisuje standardní formátovací řetězce, které slouží k vytvoření řetězcové reprezentace hodnot výčtu.Describes standard format strings that are used to create string representations of enumeration values.
Guid.ToString(String) Popisuje standardní formátovací řetězce pro Guid hodnoty.Describes standard format strings for Guid values.

Formátování zohledňující jazykovou verzi s použitím poskytovatelů formátu a rozhraní IFormatProviderCulture-Sensitive Formatting with Format Providers and the IFormatProvider Interface

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í.Although format specifiers let you customize the formatting of objects, producing a meaningful string representation of objects often requires additional formatting information. 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, jako je "$ #, #. 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. k dispozici pro zahrnutí do formátovaného řetězce.For example, formatting a number as a currency value by using either the "C" standard format string or a custom format string such as "$ #,#.00" requires, at a minimum, information about the correct currency symbol, group separator, and decimal separator to be available to include in the formatted string. V rozhraní .NET jsou tyto dodatečné informace o formátování k dispozici IFormatProvider prostřednictvím 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.In .NET, this additional formatting information is made available through the IFormatProvider interface, which is provided as a parameter to one or more overloads of the ToString method of numeric types and date and time types. IFormatProviderimplementace jsou používány v rozhraní .NET pro podporu formátování specifického pro jazykovou verzi.IFormatProvider implementations are used in .NET to support culture-specific formatting. 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.The following example illustrates how the string representation of an object changes when it is formatted with three IFormatProvider objects that represent different cultures.

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 €

Rozhraní zahrnuje jednu metodu, GetFormat(Type), která má jeden parametr, který určuje typ objektu, který poskytuje informace o formátování. IFormatProviderThe IFormatProvider interface includes one method, GetFormat(Type), which has a single parameter that specifies the type of object that provides formatting information. Pokud metoda může poskytnout objekt daného typu, vrátí jej.If the method can provide an object of that type, it returns it. V opačném případě vrátí odkaz s hodnotouNothing null (v Visual Basic).Otherwise, it returns a null reference (Nothing in Visual Basic).

IFormatProvider.GetFormatje metoda zpětného volání.IFormatProvider.GetFormat is a callback method. Při volání ToString přetížení metody, která IFormatProvider obsahuje GetFormat parametr, IFormatProvider volá metodu tohoto objektu.When you call a ToString method overload that includes an IFormatProvider parameter, it calls the GetFormat method of that IFormatProvider object. Metoda zodpovídá za vrácení objektu, který poskytuje nezbytné informace o formátování, jak je ToString určeno jeho formatType parametrem, metodě. GetFormatThe GetFormat method is responsible for returning an object that provides the necessary formatting information, as specified by its formatType parameter, to the ToString method.

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.A number of formatting or string conversion methods include a parameter of type IFormatProvider, but in many cases the value of the parameter is ignored when the method is called. 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ě.The following table lists some of the formatting methods that use the parameter and the type of the Type object that they pass to the IFormatProvider.GetFormat method.

MetodaMethod formatType Typ parametruType of formatType parameter
ToStringMetoda číselných typůToString method of numeric types System.Globalization.NumberFormatInfo
ToStringMetoda typů data a časuToString method of date and time types System.Globalization.DateTimeFormatInfo
String.Format System.ICustomFormatter
StringBuilder.AppendFormat System.ICustomFormatter

Poznámka

Metody číselných typů a typů data a času jsou přetíženy a pouze některá z přetížení IFormatProvider obsahují parametr. ToStringThe ToString methods of the numeric types and date and time types are overloaded, and only some of the overloads include an IFormatProvider parameter. Pokud metoda nemá parametr typu IFormatProvider, je místo toho předán objekt vrácený CultureInfo.CurrentCulture vlastností.If a method does not have a parameter of type IFormatProvider, the object that is returned by the CultureInfo.CurrentCulture property is passed instead. 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).For example, a call to the default Int32.ToString() method ultimately results in a method call such as the following: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture).

Rozhraní .NET poskytuje tři třídy, IFormatProviderkteré implementují:.NET provides three classes that implement IFormatProvider:

Můžete také implementovat vlastního poskytovatele formátu a nahradit jednu z těchto tříd.You can also implement your own format provider to replace any one of these classes. Nicméně GetFormat metoda vaší implementace musí vracet objekt typu, který je uveden v předchozí tabulce, pokud má poskytnout informace o ToString formátování metodě.However, your implementation’s GetFormat method must return an object of the type listed in the previous table if it has to provide formatting information to the ToString method.

Formátování číselných hodnot zohledňující jazykovou verziCulture-Sensitive Formatting of Numeric Values

Ve výchozím nastavení je formátování číselných hodnot závislé na jazykové verzi.By default, the formatting of numeric values is culture-sensitive. 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.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. 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.This is illustrated in the following example, which changes the current thread culture four times and then calls the Decimal.ToString(String) method. V každém případě výsledný řetězec odráží konvence formátování aktuální jazykové verze.In each case, the result string reflects the formatting conventions of the current culture. Důvodem je, že ToString metody ToString(String) a zabalí volání ToString(String, IFormatProvider) do jednotlivých metod číselného typu.This is because the ToString and ToString(String) methods wrap calls to each numeric type's ToString(String, IFormatProvider) method.

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:You can also format a numeric value for a specific culture by calling a ToString overload that has a provider parameter and passing it either of the following:

V následujícím příkladu jsou NumberFormatInfo použity 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.The following example uses NumberFormatInfo objects that represent the English (United States) and English (Great Britain) cultures and the French and Russian neutral cultures to format a floating-point number.

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 verziCulture-Sensitive Formatting of Date and Time Values

Ve výchozím nastavení je formátování hodnot data a času závislé na jazykové verzi.By default, the formatting of date and time values is culture-sensitive. 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.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. 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.This is illustrated in the following example, which changes the current thread culture four times and then calls the DateTime.ToString(String) method. V každém případě výsledný řetězec odráží konvence formátování aktuální jazykové verze.In each case, the result string reflects the formatting conventions of the current culture. To je způsobeno DateTime.ToString()tím DateTime.ToString(String) DateTimeOffset.ToString(), že metody DateTimeOffset.ToString(String) ,, a balí volání DateTime.ToString(String, IFormatProvider) metod DateTimeOffset.ToString(String, IFormatProvider) a.This is because the DateTime.ToString(), DateTime.ToString(String), DateTimeOffset.ToString(), and DateTimeOffset.ToString(String) methods wrap calls to the DateTime.ToString(String, IFormatProvider) and DateTimeOffset.ToString(String, IFormatProvider) methods.

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 metody DateTimeOffset.ToString nebo přetížení s provider parametrem a předáním některého z následujících:You can also format a date and time value for a specific culture by calling a DateTime.ToString or DateTimeOffset.ToString overload that has a provider parameter and passing it either of the following:

V následujícím příkladu jsou DateTimeFormatInfo použity 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.The following example uses DateTimeFormatInfo objects that represent the English (United States) and English (Great Britain) cultures and the French and Russian neutral cultures to format a date.

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í IFormattableThe IFormattable Interface

Obvykle typy, které přetěžují ToString metodu s formátovacím řetězcem IFormatProvider a parametr také implementují IFormattable rozhraní.Typically, types that overload the ToString method with a format string and an IFormatProvider parameter also implement the IFormattable interface. Toto rozhraní má jediný člen, IFormattable.ToString(String, IFormatProvider), který zahrnuje formátovací řetězec i poskytovatele formátu jako parametry.This interface has a single member, IFormattable.ToString(String, IFormatProvider), that includes both a format string and a format provider as parameters.

IFormattable Implementace rozhraní pro třídu definovanou aplikací nabízí dvě výhody:Implementing the IFormattable interface for your application-defined class offers two advantages:

Následující příklad definuje Temperature třídu, která IFormattable implementuje rozhraní.The following example defines a Temperature class that implements the IFormattable interface. 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.It supports the "C" or "G" format specifiers to display the temperature in Celsius, the "F" format specifier to display the temperature in Fahrenheit, and the "K" format specifier to display the temperature in Kelvin.

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.The following example instantiates a Temperature object. 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.It then calls the ToString method and uses several composite format strings to obtain different string representations of a Temperature object. Každé z těchto volání metod zase volá IFormattable implementaci Temperature třídy.Each of these method calls, in turn, calls the IFormattable implementation of the Temperature class.

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íComposite Formatting

Některé metody, například String.Format a StringBuilder.AppendFormat, podporují složené formátování.Some methods, such as String.Format and StringBuilder.AppendFormat, support composite formatting. 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ů.A composite format string is a kind of template that returns a single string that incorporates the string representation of zero, one, or more objects. Jednotlivé objekty jsou reprezentovány ve složeném formátovacím řetězci pomocí položky indexovaného formátu.Each object is represented in the composite format string by an indexed format item. Index položky formátu odpovídá pozici objektu, který představuje v seznamu parametrů metody.The index of the format item corresponds to the position of the object that it represents in the method's parameter list. Indexy jsou počítány od nuly.Indexes are zero-based. String.Format Například v následujícím volání metody je první {0:D}položka formátu nahrazena řetězcovou reprezentací thatDate; druhá položka {1}formátu je nahrazena řetězcovou reprezentací item1; a třetí položka {2:C2}formátu je nahrazena řetězcovou item1.Valuereprezentací.For example, in the following call to the String.Format method, the first format item, {0:D}, is replaced by the string representation of thatDate; the second format item, {1}, is replaced by the string representation of item1; and the third format item, {2:C2}, is replaced by the string representation of 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í:In addition to replacing a format item with the string representation of its corresponding object, format items also let you control the following:

  • Konkrétní způsob, jakým je objekt reprezentován jako řetězec, pokud objekt implementuje IFormattable rozhraní a podporuje řetězce formátu.The specific way in which an object is represented as a string, if the object implements the IFormattable interface and supports format strings. To provedete tak, že použijete index položky formátu : s (dvojtečkou) následovaný platným formátovacím řetězcem.You do this by following the format item's index with a : (colon) followed by a valid format string. 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 číslic.The previous example did this by formatting a date value with the "d" (short date pattern) format string (e.g., {0:d}) and by formatting a numeric value with the "C2" format string (e.g., {2:C2} to represent the number as a currency value with two fractional decimal digits.

  • Šířka pole obsahujícího řetězcovou reprezentaci objektu a zarovnání řetězcové reprezentace v tomto poli.The width of the field that contains the object's string representation, and the alignment of the string representation in that field. Provedete to tak, že použijete index položky formátu , s (čárka) následovaný šířkou pole.You do this by following the format item's index with a , (comma) followed the field width. Ř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á.The string is right-aligned in the field if the field width is a positive value, and it is left-aligned if the field width is a negative value. 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.The following example left-aligns date values in a 20-character field, and it right-aligns decimal values with one fractional digit in an 11-character field.

    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}.Note that, if both the alignment string component and the format string component are present, the former precedes the latter (for example, {0,-20:g}.

Další informace o složeném formátování najdete v tématu složené formátování.For more information about composite formatting, see Composite Formatting.

Vlastní formátování pomocí ICustomFormatterCustom Formatting with ICustomFormatter

Dvě metody String.Format(IFormatProvider, String, Object[]) složeného formátování a StringBuilder.AppendFormat(IFormatProvider, String, Object[])zahrnují parametr poskytovatele formátu, který podporuje vlastní formátování.Two composite formatting methods, String.Format(IFormatProvider, String, Object[]) and StringBuilder.AppendFormat(IFormatProvider, String, Object[]), include a format provider parameter that supports custom formatting. Když je volána kterákoli z těchto metod formátování, předá Type objekt, který ICustomFormatter představuje rozhraní GetFormat pro metodu poskytovatele formátu.When either of these formatting methods is called, it passes a Type object that represents an ICustomFormatter interface to the format provider’s GetFormat method. Metoda je pak zodpovědná za ICustomFormatter vrácení implementace, která poskytuje vlastní formátování. GetFormatThe GetFormat method is then responsible for returning the ICustomFormatter implementation that provides custom formatting.

Rozhraní má jedinou Format(String, Object, IFormatProvider)metodu, 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. ICustomFormatterThe ICustomFormatter interface has a single method, Format(String, Object, IFormatProvider), that is called automatically by a composite formatting method, once for each format item in a composite format string. Metoda má tři parametry: formátovací řetězec, který formatString představuje argument v položce formátu, objekt IFormatProvider pro formátování a objekt, který poskytuje služby formátování. Format(String, Object, IFormatProvider)The Format(String, Object, IFormatProvider) method has three parameters: a format string, which represents the formatString argument in a format item, an object to format, and an IFormatProvider object that provides formatting services. 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í.Typically, the class that implements ICustomFormatter also implements IFormatProvider, so this last parameter is a reference to the custom formatting class itself. Metoda vrátí vlastní formátovanou řetězcovou reprezentaci objektu, který má být formátován.The method returns a custom formatted string representation of the object to be formatted. Pokud metoda nemůže objekt naformátovat, měl by vrátit odkaz s hodnotou nullNothing (v Visual Basic).If the method cannot format the object, it should return a null reference (Nothing in 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.The following example provides an ICustomFormatter implementation named ByteByByteFormatter that displays integer values as a sequence of two-digit hexadecimal values followed by a space.

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.The following example uses the ByteByByteFormatter class to format integer values. Všimněte si, ICustomFormatter.Format že metoda je volána více než jednou ve druhém String.Format(IFormatProvider, String, Object[]) volání metody a že výchozí NumberFormatInfo zprostředkovatel je použit ve třetí volání metody, protože.ByteByByteFormatter.FormatNote that the ICustomFormatter.Format method is called more than once in the second String.Format(IFormatProvider, String, Object[]) method call, and that the default NumberFormatInfo provider is used in the third method call because the .ByteByByteFormatter.Format Metoda nerozpozná formátovací řetězec "N0" a vrátí odkaz s hodnotou null (Nothing v Visual Basic).method does not recognize the "N0" format string and returns a null reference (Nothing in 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

NázevTitle DefiniceDefinition
Standardní řetězce číselného formátuStandard Numeric Format Strings Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace číselných hodnot.Describes standard format strings that create commonly used string representations of numeric values.
Vlastní řetězce číselného formátuCustom Numeric Format Strings Popisuje vlastní formátovací řetězce, které vytvářejí formáty číselných hodnot specifické pro danou aplikaci.Describes custom format strings that create application-specific formats for numeric values.
Standardní řetězce formátu data a časuStandard Date and Time Format Strings Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace DateTime hodnot.Describes standard format strings that create commonly used string representations of DateTime values.
Vlastní řetězce formátu data a časuCustom Date and Time Format Strings Popisuje vlastní formátovací řetězce, které vytvářejí formáty pro hodnoty specifické DateTime pro aplikaci.Describes custom format strings that create application-specific formats for DateTime values.
Standardní řetězce formátu TimeSpanStandard TimeSpan Format Strings Popisuje standardní formátovací řetězce, které vytvářejí běžně používané řetězcové reprezentace časových intervalů.Describes standard format strings that create commonly used string representations of time intervals.
Vlastní řetězce formátu TimeSpanCustom TimeSpan Format Strings Popisuje vlastní formátovací řetězce, které vytvářejí formáty časových intervalů specifické pro danou aplikaci.Describes custom format strings that create application-specific formats for time intervals.
Výčet řetězců formátuEnumeration Format Strings Popisuje standardní formátovací řetězce, které slouží k vytvoření řetězcové reprezentace hodnot výčtu.Describes standard format strings that are used to create string representations of enumeration values.
Složené formátováníComposite Formatting Popisuje, jak vložit jednu nebo více formátovaných hodnot do řetězce.Describes how to embed one or more formatted values in a string. Řetězec lze následně zobrazit v konzole nebo zapsat do datového proudu.The string can subsequently be displayed on the console or written to a stream.
Provádění operací formátováníPerforming Formatting Operations Obsahuje seznam témat, která poskytují podrobné pokyny pro provádění konkrétních operací formátování.Lists topics that provide step-by-step instructions for performing specific formatting operations.
Analýza řetězcůParsing Strings Popisuje, jak inicializovat objekty pro hodnoty, které jsou popsány řetězcovými reprezentacemi těchto objektů.Describes how to initialize objects to the values described by string representations of those objects. Analýza je inverzní operace formátování.Parsing is the inverse operation of formatting.

ReferenceReference