Formatowanie typów w programie .NETFormatting types in .NET

Formatowanie to proces konwersji wystąpienia klasy, struktury lub wartości wyliczenia na reprezentację ciągu, często tak, aby otrzymany ciąg można było wyświetlić użytkownikom lub deserializacji w celu przywrócenia oryginalnego typu danych.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. Ta konwersja może stanowić wiele wyzwań:This conversion can pose a number of challenges:

  • Sposób, w jaki są przechowywane wartości wewnętrznie, niekoniecznie odzwierciedla sposób, w jaki użytkownicy chcą je wyświetlić.The way that values are stored internally does not necessarily reflect the way that users want to view them. Na przykład numer telefonu może być przechowywany w postaci 8009999999, który nie jest przyjazny dla użytkownika.For example, a telephone number might be stored in the form 8009999999, which is not user-friendly. Zamiast tego powinna być wyświetlana jako 800-999-9999.It should instead be displayed as 800-999-9999. Zapoznaj się z sekcją ciągów formatów niestandardowych , aby zapoznać się z przykładem, który formatuje liczbę w ten sposób.See the Custom Format Strings section for an example that formats a number in this way.

  • Czasami Konwersja obiektu na jego reprezentację w postaci ciągu nie jest intuicyjna.Sometimes the conversion of an object to its string representation is not intuitive. Na przykład nie jest jasne, jak powinna zostać wyświetlona Reprezentacja ciągu obiektu temperatury lub osoby.For example, it is not clear how the string representation of a Temperature object or a Person object should appear. Aby zapoznać się z przykładem, który formatuje obiekt temperatury na różne sposoby, zobacz sekcję ciągi formatu standardowego .For an example that formats a Temperature object in a variety of ways, see the Standard Format Strings section.

  • Wartości często wymagają formatowania z uwzględnieniem kultury.Values often require culture-sensitive formatting. Na przykład w aplikacji, która używa liczb do odzwierciedlenia wartości pieniężnych, ciągi numeryczne powinny zawierać symbol waluty bieżącej kultury, separator grupy (który w większości kultur jest separatorem tysięcy) i symbol dziesiętny.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. Aby zapoznać się z przykładem, zobacz Formatowanie z uwzględnieniem kultury przy użyciu dostawców formatów i sekcji interfejsu IFormatProvider .For an example, see the Culture-Sensitive Formatting with Format Providers and the IFormatProvider Interface section.

  • Aplikacja może mieć taką samą wartość na różne sposoby.An application may have to display the same value in different ways. Na przykład aplikacja może reprezentować element członkowski wyliczenia, wyświetlając ciąg reprezentujący jego nazwę lub wyświetlając jego wartość podstawową.For example, an application may represent an enumeration member by displaying a string representation of its name or by displaying its underlying value. Aby zapoznać się z przykładem formatowania elementu członkowskiego DayOfWeek wyliczenia na różne sposoby, zobacz sekcję ciągi formatu standardowego .For an example that formats a member of the DayOfWeek enumeration in different ways, see the Standard Format Strings section.

Uwaga

Formatowanie konwertuje wartość typu na reprezentację w postaci ciągu.Formatting converts the value of a type into a string representation. Analizowanie jest odwrotnością formatowania.Parsing is the inverse of formatting. Operacja analizowania tworzy wystąpienie typu danych z jego reprezentacji w postaci ciągu.A parsing operation creates an instance of a data type from its string representation. Aby uzyskać informacje o konwertowaniu ciągów na inne typy danych, zobacz Analizowanie ciągów.For information about converting strings to other data types, see Parsing Strings.

Platforma .NET zapewnia obsługę formatowania zaawansowanego, która umożliwia deweloperom rozwiązywanie tych wymagań..NET provides rich formatting support that enables developers to address these requirements.

To omówienie zawiera następujące sekcje:This overview contains the following sections:

Formatowanie w programie .NETFormatting in .NET

Podstawowym mechanizmem formatowania jest domyślna implementacja Object.ToString metody, która została omówiona w domyślnym formatowaniu przy użyciu metody ToString w dalszej części tego tematu.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. Jednak platforma .NET oferuje kilka sposobów modyfikowania i zwiększania obsługi formatowania domyślnego.However, .NET provides several ways to modify and extend its default formatting support. Należą do nich między innymi:These include the following:

  • Zastępowanie Object.ToString metody, aby zdefiniować niestandardową reprezentację obiektu w postaci ciągu.Overriding the Object.ToString method to define a custom string representation of an object’s value. Aby uzyskać więcej informacji, zobacz sekcję Zastępowanie metody ToString w dalszej części tego tematu.For more information, see the Overriding the ToString Method section later in this topic.

  • Definiowanie specyfikatorów formatu, które umożliwiają reprezentację ciągu obiektu w celu przejęcia wielu formularzy.Defining format specifiers that enable the string representation of an object’s value to take multiple forms. Na przykład, specyfikator formatu "X" w poniższej instrukcji konwertuje liczbę całkowitą na ciąg reprezentujący wartość szesnastkową.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.
    

    Aby uzyskać więcej informacji na temat specyfikatorów formatu, zobacz sekcję metody ToString i ciągi formatu .For more information about format specifiers, see the ToString Method and Format Strings section.

  • Korzystanie z dostawców formatu w celu wykorzystania Konwencji formatowania określonej kultury.Using format providers to take advantage of the formatting conventions of a specific culture. Na przykład poniższa instrukcja wyświetla wartość waluty przy użyciu Konwencji formatowania kultury 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
    

    Aby uzyskać więcej informacji o formatowaniu z dostawcami formatu, zobacz sekcję about providers and the IFormatProvider Interface (interfejs ).For more information about formatting with format providers, see the Format Providers and the IFormatProvider Interface section.

  • Implementacja interfejsu do obsługi obydwu konwersji ciągów Convert z klasą i formatowaniem złożonym. IFormattableImplementing the IFormattable interface to support both string conversion with the Convert class and composite formatting. Aby uzyskać więcej informacji, zobacz sekcję dotyczącą interfejsu IFormattable .For more information, see the IFormattable Interface section.

  • Użycie formatowania złożonego do osadzenia ciągu reprezentującego wartość w większym ciągu.Using composite formatting to embed the string representation of a value in a larger string. Aby uzyskać więcej informacji, zobacz sekcję formatowanie złożone .For more information, see the Composite Formatting section.

  • ICustomFormatter Implementowanie IFormatProvider i zapewnianie kompletnego rozwiązania do formatowania niestandardowego.Implementing ICustomFormatter and IFormatProvider to provide a complete custom formatting solution. Aby uzyskać więcej informacji, zobacz sekcję formatowanie niestandardowe z ICustomFormatter .For more information, see the Custom Formatting with ICustomFormatter section.

Poniższe sekcje przedstawiają te metody konwertowania obiektu na jego reprezentację w postaci ciągu.The following sections examine these methods for converting an object to its string representation.

Domyślne formatowania przy użyciu metody ToStringDefault Formatting Using the ToString Method

Każdy typ pochodzący od System.Object automatycznie dziedziczy ToString metodę bez parametrów, która domyślnie zwraca nazwę typu.Every type that is derived from System.Object automatically inherits a parameterless ToString method, which returns the name of the type by default. Poniższy przykład ilustruje metodę domyślną ToString .The following example illustrates the default ToString method. Definiuje klasę o nazwie Automobile , która nie ma implementacji.It defines a class named Automobile that has no implementation. Po utworzeniu wystąpienia klasy i ToString wywołaniu metody jest wyświetlana nazwa typu.When the class is instantiated and its ToString method is called, it displays its type name. Należy zauważyć, ToString że metoda nie jest jawnie wywoływana w przykładzie.Note that the ToString method is not explicitly called in the example. Metoda niejawnie wywołuje metodę obiektu, do którego jest przenoszona 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

Ostrzeżenie

Począwszy od IStringable , środowisko wykonawcze systemu Windows zawiera interfejs o pojedynczej metodzie IStringable. ToString, która zapewnia obsługę formatowania domyślnego. 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. Jednak zaleca się, aby typy zarządzane nie implementują IStringable interfejsu.However, we recommend that managed types do not implement the IStringable interface. Aby uzyskać więcej informacji, zobacz sekcję "środowisko wykonawcze systemu Windows i IStringable interfejs" Object.ToString na stronie odniesienia.For more information, see "The Windows Runtime and the IStringable Interface" section on the Object.ToString reference page.

Ponieważ wszystkie typy inne niż interfejsy są wyprowadzane Objectz, ta funkcja jest automatycznie dostarczana do niestandardowych klas lub struktur.Because all types other than interfaces are derived from Object, this functionality is automatically provided to your custom classes or structures. Jednak funkcje oferowane przez metodę domyślną ToString są ograniczone: Chociaż identyfikuje typ, nie zawiera on informacji o wystąpieniu 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. Aby podać ciąg reprezentujący obiekt, który zawiera informacje o tym obiekcie, należy zastąpić ToString metodę.To provide a string representation of an object that provides information about that object, you must override the ToString method.

Uwaga

Struktury dziedziczą ValueTypez, które z kolei są wyprowadzane z. ObjectStructures inherit from ValueType, which in turn is derived from Object. Chociaż ValueType zastąpieniaObject.ToString, jego implementacja jest taka sama.Although ValueType overrides Object.ToString, its implementation is identical.

Zastąpienie metody ToStringOverriding the ToString Method

Wyświetlanie nazwy typu jest często ograniczonym zastosowaniem i nie pozwala na odbiorców typów odróżnienia jednego wystąpienia od drugiego.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. Można jednak zastąpić ToString metodę, aby zapewnić bardziej przydatną reprezentację wartości obiektu.However, you can override the ToString method to provide a more useful representation of an object’s value. Poniższy przykład definiuje Temperature obiekt i zastępuje jego ToString metodę, aby wyświetlić temperaturę w stopniach Celsjusza.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.

W programie .NET ToString Metoda każdego typu wartości pierwotnej została zastąpiona, aby wyświetlić wartość obiektu zamiast jego nazwy.In .NET, the ToString method of each primitive value type has been overridden to display the object’s value instead of its name. W poniższej tabeli przedstawiono przesłonięcie dla każdego typu pierwotnego.The following table shows the override for each primitive type. Należy zauważyć, że większość zastąpionych metod wywołuje inne Przeciążenie ToString metody i przekazuje ją specyfikator formatu "G", który definiuje format ogólny dla jego typu, IFormatProvider a obiekt, który reprezentuje bieżącą kulturę.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.

TypType Zastąpienie metody ToStringToString override
Boolean Zwraca albo Boolean.TrueString. Boolean.FalseStringReturns either Boolean.TrueString or Boolean.FalseString.
Byte Wywołuje Byte.ToString("G", NumberFormatInfo.CurrentInfo) metodęByte formatowania wartości dla bieżącej kultury.Calls Byte.ToString("G", NumberFormatInfo.CurrentInfo) to format the Byte value for the current culture.
Char Zwraca znak jako ciąg.Returns the character as a string.
DateTime Wywołuje DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) metodę formatowania wartości daty i godziny dla bieżącej kultury.Calls DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) to format the date and time value for the current culture.
Decimal Wywołuje Decimal.ToString("G", NumberFormatInfo.CurrentInfo) metodęDecimal formatowania wartości dla bieżącej kultury.Calls Decimal.ToString("G", NumberFormatInfo.CurrentInfo) to format the Decimal value for the current culture.
Double Wywołuje Double.ToString("G", NumberFormatInfo.CurrentInfo) metodęDouble formatowania wartości dla bieżącej kultury.Calls Double.ToString("G", NumberFormatInfo.CurrentInfo) to format the Double value for the current culture.
Int16 Wywołuje Int16.ToString("G", NumberFormatInfo.CurrentInfo) metodęInt16 formatowania wartości dla bieżącej kultury.Calls Int16.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int16 value for the current culture.
Int32 Wywołuje Int32.ToString("G", NumberFormatInfo.CurrentInfo) metodęInt32 formatowania wartości dla bieżącej kultury.Calls Int32.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int32 value for the current culture.
Int64 Wywołuje Int64.ToString("G", NumberFormatInfo.CurrentInfo) metodęInt64 formatowania wartości dla bieżącej kultury.Calls Int64.ToString("G", NumberFormatInfo.CurrentInfo) to format the Int64 value for the current culture.
SByte Wywołuje SByte.ToString("G", NumberFormatInfo.CurrentInfo) metodęSByte formatowania wartości dla bieżącej kultury.Calls SByte.ToString("G", NumberFormatInfo.CurrentInfo) to format the SByte value for the current culture.
Single Wywołuje Single.ToString("G", NumberFormatInfo.CurrentInfo) metodęSingle formatowania wartości dla bieżącej kultury.Calls Single.ToString("G", NumberFormatInfo.CurrentInfo) to format the Single value for the current culture.
UInt16 Wywołuje UInt16.ToString("G", NumberFormatInfo.CurrentInfo) metodęUInt16 formatowania wartości dla bieżącej kultury.Calls UInt16.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt16 value for the current culture.
UInt32 Wywołuje UInt32.ToString("G", NumberFormatInfo.CurrentInfo) metodęUInt32 formatowania wartości dla bieżącej kultury.Calls UInt32.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt32 value for the current culture.
UInt64 Wywołuje UInt64.ToString("G", NumberFormatInfo.CurrentInfo) metodęUInt64 formatowania wartości dla bieżącej kultury.Calls UInt64.ToString("G", NumberFormatInfo.CurrentInfo) to format the UInt64 value for the current culture.

Metoda ToString i ciągi formatująceThe ToString Method and Format Strings

Opieranie się na domyślnej ToString metodzie lub ToString zastępowaniu jest odpowiednie, gdy obiekt ma pojedynczą reprezentację ciągu.Relying on the default ToString method or overriding ToString is appropriate when an object has a single string representation. Jednak wartość obiektu często ma wiele reprezentacji.However, the value of an object often has multiple representations. Na przykład temperatura może być wyrażona w stopniach Fahrenheita, stopniach Celsjusza i kelwinach.For example, a temperature can be expressed in degrees Fahrenheit, degrees Celsius, or kelvins. Podobnie wartość całkowita 10 może być reprezentowana na wiele sposobów, w tym 10, 10,0, 1.0 E01 lub $10,00.Similarly, the integer value 10 can be represented in numerous ways, including 10, 10.0, 1.0e01, or $10.00.

Aby włączyć pojedynczą wartość, aby zawierała wiele reprezentacji ciągów, platforma .NET używa ciągów formatu.To enable a single value to have multiple string representations, .NET uses format strings. Ciąg formatu jest ciągiem zawierającym co najmniej jeden wstępnie zdefiniowany specyfikator formatu, które są pojedynczymi znakami lub grupami znaków, które definiują ToString sposób formatowania danych wyjściowych przez metodę.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. Ciąg formatu jest następnie przenoszona jako parametr do ToString metody obiektu i określa, jak będzie wyglądać ciąg reprezentujący wartość tego obiektu.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.

Wszystkie typy liczbowe, typy daty i godziny oraz typy wyliczeniowe w programie .NET obsługują wstępnie zdefiniowany zestaw specyfikatorów formatu.All numeric types, date and time types, and enumeration types in .NET support a predefined set of format specifiers. Można również użyć ciągów formatowania do zdefiniowania wielu reprezentacji ciągów dla typów danych zdefiniowanych przez aplikację.You can also use format strings to define multiple string representations of your application-defined data types.

Standardowe ciągi formatująceStandard Format Strings

Ciąg formatu standardowego zawiera pojedynczy specyfikator formatu, który jest znakiem alfabetycznym, który definiuje ciąg reprezentujący obiekt, do którego jest stosowany, wraz z opcjonalnym specyfikatorem dokładności, który ma wpływ na liczbę cyfr wyświetlanych w Ciąg wynikowy.A 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. Jeśli specyfikator dokładności zostanie pominięty lub nie jest obsługiwany, specyfikator formatu standardowego jest równoznaczny z ciągiem formatu standardowego.If the precision specifier is omitted or is not supported, a standard format specifier is equivalent to a standard format string.

Platforma .NET definiuje zestaw specyfikatorów formatu standardowego dla wszystkich typów liczbowych, wszystkich typów daty i godziny oraz wszystkich typów wyliczeniowych..NET defines a set of standard format specifiers for all numeric types, all date and time types, and all enumeration types. Na przykład każda z tych kategorii obsługuje specyfikator formatu standardowego "G", który definiuje ogólną reprezentację ciągu wartości tego 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.

Ciągi formatu standardowego dla typów wyliczeniowych bezpośrednio kontrolują reprezentację ciągu wartości.Standard format strings for enumeration types directly control the string representation of a value. Ciągi formatu przesłane do ToString metody wartości wyliczenia określają, czy wartość jest wyświetlana przy użyciu nazwy ciągu (specyfikatory formatu "G" i "F"), jej podstawowej wartości całkowitej (specyfikator formatu "D") lub jej wartości szesnastkowej ("X" "specyfikator formatu).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). Poniższy przykład ilustruje użycie ciągów formatu standardowego do formatowania DayOfWeek wartości wyliczenia.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

Aby uzyskać informacje na temat ciągów formatu wyliczenia, zobacz ciągi formatujące Wyliczenie.For information about enumeration format strings, see Enumeration Format Strings.

Ciągi formatu standardowego dla typów liczbowych zwykle definiują ciąg wynikowy, którego dokładny wygląd jest kontrolowany przez jedną lub więcej wartości właściwości.Standard format strings for numeric types usually define a result string whose precise appearance is controlled by one or more property values. Na przykład specyfikator formatu "C" formatuje liczbę jako wartość walutową.For example, the "C" format specifier formats a number as a currency value. Po wywołaniu ToString metody ze specyfikatorem formatu "C" jako jedynego parametru, następujące wartości właściwości z NumberFormatInfo obiektu bieżącej kultury są używane do definiowania ciągu reprezentującego wartość liczbową: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 Właściwość, która określa symbol waluty bieżącej kultury.The CurrencySymbol property, which specifies the current culture’s currency symbol.

  • Właściwość CurrencyNegativePattern lubCurrencyPositivePattern , która zwraca liczbę całkowitą, która określa następujące elementy:The CurrencyNegativePattern or CurrencyPositivePattern property, which returns an integer that determines the following:

    • Położenie symbolu waluty.The placement of the currency symbol.

    • Czy wartości ujemne są wskazywane przez wiodący znak ujemny, końcowy znak minus lub nawiasy.Whether negative values are indicated by a leading negative sign, a trailing negative sign, or parentheses.

    • Określa, czy spacja jest wyświetlana między wartością liczbową, a symbolem waluty.Whether a space appears between the numeric value and the currency symbol.

  • CurrencyDecimalDigits Właściwość, która definiuje liczbę cyfr dziesiętnych w ciągu wynikowym.The CurrencyDecimalDigits property, which defines the number of fractional digits in the result string.

  • CurrencyDecimalSeparator Właściwość, która definiuje symbol separatora dziesiętnego w ciągu wynikowym.The CurrencyDecimalSeparator property, which defines the decimal separator symbol in the result string.

  • CurrencyGroupSeparator Właściwość, która definiuje symbol separatora grupy.The CurrencyGroupSeparator property, which defines the group separator symbol.

  • CurrencyGroupSizes Właściwość, która definiuje liczbę cyfr w każdej grupie po lewej stronie wartości dziesiętnej.The CurrencyGroupSizes property, which defines the number of digits in each group to the left of the decimal.

  • NegativeSign Właściwość, która określa znak ujemny używany w ciągu wynikowym, jeśli nawiasy nie są używane do wskazania wartości ujemnych.The NegativeSign property, which determines the negative sign used in the result string if parentheses are not used to indicate negative values.

Ponadto ciągi formatu liczbowego mogą zawierać specyfikator dokładności.In addition, numeric format strings may include a precision specifier. Znaczenie tego specyfikatora zależy od ciągu formatu, z którym jest używany, ale zazwyczaj wskazuje całkowitą liczbę cyfr lub liczbę cyfr, które powinny być wyświetlane w ciągu wynikowym.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. Na przykład w poniższym przykładzie użyto standardowego ciągu numerycznego "X4" i specyfikatora dokładności, aby utworzyć wartość ciągu, która ma cztery cyfry szesnastkowe.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

Aby uzyskać więcej informacji na temat standardowych ciągów formatowania liczbowego, zobacz Standardowe ciągi formatujące.For more information about standard numeric formatting strings, see Standard Numeric Format Strings.

Ciągi formatu standardowego dla wartości daty i godziny to aliasy dla ciągów formatów niestandardowych przechowywanych przez określoną DateTimeFormatInfo właściwość.Standard format strings for date and time values are aliases for custom format strings stored by a particular DateTimeFormatInfo property. Na przykład wywołanie ToString metody wartości daty i godziny z specyfikatorem formatu "D" powoduje wyświetlenie daty i godziny przy użyciu niestandardowego ciągu formatu przechowywanego we DateTimeFormatInfo.LongDatePattern właściwości bieżącej kultury.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. (Aby uzyskać więcej informacji na temat ciągów formatu niestandardowego, zobacz następną sekcję). Poniższy przykład ilustruje tę relację.(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

Aby uzyskać więcej informacji na temat standardowych ciągów formatu daty i godziny, zobacz ciągi standardowych formatów daty i godziny.For more information about standard date and time format strings, see Standard Date and Time Format Strings.

Za pomocą ciągów formatu standardowego można także zdefiniować ciąg reprezentujący obiekt zdefiniowany przez aplikację, który jest generowany przez ToString(String) metodę obiektu.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. Można zdefiniować określone specyfikatory formatu standardowego, które obsługuje dany obiekt, i można określić, czy są one rozróżniane wielkości liter czy nie są rozróżniane wielkości liter.You can define the specific standard format specifiers that your object supports, and you can determine whether they are case-sensitive or case-insensitive. Implementacja ToString(String) metody powinna obsługiwać następujące elementy:Your implementation of the ToString(String) method should support the following:

  • Specyfikator formatu "G", który reprezentuje niestandardowy lub typowy format obiektu.A "G" format specifier that represents a customary or common format of the object. Przeciążenie bez parametrów ToString metody obiektu powinno wywołać jego ToString(String) Przeciążenie i przekazać do niego ciąg formatu standardowego "G".The parameterless overload of your object's ToString method should call its ToString(String) overload and pass it the "G" standard format string.

  • Obsługa specyfikatora formatu, który jest równy odwołaniu o wartości null (Nothing w Visual Basic).Support for a format specifier that is equal to a null reference (Nothing in Visual Basic). Specyfikator formatu, który jest równy odwołaniu o wartości null, powinien być uważany za równoważny specyfikatorowi formatu "G".A format specifier that is equal to a null reference should be considered equivalent to the "G" format specifier.

Na przykład Temperature Klasa może wewnętrznie przechowywać temperaturę w stopniach Celsjusza i używać specyfikatorów formatu do reprezentowania wartości Temperature obiektu w stopniach Celsjusza, stopniach Fahrenheita i kelwinach.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. Poniższy przykład stanowi ilustrację.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.

Niestandardowe ciągi formatująceCustom Format Strings

Oprócz standardowych ciągów formatu, .NET definiuje niestandardowe ciągi formatu dla wartości liczbowych i wartości daty i godziny.In addition to the standard format strings, .NET defines custom format strings for both numeric values and date and time values. Niestandardowy ciąg formatu składa się z co najmniej jednego specyfikatora formatu niestandardowego, który definiuje reprezentację ciągu wartości.A custom format string consists of one or more custom format specifiers that define the string representation of a value. Na przykład niestandardowy ciąg formatu daty i godziny "rrrr/mm/dd hh: mm: SS. FFFF t ZZZ" konwertuje datę na reprezentację ciągu w postaci "2008/11/15 07:45:00.0000 P-08:00" dla kultury 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. Podobnie ciąg formatu niestandardowego "0000" konwertuje wartość całkowitą 12 na "0012".Similarly, the custom format string "0000" converts the integer value 12 to "0012". Aby zapoznać się z pełną listą niestandardowych ciągów formatujących, zobacz Niestandardowe ciągi formatujące datę i godzinę oraz Niestandardowe ciągi formatujące liczbowe.For a complete list of custom format strings, see Custom Date and Time Format Strings and Custom Numeric Format Strings.

Jeśli ciąg formatu składa się z pojedynczego specyfikatora formatu niestandardowego, specyfikator formatu powinien być poprzedzony wartością procentową (%) symbol, aby uniknąć nieporozumień ze specyfikatorem formatu standardowego.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. Poniższy przykład używa specyfikatora formatu niestandardowego "M", aby wyświetlić jedną cyfrę lub dwucyfrową liczbę miesięcy w danym dniu.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

Wiele ciągów formatu standardowego dla wartości daty i godziny to aliasy dla ciągów formatów niestandardowych, które są zdefiniowane przez właściwości DateTimeFormatInfo obiektu.Many standard format strings for date and time values are aliases for custom format strings that are defined by properties of the DateTimeFormatInfo object. Niestandardowe ciągi formatujące oferują również znaczną elastyczność w dostarczaniu formatowania zdefiniowanego przez aplikację dla wartości numerycznych lub wartości daty i godziny.Custom format strings also offer considerable flexibility in providing application-defined formatting for numeric values or date and time values. Można zdefiniować własne niestandardowe ciągi wynikowe dla wartości liczbowych i wartości daty i godziny, łącząc wiele niestandardowych specyfikatorów formatu w jeden ciąg formatu niestandardowego.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. W poniższym przykładzie zdefiniowano ciąg formatu niestandardowego, który wyświetla dzień tygodnia w nawiasach po nazwie miesiąca, dzień i roku.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)      

W poniższym przykładzie zdefiniowano ciąg formatu niestandardowego, który wyświetla Int64 wartość jako standardowy, 7-cyfrowy numer telefonu amerykańskiego wraz z numerem kierunkowym.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

Chociaż ciągi formatu standardowego mogą ogólnie obsłużyć większość potrzeb formatowania dla typów zdefiniowanych przez aplikację, można także zdefiniować specyfikatory formatu niestandardowego, aby sformatować typy.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.

Ciągi formatujące i typy .NETFormat Strings and .NET Types

Wszystkie typy liczbowe Byte(czyli Single ,,UInt64,,,, ,UInt32,, ,,iUInt16 Decimal Double Int16 Int32 Int64 SByte BigIntegertypy DateTime), a także DateTimeOffset Guidtypy wyliczeniowe,, ,iwszystkie,obsługująformatowanieciągówformatowania.TimeSpanAll 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. Informacje o określonych ciągach formatu obsługiwanych przez poszczególne typy można znaleźć w następujących tematach:For information on the specific format strings supported by each type, see the following topics:

TytułTitle DefinicjaDefinition
Standardowe ciągi formatujące liczbyStandard Numeric Format Strings Opisuje ciągi formatu standardowego, które tworzą często używane reprezentacje ciągów wartości liczbowych.Describes standard format strings that create commonly used string representations of numeric values.
Niestandardowe ciągi formatujące liczbyCustom Numeric Format Strings Opisuje niestandardowe ciągi formatujące, które tworzą formaty specyficzne dla aplikacji dla wartości liczbowych.Describes custom format strings that create application-specific formats for numeric values.
Standardowe ciągi formatujące datę i godzinęStandard Date and Time Format Strings Opisuje ciągi formatu standardowego, które tworzą często używane reprezentacje DateTime ciągu DateTimeOffset i wartości.Describes standard format strings that create commonly used string representations of DateTime and DateTimeOffset values.
Niestandardowe ciągi formatujące datę i godzinęCustom Date and Time Format Strings Opisuje niestandardowe ciągi formatujące, które tworzą formaty dla i DateTime DateTimeOffset wartości specyficzne dla aplikacji.Describes custom format strings that create application-specific formats for DateTime and DateTimeOffset values.
Standardowe ciągi formatujące TimeSpanStandard TimeSpan Format Strings Opisuje ciągi formatu standardowego, które tworzą często używane reprezentacje ciągów przedziałów czasu.Describes standard format strings that create commonly used string representations of time intervals.
Niestandardowe ciągi formatujące TimeSpanCustom TimeSpan Format Strings Opisuje niestandardowe ciągi formatujące, które tworzą formaty specyficzne dla aplikacji dla przedziałów czasu.Describes custom format strings that create application-specific formats for time intervals.
Ciągi formatujące wyliczeniaEnumeration Format Strings Opisuje ciągi formatu standardowego, które są używane do tworzenia reprezentacji ciągów wartości wyliczenia.Describes standard format strings that are used to create string representations of enumeration values.
Guid.ToString(String) Opisuje ciągi formatu standardowego dla Guid wartości.Describes standard format strings for Guid values.

Wrażliwość na ustawienia kulturowe — mechanizm formatowania i interfejs IFormatProviderCulture-Sensitive Formatting with Format Providers and the IFormatProvider Interface

Chociaż specyfikatory formatu pozwalają dostosować formatowanie obiektów, generowanie znaczących reprezentacji obiektów często wymaga dodatkowych informacji o formatowaniu.Although format specifiers let you customize the formatting of objects, producing a meaningful string representation of objects often requires additional formatting information. Na przykład formatowanie liczby jako wartości walutowej przy użyciu standardowego ciągu formatu "C" lub niestandardowego ciągu formatu, takiego jak "$ #, #. 00" wymaga co najmniej informacji o poprawnym symbolu waluty, separatorze grup i separatorze dziesiętnym do dostępne do uwzględnienia w sformatowanym ciągu.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. W programie .NET te dodatkowe informacje o formatowaniu są udostępniane za IFormatProvider pomocą interfejsu, który jest dostarczany jako parametr do jednego lub większej liczby przeciążeń ToString metody typów liczbowych i typów dat i godzin.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. IFormatProviderimplementacje są używane w programie .NET do obsługi formatowania specyficznego dla kultury.IFormatProvider implementations are used in .NET to support culture-specific formatting. Poniższy przykład ilustruje sposób, w jaki ciąg reprezentujący obiekt ulega zmianie, gdy jest sformatowany przy IFormatProvider użyciu trzech obiektów, które reprezentują różne kultury.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 €

Interfejs zawiera jedną metodę, GetFormat(Type), która ma jeden parametr, który określa typ obiektu, który zawiera informacje o formatowaniu. IFormatProviderThe IFormatProvider interface includes one method, GetFormat(Type), which has a single parameter that specifies the type of object that provides formatting information. Jeśli metoda może dostarczyć obiekt tego typu, zwraca go.If the method can provide an object of that type, it returns it. W przeciwnym razie zwraca odwołanie o wartości nullNothing (w Visual Basic).Otherwise, it returns a null reference (Nothing in Visual Basic).

IFormatProvider.GetFormatjest metodą wywołania zwrotnego.IFormatProvider.GetFormat is a callback method. Po wywołaniu ToString przeciążenia metody, która IFormatProvider zawiera GetFormat parametr, IFormatProvider wywołuje metodę tego obiektu.When you call a ToString method overload that includes an IFormatProvider parameter, it calls the GetFormat method of that IFormatProvider object. Metoda jest odpowiedzialna za zwracanie obiektu, który dostarcza niezbędne informacje o formatowaniu, jak określono przez formatType jego parametr, do ToString metody. 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.

Wiele metod formatowania lub konwersji ciągów zawiera parametr typu IFormatProvider, ale w wielu przypadkach wartość parametru jest ignorowana, gdy wywoływana jest metoda.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. W poniższej tabeli wymieniono niektóre metody formatowania, które używają parametru i typu Type obiektu, który przekazuje IFormatProvider.GetFormat do metody.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 typów liczbowychToString method of numeric types System.Globalization.NumberFormatInfo
ToStringMetoda typów daty i godzinyToString method of date and time types System.Globalization.DateTimeFormatInfo
String.Format System.ICustomFormatter
StringBuilder.AppendFormat System.ICustomFormatter

Uwaga

Metody typów liczbowych i daty i godziny są przeciążone, a tylko niektóre przeciążenia IFormatProvider zawierają 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. Jeśli metoda nie ma parametru typu IFormatProvider, zamiast niego zostanie przekazana obiekt, który jest zwracany CultureInfo.CurrentCulture przez właściwość.If a method does not have a parameter of type IFormatProvider, the object that is returned by the CultureInfo.CurrentCulture property is passed instead. Na przykład wywołanie metody domyślnej Int32.ToString() ostatecznie powoduje wywołanie metody, takie jak:. 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).

Platforma .NET udostępnia trzy klasy, IFormatProviderktóre implementują:.NET provides three classes that implement IFormatProvider:

Możesz również zaimplementować własnego dostawcę formatu, aby zastąpić każdą z tych klas.You can also implement your own format provider to replace any one of these classes. Jednak GetFormat Metoda implementacji musi zwrócić obiekt typu wymienionego w poprzedniej tabeli, jeśli musi dostarczyć informacje o formatowaniu ToString do metody.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.

Wrażliwość na ustawienia kulturowe — formatowania wartości numerycznychCulture-Sensitive Formatting of Numeric Values

Domyślnie formatowanie wartości liczbowych jest zależne od kultury.By default, the formatting of numeric values is culture-sensitive. Jeśli nie określisz kultury podczas wywoływania metody formatowania, używane są konwencje formatowania bieżącej kultury wątku.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. Jest to zilustrowane w poniższym przykładzie, który zmienia bieżącą kulturę wątku czterokrotnie, a następnie wywołuje Decimal.ToString(String) metodę.This is illustrated in the following example, which changes the current thread culture four times and then calls the Decimal.ToString(String) method. W każdym przypadku ciąg wynikowy odzwierciedla konwencje formatowania bieżącej kultury.In each case, the result string reflects the formatting conventions of the current culture. Wynika to z faktu ToString(String) , że ToString metody i zawijają wywołania ToString(String, IFormatProvider) do poszczególnych metod typu liczbowego.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 €

Możesz również sformatować wartość numeryczną dla określonej kultury, wywołując ToString Przeciążenie, które provider ma parametr i przekazując go jedną z następujących czynności: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:

Poniższy przykład używa NumberFormatInfo obiektów, które reprezentują kultury angielskie (Stany Zjednoczone) i angielskie (Wielka Brytania) oraz kulturę neutralną w języku francuskim i rosyjskim do formatowania liczby zmiennoprzecinkowej.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

Wrażliwość na ustawienia kulturowe — formatowanie wartości daty i godzinyCulture-Sensitive Formatting of Date and Time Values

Domyślnie formatowanie wartości daty i godziny jest zależne od kultury.By default, the formatting of date and time values is culture-sensitive. Jeśli nie określisz kultury podczas wywoływania metody formatowania, używane są konwencje formatowania bieżącej kultury wątku.If you do not specify a culture when you call a formatting method, the formatting conventions of the current thread culture are used. Jest to zilustrowane w poniższym przykładzie, który zmienia bieżącą kulturę wątku czterokrotnie, a następnie wywołuje DateTime.ToString(String) metodę.This is illustrated in the following example, which changes the current thread culture four times and then calls the DateTime.ToString(String) method. W każdym przypadku ciąg wynikowy odzwierciedla konwencje formatowania bieżącej kultury.In each case, the result string reflects the formatting conventions of the current culture. DateTime.ToString()Jest to spowodowane tym, że DateTimeOffset.ToString()metody, DateTimeOffset.ToString(String) DateTime.ToString(String), i zawijają wywołania DateTime.ToString(String, IFormatProvider) metod DateTimeOffset.ToString(String, IFormatProvider) i.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 

Możesz również sformatować wartość daty i godziny dla określonej kultury poprzez wywołanie metody DateTime.ToString lub DateTimeOffset.ToString przeciążenia, która ma provider parametr i przekazanie do niego jednego z następujących elementów: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:

Poniższy przykład używa DateTimeFormatInfo obiektów, które reprezentują kultury angielskie (Stany Zjednoczone) i angielskie (Wielka Brytania) oraz kulturę neutralną w języku francuskim i rosyjskim do formatowania daty.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

Interfejs IFormattableThe IFormattable Interface

Zazwyczaj typy, które przeciążą ToString metodę z ciągiem formatu IFormatProvider i parametrem również implementują IFormattable interfejs.Typically, types that overload the ToString method with a format string and an IFormatProvider parameter also implement the IFormattable interface. Ten interfejs ma pojedynczy element członkowski IFormattable.ToString(String, IFormatProvider), który zawiera ciąg formatu i dostawcę formatowania 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 Implementacja interfejsu dla klasy zdefiniowanej przez aplikację oferuje dwie zalety:Implementing the IFormattable interface for your application-defined class offers two advantages:

W poniższym przykładzie zdefiniowano Temperature klasę, która IFormattable implementuje interfejs.The following example defines a Temperature class that implements the IFormattable interface. Obsługuje specyfikatory formatu "C" lub "G", aby wyświetlić temperaturę w c, specyfikator formatu "F", aby wyświetlić temperaturę w stopniach Fahrenheita i specyfikator formatu "K", aby wyświetlić temperaturę w Kelvin.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

Poniższy przykład tworzy wystąpienie Temperature obiektu.The following example instantiates a Temperature object. Następnie wywołuje ToString metodę i używa kilku ciągów formatu złożonego, aby uzyskać różne reprezentacje Temperature ciągu obiektu.It then calls the ToString method and uses several composite format strings to obtain different string representations of a Temperature object. Z kolei każda z tych wywołań metod wywołuje IFormattable implementację Temperature klasy.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

Złożone formatowanieComposite Formatting

Niektóre metody, takie jak String.Format i StringBuilder.AppendFormat, obsługują formatowanie złożone.Some methods, such as String.Format and StringBuilder.AppendFormat, support composite formatting. Ciąg formatu złożonego jest rodzajem szablonu, który zwraca pojedynczy ciąg, który zawiera ciąg reprezentujący zero, jeden lub więcej obiektów.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. Każdy obiekt jest reprezentowany w ciągu formatu złożonego przez element formatu indeksowanego.Each object is represented in the composite format string by an indexed format item. Indeks elementu formatu odnosi się do położenia obiektu reprezentowanego na liście parametrów metody.The index of the format item corresponds to the position of the object that it represents in the method's parameter list. Indeksy są oparte na zero.Indexes are zero-based. Na przykład String.Format w poniższym wywołaniu metody pierwszy {0:D}element formatu,, jest zastępowany ciągiem reprezentującym thatDate; drugi element {1}formatu,, jest zastępowany ciągiem reprezentującym item1; i trzeci element {2:C2}formatu,,, jest zamieniany na ciąg item1.Valuereprezentujący.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.

Oprócz zamiany elementu formatu na ciąg reprezentujący odpowiadający mu obiekt, elementy formatu umożliwiają również kontrolę następujących elementów:In addition to replacing a format item with the string representation of its corresponding object, format items also let you control the following:

  • Określony sposób, w którym obiekt jest reprezentowany jako ciąg, jeśli obiekt implementuje IFormattable interfejs i obsługuje ciągi formatu.The specific way in which an object is represented as a string, if the object implements the IFormattable interface and supports format strings. Można to zrobić, wykonując indeks elementu formatowania z : dwukropkiem, po którym następuje prawidłowy ciąg formatu.You do this by following the format item's index with a : (colon) followed by a valid format string. W poprzednim przykładzie pokazano, jak sformatować wartość daty za pomocą ciągu formatu "d" (krótkiej daty) (np. {0:d}) oraz przez formatowanie wartości liczbowej przy użyciu ciągu formatu "C2" (np {2:C2} . do reprezentowania liczby jako wartości walutowej z dwoma ułamkowe cyfry dziesiętne.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.

  • Szerokość pola zawierającego reprezentację ciągu obiektu oraz wyrównanie ciągu reprezentującego w tym polu.The width of the field that contains the object's string representation, and the alignment of the string representation in that field. W tym celu należy postępować według szerokości pola , (indeks elementu formatu z przecinkiem).You do this by following the format item's index with a , (comma) followed the field width. Ciąg jest wyrównany do prawej w polu, jeśli szerokość pola jest wartością dodatnią i jest wyrównany do lewej, jeśli szerokość pola jest wartością ujemną.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. Poniższy przykład wyrównuje wartości dat w polu 20-znakowym i wyrównuje wartości dziesiętne z jedną cyfrą ułamkową w polu 11-znakowym.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
    

    Należy zauważyć, że jeśli zarówno składnik ciągu wyrównania, jak i składnik ciągu formatu są obecne, dawniej poprzedza ostatni (na przykład {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}.

Aby uzyskać więcej informacji na temat formatowania złożonego, zobacz formatowanie złożone.For more information about composite formatting, see Composite Formatting.

Niestandardowe formatowanie z ICustomFormatterCustom Formatting with ICustomFormatter

Dwie metody String.Format(IFormatProvider, String, Object[]) formatowania złożonego i StringBuilder.AppendFormat(IFormatProvider, String, Object[])zawierają parametr dostawcy formatu obsługujący niestandardowe formatowanie.Two composite formatting methods, String.Format(IFormatProvider, String, Object[]) and StringBuilder.AppendFormat(IFormatProvider, String, Object[]), include a format provider parameter that supports custom formatting. Gdy każda z tych metod formatowania jest wywoływana, przekazuje Type obiekt, który ICustomFormatter reprezentuje interfejs GetFormat do metody dostawcy formatowania.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 jest następnie odpowiedzialna za ICustomFormatter zwrócenie implementacji, która zapewnia niestandardowe formatowanie. GetFormatThe GetFormat method is then responsible for returning the ICustomFormatter implementation that provides custom formatting.

Interfejs ma pojedynczą Format(String, Object, IFormatProvider)metodę, która jest wywoływana automatycznie przez metodę formatowania złożonego, jednokrotnie dla każdego elementu formatu w ciągu formatu złożonego. 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 ma trzy parametry: ciąg formatu, który formatString reprezentuje argument w elemencie formatu, obiekt IFormatProvider do sformatowania i obiekt, który zapewnia usługi formatowania. 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. Zazwyczaj Klasa ICustomFormatter implementująca również implementuje IFormatProvider, dlatego ostatni parametr jest odwołaniem do samej klasy formatowania niestandardowego.Typically, the class that implements ICustomFormatter also implements IFormatProvider, so this last parameter is a reference to the custom formatting class itself. Metoda zwraca niestandardową reprezentację ciągu obiektu do sformatowania.The method returns a custom formatted string representation of the object to be formatted. Jeśli metoda nie może sformatować obiektu, powinna zwrócić odwołanie o wartości null (Nothing w Visual Basic).If the method cannot format the object, it should return a null reference (Nothing in Visual Basic).

W poniższym przykładzie przedstawiono ICustomFormatter implementację o nazwie ByteByByteFormatter , która wyświetla wartości całkowite jako sekwencję dwucyfrowych wartości szesnastkowych, po których występuje spacja.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

Poniższy przykład używa ByteByByteFormatter klasy do formatowania wartości całkowitych.The following example uses the ByteByByteFormatter class to format integer values. Należy zauważyć, ICustomFormatter.Format że metoda jest wywoływana więcej niż raz w drugim String.Format(IFormatProvider, String, Object[]) wywołaniu metody i że dostawca domyślny NumberFormatInfo jest używany w trzecim wywołaniu metody, ponieważ.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 nie rozpoznaje ciągu formatu "N0" i zwraca odwołanie o wartości null (Nothing w 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

TytułTitle DefinicjaDefinition
Standardowe ciągi formatujące liczbyStandard Numeric Format Strings Opisuje ciągi formatu standardowego, które tworzą często używane reprezentacje ciągów wartości liczbowych.Describes standard format strings that create commonly used string representations of numeric values.
Niestandardowe ciągi formatujące liczbyCustom Numeric Format Strings Opisuje niestandardowe ciągi formatujące, które tworzą formaty specyficzne dla aplikacji dla wartości liczbowych.Describes custom format strings that create application-specific formats for numeric values.
Standardowe ciągi formatujące datę i godzinęStandard Date and Time Format Strings Opisuje ciągi formatu standardowego, które tworzą często używane reprezentacje DateTime ciągów wartości.Describes standard format strings that create commonly used string representations of DateTime values.
Niestandardowe ciągi formatujące datę i godzinęCustom Date and Time Format Strings Opisuje niestandardowe ciągi formatujące, które tworzą formaty charakterystyczne DateTime dla aplikacji dla wartości.Describes custom format strings that create application-specific formats for DateTime values.
Standardowe ciągi formatujące TimeSpanStandard TimeSpan Format Strings Opisuje ciągi formatu standardowego, które tworzą często używane reprezentacje ciągów przedziałów czasu.Describes standard format strings that create commonly used string representations of time intervals.
Niestandardowe ciągi formatujące TimeSpanCustom TimeSpan Format Strings Opisuje niestandardowe ciągi formatujące, które tworzą formaty specyficzne dla aplikacji dla przedziałów czasu.Describes custom format strings that create application-specific formats for time intervals.
Ciągi formatujące wyliczeniaEnumeration Format Strings Opisuje ciągi formatu standardowego, które są używane do tworzenia reprezentacji ciągów wartości wyliczenia.Describes standard format strings that are used to create string representations of enumeration values.
Złożone formatowanieComposite Formatting Opisuje sposób osadzenia jednej lub więcej sformatowanych wartości w ciągu.Describes how to embed one or more formatted values in a string. Ciąg można następnie wyświetlić w konsoli lub zapisać w strumieniu.The string can subsequently be displayed on the console or written to a stream.
Wykonywanie operacji formatowaniaPerforming Formatting Operations Wyświetla listę tematów, które zawierają instrukcje krok po kroku dotyczące wykonywania określonych operacji formatowania.Lists topics that provide step-by-step instructions for performing specific formatting operations.
Analizowanie ciągówParsing Strings Opisuje sposób inicjowania obiektów do wartości opisanych przez ciąg reprezentujący te obiekty.Describes how to initialize objects to the values described by string representations of those objects. Analizowanie jest operacją odwrotną formatowania.Parsing is the inverse operation of formatting.

Tematy pomocyReference