String.Format Metoda

Definicja

Konwertuje wartość obiektów na ciągi w oparciu o określone formaty i wstawia je do innego ciągu.Converts the value of objects to strings based on the formats specified and inserts them into another string.

Jeśli dopiero zaczynasz korzystać z metody String.Format, zobacz sekcję wprowadzenie do metody String. format , aby zapoznać się z krótkim omówieniem.If you are new to the String.Format method, see the Get started with the String.Format method section for a quick overview.

Zobacz sekcję uwagi , aby zapoznać się z ogólną dokumentacją metody String.Format.See the Remarks section for general documentation for the String.Format method.

Przeciążenia

Format(String, Object)

Zamienia jeden lub więcej elementów formatu ciągu na ciąg reprezentujący określony obiekt.Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object[])

Zamienia element formatu w określonym ciągu na ciąg reprezentujący odpowiadający obiekt w określonej tablicy.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

Format(IFormatProvider, String, Object)

Zamienia element formatu lub elementy w określonym ciągu na ciąg reprezentujący odpowiadający obiekt.Replaces the format item or items in a specified string with the string representation of the corresponding object. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[])

Zamienia elementy formatu w ciągu na ciąg reprezentujący odpowiadające obiekty w określonej tablicy.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.A parameter supplies culture-specific formatting information.

Format(String, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący dwa określone obiekty.Replaces the format items in a string with the string representation of two specified objects.

Format(IFormatProvider, String, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący dwa określone obiekty.Replaces the format items in a string with the string representation of two specified objects. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.A parameter supplies culture-specific formatting information.

Format(String, Object, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący trzy określone obiekty.Replaces the format items in a string with the string representation of three specified objects.

Format(IFormatProvider, String, Object, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący trzy określone obiekty.Replaces the format items in a string with the string representation of three specified objects. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.An parameter supplies culture-specific formatting information.

Przykłady

Liczne przykłady, które wywołują metodę Format, są przeplatane w sekcji uwagi tego artykułu.Numerous examples that call the Format method are interspersed through the Remarks section of this article.

Uwaga

Przykłady języka C#, w tym artykule uruchamiane w Try.NET modułu uruchamiającego testy i Plac zabaw dla kodu wbudowanego.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Jeśli jest obecny, zaznacz Uruchom przycisk, aby uruchomić przykład, w oknie interaktywnym.When present, select the Run button to run an example in an interactive window. Po wykonaniu kodu, możesz go zmodyfikować i uruchomić zmodyfikowany kod, wybierając Uruchom ponownie.Once you execute the code, you can modify it and run the modified code by selecting Run again. Zmodyfikowanego kodu albo działa w oknie interaktywnym lub, jeśli kompilacja nie powiedzie się, w oknie interaktywnym Wyświetla wszystkie C# kompilatora komunikaty o błędach.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Możesz również pobrać kompletny zestaw String.Format przykładów, które są uwzględnione w projekcie .NET Core 2,0 dla C# i projektu .NET Core 2,0 dla Visual Basic, w repozytorium GitHub/Samples.You can also download a complete set of String.Format examples, which are included a .NET Core 2.0 project for C# and a .NET Core 2.0 project for Visual Basic, from the dotnet/samples GitHub repository.

Poniżej przedstawiono niektóre przykłady zawarte w artykule:The following are some of the examples included in the article:

Utwórz ciąg formatuCreate a format string

Wstawianie ciąguInserting a string
Element formatuThe format item
Sformatuj elementy, które mają ten sam indeksFormat items that have the same index

Kontrolowanie danych wyjściowych w formacieControl formatted output

Kontrolowanie formatowaniaControlling formatting
Kontrolowanie odstępówControlling spacing
Kontrolowanie wyrównaniaControlling alignment
Kontrolowanie liczby cyfr całkowitychControlling the number of integral digits
Kontrolowanie liczby cyfr po separatorze dziesiętnymControlling the number of digits after the decimal separator
Uwzględnianie nawiasów klamrowych w ciągu wynikowymIncluding literal braces in a result string

Wprowadź w formacie ciągi kulturoweMake format strings culture-sensitive

Formatowanie z uwzględnieniem kulturCulture-sensitive formatting

Dostosowywanie operacji formatowaniaCustomize the formatting operation

Niestandardowa Operacja formatowaniaA custom formatting operation
Dostawca przechwycenia i program formatujący cyfry rzymskieAn intercept provider and Roman numeral formatter

Uwagi

Ważne

Zamiast wywoływać metodę String.Format metody lub używając ciągów formatowania złożonego, możesz użyć ciągi interpolowane Jeśli język je obsługuje.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Ciąg interpolowany jest ciąg zawierający wyrażeń interpolowanych.An interpolated string is a string that contains interpolated expressions. Każde wyrażenie interpolowane jest rozwiązany wartość wyrażenia i uwzględnione w ciągu wynikowym, jeśli ciąg jest przypisany.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Aby uzyskać więcej informacji, zobacz Interpolacja ciągów (C# odwołania) i ciągi interpolowane (odwołanie w Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

W tej sekcji:In this section:

Zacznij korzystać z metody String. Format Get started with the String.Format method
Którą metodę nazywam? Which method do I call?
Metoda format w krótkim The Format method in brief
Element formatu The Format item
Sposób formatowania argumentów How arguments are formatted
Sformatuj elementy, które mają ten sam indeks Format items that have the same index
Formatowanie i kulturoweFormatting and culture
Niestandardowe operacje formatowania Custom formatting operations
Ciąg. format Q & AString.Format Q & A

Wprowadzenie do metody String. formatGet started with the String.Format method

Użyj String.Format, jeśli chcesz wstawić wartość obiektu, zmiennej lub wyrażenia do innego ciągu.Use String.Format if you need to insert the value of an object, variable, or expression into another string. Na przykład można wstawić wartość Decimal wartość do ciągu, aby wyświetlić go użytkownikowi jako pojedynczy ciąg:For example, you can insert the value of a Decimal value into a string to display it to the user as a single string:

Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0} per ounce.",
                           pricePerOunce);
// Result: The current price is 17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result: The current price is 17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36d
Dim s As String = String.Format("The current price is {0} per ounce.",
                                pricePerOunce)
' Result: The current price is 17.36 per ounce.

Możesz kontrolować formatowanie tej wartości:And you can control that value's formatting:

Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0:C2} per ounce.",
                           pricePerOunce);
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0:C2} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36d
Dim s As String = String.Format("The current price is {0:C2} per ounce.",
                                pricePerOunce)
' Result if current culture is en-US:
'      The current price is $17.36 per ounce.

Oprócz formatowania można również kontrolować wyrównanie i odstępy.Besides formatting, you can also control alignment and spacing.

Wstawianie ciąguInserting a string

String.Format rozpoczyna się od ciągu formatu, po którym następuje co najmniej jeden obiekt lub wyrażenie, które zostanie przekonwertowane na ciągi i wstawione w określonym miejscu w ciągu formatu.String.Format starts with a format string, followed by one or more objects or expressions that will be converted to strings and inserted at a specified place in the format string. Na przykład:For example:

Decimal temp = (Decimal)20.4;
String^ s = String::Format("The temperature is {0}°C.", temp);
Console::WriteLine(s);
// Displays 'The temperature is 20.4°C.'
decimal temp = 20.4m;
string s = String.Format("The temperature is {0}°C.", temp);
Console.WriteLine(s);
// Displays 'The temperature is 20.4°C.'
Dim temp As Decimal = 20.4d
Dim s As String = String.Format("The temperature is {0}°C.", temp)
Console.WriteLine(s)
' Displays 'The temperature is 20.4°C.'

{0} w ciągu formatu jest elementem formatu.The {0} in the format string is a format item. 0 jest indeksem obiektu, którego wartość ciągu zostanie wstawiona w tym miejscu.0 is the index of the object whose string value will be inserted at that position. (Indeksy zaczynają się od 0). Jeśli obiekt, który ma zostać wstawiony, nie jest ciągiem, jego Metoda ToString jest wywoływana, aby przekonwertować ją na jeden przed wstawieniem go w ciągu wynikowym.(Indexes start at 0.) If the object to be inserted is not a string, its ToString method is called to convert it to one before inserting it in the result string.

Oto inny przykład, w którym są używane dwa elementy formatu i dwa obiekty na liście obiektów:Here's another example that uses two format items and two objects in the object list:

String^ s = String::Format("At {0}, the temperature is {1}°C.",
                           DateTime::Now, 20.4);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
string s = String.Format("At {0}, the temperature is {1}°C.",
                         DateTime.Now, 20.4);
Console.WriteLine(s);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
Dim s As String = String.Format("At {0}, the temperature is {1}°C.",
                                Date.Now, 20.4)
' Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'

Możesz mieć dowolną liczbę elementów formatu i dowolną liczbę obiektów na liście obiektów, tak długo, jak indeks każdego elementu formatu ma pasujący obiekt na liście obiektów.You can have as many format items and as many objects in the object list as you want, as long as the index of every format item has a matching object in the object list. Nie trzeba również martwić się o to, które Przeciążenie zostało wywołane; Kompilator wybierze odpowiedni dla siebie.You also don't have to worry about which overload you call; the compiler will select the appropriate one for you.

Kontrolowanie formatowaniaControlling formatting

Możesz użyć indeksu w elemencie formatu z ciągiem formatu, aby kontrolować sposób formatowania obiektu.You can follow the index in a format item with a format string to control how an object is formatted. Na przykład {0:d} stosuje ciąg formatu "d" do pierwszego obiektu na liście obiektów.For example, {0:d} applies the "d" format string to the first object in the object list. Oto przykład z pojedynczym obiektem i dwoma elementami formatu:Here is an example with a single object and two format items:

String^ s = String::Format("It is now {0:d} at {0:t}",
                           DateTime::Now);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
string s = String.Format("It is now {0:d} at {0:t}", DateTime.Now);
Console.WriteLine(s);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
Dim s As String = String.Format("It is now {0:d} at {0:t}",
                                Date.Now)
' Output similar to: 'It is now 4/10/2015 at 10:04 AM'

Niektóre typy obsługują ciągi formatujące, w tym wszystkie typy liczbowe (ciągi formatu standardowego i niestandardowego ), wszystkie daty i godziny (zarówno w formacie standardowych , jak i niestandardowych ) oraz przedziały czasu (ciągi formatu standardowego i niestandardowego ), wszystkie typy wyliczeniowei identyfikatory GUID.A number of types support format strings, including all numeric types (both standard and custom format strings), all dates and times (both standard and custom format strings) and time intervals (both standard and custom format strings), all enumeration types enumeration types, and GUIDs. Możesz również dodać obsługę ciągów formatowania do własnych typów.You can also add support for format strings to your own types.

Kontrolowanie odstępówControlling spacing

Można zdefiniować szerokość ciągu, która jest wstawiana do ciągu wynikowego przy użyciu składni takiej jak {0,12}, która wstawia 12-znakowy ciąg.You can define the width of the string that is inserted into the result string by using syntax such as {0,12}, which inserts a 12-character string. W takim przypadku ciąg reprezentujący pierwszy obiekt jest wyrównany do prawej w polu 12 znaków.In this case, the string representation of the first object is right-aligned in the 12-character field. (Jeśli ciąg reprezentujący pierwszy obiekt ma więcej niż 12 znaków, chociaż Preferowana szerokość pola jest ignorowana, a cały ciąg zostanie wstawiony do ciągu wynikowego.)(If the string representation of the first object is more than 12 characters in length, though, the preferred field width is ignored, and the entire string is inserted into the result string.)

W poniższym przykładzie zdefiniowano 6-znakowe pole w celu przechowywania ciągu "Year" i niektórych ciągów rok, a także pola 15-znakowego do przechowywania ciągu "populacja" i niektórych danych populacji.The following example defines a 6-character field to hold the string "Year" and some year strings, as well as an 15-character field to hold the string "Population" and some population data. Należy zauważyć, że znaki w polu są wyrównane do prawej strony.Note that the characters are right-aligned in the field.

array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
StringBuiler^ sb = gcnew StringBuilder();
sb->Append(String::Format("{0,6} {1,15}\n\n", "Year", "Population"));
for(int index = 0; index < years->Length; index++)
   sb->AppendFormat("{0,6} {1,15:N0}\n",
                    years[index], population[index]);
// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203
     int[] years = { 2013, 2014, 2015 };
     int[] population = { 1025632, 1105967, 1148203 };
     var sb = new System.Text.StringBuilder();
     sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
     for (int index = 0; index < years.Length; index++)
        sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));

     Console.WriteLine(sb);

     // Result:
     //      Year      Population
     //
     //      2013       1,025,632
     //      2014       1,105,967
     //      2015       1,148,203
Dim years() As Integer = { 2013, 2014, 2015 }
Dim population() As Integer  = { 1025632, 1105967, 1148203 }
Dim sb As New StringBuilder()
sb.Append(String.Format("{0,6} {1,15}{2}{2}",
                        "Year", "Population", vbCrLf))
For index As Integer = 0 To years.Length - 1
   sb.AppendFormat("{0,6} {1,15:N0}{2}",
                   years(index), population(index), vbCrLf)
Next
' Result:
'      Year      Population
'
'      2013       1,025,632
'      2014       1,105,967
'      2015       1,148,203

Kontrolowanie wyrównaniaControlling alignment

Domyślnie ciągi są wyrównane do prawej w polach w przypadku określenia szerokości pola.By default, strings are right-aligned within their field if you specify a field width. Aby wyrównać lewe ciągi w polu, należy poprzedzić szerokość pola znakiem minus, na przykład {0,-12}, aby zdefiniować 12-znakowe pole wyrównane do lewej strony.To left-align strings in a field, you preface the field width with a negative sign, such as {0,-12} to define a 12-character left-aligned field.

Poniższy przykład jest podobny do poprzedniego, z tą różnicą, że wyrównuje zarówno etykiety, jak i dane.The following example is similar to the previous one, except that it left-aligns both labels and data.

array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
String^ s = String::Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years->Length; index++)
   s += String::Format("{0,-10} {1,-10:N0}\n",
                      years[index], population[index]);
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years.Length; index++)
   s += String.Format("{0,-10} {1,-10:N0}\n",
                      years[index], population[index]);
Console.WriteLine($"\n{s}");
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203
Dim years() As Integer = { 2013, 2014, 2015 }
Dim population() As Integer  = { 1025632, 1105967, 1148203 }
Dim s As String = String.Format("{0,-10} {1,-10}{2}{2}",
                                "Year", "Population", vbCrLf)
For index As Integer = 0 To years.Length - 1
   s += String.Format("{0,-10} {1,-10:N0}{2}",
                      years(index), population(index), vbCrLf)
Next
' Result:
'    Year       Population
'
'    2013       1,025,632
'    2014       1,105,967
'    2015       1,148,203

String.Format korzysta z funkcji formatowania złożonego.String.Format makes use of the composite formatting feature. Aby uzyskać więcej informacji, zobacz formatowanie złożone.For more information, see Composite Formatting.

Jaką metodę wywołać?Which method do I call?

DoTo RozmowaCall
Sformatuj jeden lub więcej obiektów przy użyciu Konwencji bieżącej kultury.Format one or more objects by using the conventions of the current culture. Z wyjątkiem przeciążeń, które zawierają parametr provider, pozostałe przeciążenia Format obejmują parametr String, po którym następuje co najmniej jeden parametr obiektu.Except for the overloads that include a provider parameter, the remaining Format overloads include a String parameter followed by one or more object parameters. W związku z tym nie trzeba określać, które Format przeciążenia mają być wywoływane.Because of this, you don't have to determine which Format overload you intend to call. Kompilator języka wybiera odpowiednie Przeciążenie spośród przeciążeń, które nie mają provider parametru, na podstawie listy argumentów.Your language compiler selects the appropriate overload from among the overloads that don't have a provider parameter, based on your argument list. Na przykład jeśli lista argumentów ma pięć argumentów, kompilator wywołuje metodę Format(String, Object[]).For example, if your argument list has five arguments, the compiler calls the Format(String, Object[]) method.
Sformatuj jeden lub więcej obiektów przy użyciu konwencji określonej kultury.Format one or more objects by using the conventions of a specific culture. Każde Przeciążenie Format, które rozpoczyna się od parametru provider, następuje String parametr i co najmniej jeden parametr obiektu.Each Format overload that begins with a provider parameter is followed by a String parameter and one or more object parameters. W związku z tym nie trzeba określać konkretnych przeciążeń Format, które mają być wywoływane.Because of this, you don't have to determine which specific Format overload you intend to call. Kompilator języka wybiera odpowiednie Przeciążenie z przeciążeń, które mają parametr provider, na podstawie listy argumentów.Your language compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list. Na przykład jeśli lista argumentów ma pięć argumentów, kompilator wywołuje metodę Format(IFormatProvider, String, Object[]).For example, if your argument list has five arguments, the compiler calls the Format(IFormatProvider, String, Object[]) method.
Wykonywanie niestandardowej operacji formatowania z implementacją ICustomFormatter lub implementacją IFormattable.Perform a custom formatting operation either with an ICustomFormatter implementation or an IFormattable implementation. Dowolny z czterech przeciążeń z parametrem provider.Any of the four overloads with a provider parameter. Kompilator wybiera odpowiednie Przeciążenie spośród przeciążeń, które mają parametr provider, na podstawie listy argumentów.The compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list.

Metoda formatowania w skrócieThe Format method in brief

Każde Przeciążenie metody Format używa funkcji formatowania złożonego , aby dołączyć indeksowane symbole zastępcze oparte na zero, nazywane elementami formatu, w ciągu formatu złożonego.Each overload of the Format method uses the composite formatting feature to include zero-based indexed placeholders, called format items, in a composite format string. W czasie wykonywania każdy element formatu jest zamieniany na ciąg reprezentujący odpowiadający argument na liście parametrów.At run time, each format item is replaced with the string representation of the corresponding argument in a parameter list. Jeśli wartość argumentu jest null, element formatu jest zastępowany String.Empty.If the value of the argument is null, the format item is replaced with String.Empty. Na przykład następujące wywołanie metody Format(String, Object, Object, Object) zawiera ciąg formatu z trzema elementami formatu, {0}, {1}i {2}, a lista argumentów z trzema elementami.For example, the following call to the Format(String, Object, Object, Object) method includes a format string with three format items, {0}, {1}, and {2}, and an argument list with three items.

using namespace System;

void main()
{
   DateTime^ dat = gcnew DateTime(2012, 1, 17, 9, 30, 0); 
   String^ city = "Chicago";
   int temp = -16;
   String^ output = String::Format("At {0} in {1}, the temperature was {2} degrees.",
                                   dat, city, temp);
   Console::WriteLine(output);
}
// The example displays the following output: 
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   
DateTime dat = new DateTime(2012, 1, 17, 9, 30, 0); 
string city = "Chicago";
int temp = -16;
string output = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                              dat, city, temp);
Console.WriteLine(output);
// The example displays output like the following:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   
Dim dat As Date = #1/17/2012 9:30AM# 
Dim city As String = "Chicago"
Dim temp As Integer = -16
Dim output As String = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                                     dat, city, temp)
Console.WriteLine(output)
' The example displays the following output:
'    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.   

Element formatuThe format item

Element formatu ma następującą składnię:A format item has this syntax:

{index[,alignment][:formatString]}  

Nawiasy klamrowe oznaczają opcjonalne elementy.Brackets denote optional elements. Otwierające i zamykające nawiasy klamrowe są wymagane.The opening and closing braces are required. (Aby dołączyć literał otwierającego lub zamykającego nawiasu klamrowego w ciągu formatu, zobacz sekcję dotyczącą nawiasów klamrowych w artykule dotyczącym formatowania złożonego ).(To include a literal opening or closing brace in the format string, see the Escaping Braces section in the Composite Formatting article.)

Na przykład element formatu służący do formatowania wartości walutowej może wyglądać następująco:For example, a format item to format a currency value might appear like this:

String::Format("{0,-10:C}", (Decimal) 126347.89);         
var value = String.Format("{0,-10:C}", 126347.89m);         
Console.WriteLine(value);
String.Format("{0,-10:C}", 126347.89d)        

Element formatu ma następujące elementy:A format item has the following elements:

indexindex
Indeks (liczony od zera) argumentu, którego reprezentacja ciągu ma zostać uwzględniona w tym położeniu w ciągu.The zero-based index of the argument whose string representation is to be included at this position in the string. Jeśli ten argument jest null, pusty ciąg zostanie uwzględniony w tej pozycji w ciągu.If this argument is null, an empty string will be included at this position in the string.

strukturyalignment
Opcjonalny.Optional. Liczba całkowita ze znakiem, która wskazuje łączną długość pola, do którego wstawiono argument, i określa, czy jest wyrównany do prawej (dodatnia liczba całkowita) czy wyrównany do lewej (ujemna liczba całkowita).A signed integer that indicates the total length of the field into which the argument is inserted and whether it is right-aligned (a positive integer) or left-aligned (a negative integer). W przypadku pominięcia wyrównania, reprezentacja odpowiadającego argumentu jest wstawiana w polu bez spacji wiodących i końcowych.If you omit alignment, the string representation of the corresponding argument is inserted in a field with no leading or trailing spaces.

Jeśli wartość wyrównania jest mniejsza niż długość argumentu, który ma zostać wstawiony, wyrównanie jest ignorowane i długość ciągu reprezentującego argument jest używana jako szerokość pola.If the value of alignment is less than the length of the argument to be inserted, alignment is ignored and the length of the string representation of the argument is used as the field width.

FormatowanieformatString
Opcjonalny.Optional. Ciąg określający format ciągu wynikowego odpowiadającego argumentu.A string that specifies the format of the corresponding argument's result string. W przypadku pominięcia elementu FormatString, odpowiednia metoda ToString bezparametrowego argumentu jest wywoływana, aby utworzyć reprezentację ciągu.If you omit formatString, the corresponding argument's parameterless ToString method is called to produce its string representation. W przypadku określenia elementu FormatStringargument, do którego odwołuje się element formatu, musi implementować interfejs IFormattable.If you specify formatString, the argument referenced by the format item must implement the IFormattable interface. Typy obsługujące ciągi formatu obejmują:Types that support format strings include:

Należy jednak pamiętać, że dowolny typ niestandardowy może zaimplementować IFormattable lub zwiększyć implementację IFormattable istniejącej typu.However, note that any custom type can implement IFormattable or extend an existing type's IFormattable implementation.

Poniższy przykład używa argumentów alignment i formatString do tworzenia sformatowanych danych wyjściowych.The following example uses the alignment and formatString arguments to produce formatted output.

using namespace System;

void main()
{
   // Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
   array<Tuple<String^, DateTime, int, DateTime, int>^>^ cities = gcnew array<Tuple<String^, DateTime, int, DateTime, int>^> 
         { gcnew Tuple<String^, DateTime, int, DateTime, int>("Los Angeles", DateTime(1940, 1, 1), 1504277, 
                        DateTime(1950, 1, 1), 1970358),
         gcnew Tuple<String^, DateTime, int, DateTime, int>("New York", DateTime(1940, 1, 1), 7454995, 
                        DateTime(1950, 1, 1), 7891957),  
         gcnew Tuple<String^, DateTime, int, DateTime, int>("Chicago", DateTime(1940, 1, 1), 3396808, 
                        DateTime(1950, 1, 1), 3620962),  
         gcnew Tuple<String^, DateTime, int, DateTime, int>("Detroit", DateTime(1940, 1, 1), 1623452, 
                        DateTime(1950, 1, 1), 1849568) };

   // Display header
   String^ header = String::Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                                   "City", "Year", "Population", "Change (%)");
   Console::WriteLine(header);
   String^ output;      
   for each (Tuple<String^, DateTime, int, DateTime, int>^ city in cities) {
      output = String::Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                              city->Item1, city->Item2, city->Item3, city->Item4, city->Item5,
                              (city->Item5 - city->Item3)/ (double)city->Item3);
      Console::WriteLine(output);
   }
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//    
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %
// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Tuple<string, DateTime, int, DateTime, int>[] cities = 
    { Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277, 
                   new DateTime(1950, 1, 1), 1970358),
      Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995, 
                   new DateTime(1950, 1, 1), 7891957),  
      Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808, 
                   new DateTime(1950, 1, 1), 3620962),  
      Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452, 
                   new DateTime(1950, 1, 1), 1849568) };

// Display header
var header = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                              "City", "Year", "Population", "Change (%)");
Console.WriteLine(header);
foreach (var city in cities) {
   var output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                          city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                          (city.Item5 - city.Item3)/ (double)city.Item3);
   Console.WriteLine(output);
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//  
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %
Module Example
   Public Sub Main()
      ' Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
      Dim cities()  = _
          { Tuple.Create("Los Angeles", #1/1/1940#, 1504277, #1/1/1950#, 1970358),
            Tuple.Create("New York", #1/1/1940#, 7454995, #1/1/1950#, 7891957),  
            Tuple.Create("Chicago", #1/1/1940#, 3396808, #1/1/1950#, 3620962),  
            Tuple.Create("Detroit", #1/1/1940#, 1623452, #1/1/1950#, 1849568) }

      ' Display header
      Dim header As String = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}",
                                           "City", "Year", "Population", "Change (%)")
      Console.WriteLine(header)
      Console.WriteLine()
      For Each city In cities
         Dim output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                                city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                                (city.Item5 - city.Item3)/city.Item3)
         Console.WriteLine(output)
      Next
   End Sub
End Module
' The example displays the following output:
'    City            Year  Population    Year  Population    Change (%)
'    
'    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
'    New York        1940   7,454,995    1950   7,891,957         5.9 %
'    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
'    Detroit         1940   1,623,452    1950   1,849,568        13.9 %

Sposób formatowania argumentówHow arguments are formatted

Elementy formatu są przetwarzane sekwencyjnie od początku ciągu.Format items are processed sequentially from the beginning of the string. Każdy element formatu ma indeks, który odnosi się do obiektu na liście argumentów metody.Each format item has an index that corresponds to an object in the method's argument list. Metoda Format Pobiera argument i dziedziczy jego reprezentację w postaci ciągu w następujący sposób:The Format method retrieves the argument and derives its string representation as follows:

Przykład, który przechwytuje wywołania metody ICustomFormatter.Format i pozwala zobaczyć, jakie informacje Metoda Format przekazuje do metody formatowania dla każdego elementu formatu w ciągu formatu złożonego, zobacz przykład: dostawca przechwycenia i program formatujący cyfry rzymskie.For an example that intercepts calls to the ICustomFormatter.Format method and allows you to see what information the Format method passes to a formatting method for each format item in a composite format string, see Example: An intercept provider and Roman numeral formatter.

Aby uzyskać więcej informacji, zobacz sekcję kolejność przetwarzania w artykule dotyczącym formatowania złożonego .For more information, see the Processing Order section in the Composite Formatting article.

Elementy formatu o tym samym indeksieFormat items that have the same index

Metoda Format zgłasza wyjątek FormatException, jeśli indeks elementu indeksu jest większy lub równy liczbie argumentów na liście argumentów.The Format method throws a FormatException exception if the index of an index item is greater than or equal to the number of arguments in the argument list. Jednak format może zawierać więcej elementów formatu niż istnieją argumenty, tak długo, jak wiele elementów formatu ma ten sam indeks.However, format can include more format items than there are arguments, as long as multiple format items have the same index. W wywołaniu metody Format(String, Object) w poniższym przykładzie lista argumentów ma jeden argument, ale ciąg formatu zawiera dwa elementy formatu: jeden wyświetla wartość dziesiętną liczby, a druga wyświetla wartość szesnastkową.In the call to the Format(String, Object) method in following example, the argument list has a single argument, but the format string includes two format items: one displays the decimal value of a number, and the other displays its hexadecimal value.

short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
Console.WriteLine("{0,10}  {1,10}\n", "Decimal", "Hex");
foreach (short value in values)
{
   string formatString = String.Format("{0,10:G}: {0,10:X}", value);
   Console.WriteLine(formatString);
}   
// The example displays the following output:
//       Decimal         Hex
//    
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF
Module Example
   Public Sub Main()
      Dim values() As Short = { Int16.MinValue, -27, 0, 1042, Int16.MaxValue }
      Console.WriteLine("{0,10}  {1,10}", "Decimal", "Hex")
      Console.WriteLine()
      For Each value As Short In values
         Dim formatString As String = String.Format("{0,10:G}: {0,10:X}", value)
         Console.WriteLine(formatString)
      Next        
   End Sub
End Module
' The example displays the following output:
'       Decimal         Hex
'    
'        -32768:       8000
'           -27:       FFE5
'             0:          0
'          1042:        412
'         32767:       7FFF

Formatowanie i kulturaFormatting and culture

Ogólnie rzecz biorąc, obiekty na liście argumentów są konwertowane na ich reprezentacje ciągów przy użyciu Konwencji bieżącej kultury, które są zwracane przez właściwość CultureInfo.CurrentCulture.Generally, objects in the argument list are converted to their string representations by using the conventions of the current culture, which is returned by the CultureInfo.CurrentCulture property. Możesz kontrolować to zachowanie, wywołując jeden z przeciążeń Format, które zawierają parametr provider.You can control this behavior by calling one of the overloads of Format that includes a provider parameter. provider parametr jest implementacją IFormatProvider, która dostarcza niestandardowe i specyficzne dla kultury informacje o formatowaniu, które są używane do umiarkowanego procesu formatowania.The provider parameter is an IFormatProvider implementation that supplies custom and culture-specific formatting information that is used to moderate the formatting process.

Interfejs IFormatProvider ma pojedynczy element członkowski GetFormat, który jest odpowiedzialny za zwracanie obiektu, który zawiera informacje o formatowaniu.The IFormatProvider interface has a single member, GetFormat, which is responsible for returning the object that provides formatting information. Platforma .NET ma trzy implementacje IFormatProvider, które zapewniają formatowanie specyficzne dla kultury:.NET has three IFormatProvider implementations that provide culture-specific formatting:

Niestandardowe formatowanie operacjiCustom formatting operations

Można również wywołać dowolne przeciążenia metody Format, które mają parametr provider typu IFormatProvider do wykonywania niestandardowych operacji formatowania.You can also call the any of the overloads of the Format method that have a provider parameter of type IFormatProvider to perform custom formatting operations. Na przykład można sformatować liczbę całkowitą jako numer identyfikacyjny lub numer telefonu.For example, you could format an integer as an identification number or as a telephone number. Aby można było zastosować niestandardowe formatowanie, argument provider musi implementować zarówno interfejs IFormatProvider, jak i ICustomFormatter.To perform custom formatting, your provider argument must implement both the IFormatProvider and ICustomFormatter interfaces. Gdy w metodzie Format jest przenoszona implementacja ICustomFormatter jako argument provider, Metoda Format wywoła swoją IFormatProvider.GetFormat implementację i żąda obiektu typu ICustomFormatter.When the Format method is passed an ICustomFormatter implementation as the provider argument, the Format method calls its IFormatProvider.GetFormat implementation and requests an object of type ICustomFormatter. Następnie wywołuje metodę Format zwróconego obiektu ICustomFormatter, aby sformatować każdy element formatu do ciągu złożonego.It then calls the returned ICustomFormatter object's Format method to format each format item in the composite string passed to it.

Aby uzyskać więcej informacji na temat udostępniania niestandardowych rozwiązań formatowania, zobacz How to: define and use Custom format numeric Providers and ICustomFormatter.For more information about providing custom formatting solutions, see How to: Define and Use Custom Numeric Format Providers and ICustomFormatter. Aby zapoznać się z przykładem, który konwertuje liczby całkowite na sformatowane wartości niestandardowe, zobacz przykład: niestandardowa Operacja formatowania.For an example that converts integers to formatted custom numbers, see Example: A custom formatting operation. Przykład, który konwertuje bajty bez znaku na cyfry rzymskie, zobacz przykład: dostawca przechwycenia i program formatujący cyfry rzymskie.For an example that converts unsigned bytes to Roman numerals, see Example: An intercept provider and Roman numeral formatter.

Przykład: niestandardowa Operacja formatowaniaExample: A custom formatting operation

W tym przykładzie zdefiniowano dostawcę formatu, który formatuje wartość całkowitą jako numer konta klienta w postaci x-XXXXX-XX.This example defines a format provider that formats an integer value as a customer account number in the form x-xxxxx-xx.

using namespace System;

ref class CustomerFormatter : IFormatProvider, ICustomFormatter
{
public:
   virtual Object^ GetFormat(Type^ formatType) 
   {
      if (formatType == ICustomFormatter::typeid)        
         return this; 
      else 
         return nullptr; 
   }
   
   virtual String^ Format(String^ format, 
                   Object^ arg, 
                   IFormatProvider^ formatProvider) 
   {                       
      if (! this->Equals(formatProvider))
      {
         return nullptr;
      }
      else
      {
         if (String::IsNullOrEmpty(format)) 
            format = "G";
         
         String^ customerString = arg->ToString();
         if (customerString->Length < 8)
            customerString = customerString->PadLeft(8, '0');
         
         format = format->ToUpper();
         if (format == L"G") 
               return customerString->Substring(0, 1) + "-" +
                                     customerString->Substring(1, 5) + "-" +
                                     customerString->Substring(6);
         else if (format == L"S")                          
               return customerString->Substring(0, 1) + "/" +
                                     customerString->Substring(1, 5) + "/" +
                                     customerString->Substring(6);
         else if (format == L"P")
               return customerString->Substring(0, 1) + "." +
                                     customerString->Substring(1, 5) + "." +
                                     customerString->Substring(6);
         else
               throw gcnew FormatException( 
                         String::Format("The '{0}' format specifier is not supported.", format));
         }
    }   
};

void main()
{
   int acctNumber = 79203159;
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:G}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:S}", acctNumber));
   Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:P}", acctNumber));
   try {
      Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:X}", acctNumber));
   }
   catch (FormatException^ e) {
      Console::WriteLine(e->Message);
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.
using System;

public class TestFormatter
{
   public static void Main()
   {
      int acctNumber = 79203159;
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:G}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:S}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:P}", acctNumber));
      try {
         Console.WriteLine(String.Format(new CustomerFormatter(), "{0:X}", acctNumber));
      }
      catch (FormatException e) {
         Console.WriteLine(e.Message);
      }
   }
}

public class CustomerFormatter : 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 (! this.Equals(formatProvider))
      {
         return null;
      }
      else
      {
         if (String.IsNullOrEmpty(format)) 
            format = "G";
         
         string customerString = arg.ToString();
         if (customerString.Length < 8)
            customerString = customerString.PadLeft(8, '0');
         
         format = format.ToUpper();
         switch (format)
         {
            case "G":
               return customerString.Substring(0, 1) + "-" +
                                     customerString.Substring(1, 5) + "-" +
                                     customerString.Substring(6);
            case "S":                          
               return customerString.Substring(0, 1) + "/" +
                                     customerString.Substring(1, 5) + "/" +
                                     customerString.Substring(6);
            case "P":                          
               return customerString.Substring(0, 1) + "." +
                                     customerString.Substring(1, 5) + "." +
                                     customerString.Substring(6);
            default:
               throw new FormatException( 
                         String.Format("The '{0}' format specifier is not supported.", format));
         }
      }   
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.
Module TestFormatter
   Public Sub Main()
      Dim acctNumber As Integer = 79203159
      Console.WriteLine(String.Format(New CustomerFormatter, "{0}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:G}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:S}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:P}", acctNumber))
      Try
         Console.WriteLine(String.Format(New CustomerFormatter, "{0:X}", acctNumber))
      Catch e As FormatException
         Console.WriteLine(e.Message)
      End Try   
   End Sub
End Module

Public Class CustomerFormatter : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(type As Type) As Object  _
                   Implements IFormatProvider.GetFormat
      If type 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 Me.Equals(formatProvider) Then
         Return Nothing
      Else
         If String.IsNullOrEmpty(fmt) Then fmt = "G"
         
         Dim customerString As String = arg.ToString()
         if customerString.Length < 8 Then _
            customerString = customerString.PadLeft(8, "0"c)
         
         Select Case fmt
            Case "G"
               Return customerString.Substring(0, 1) & "-" & _
                                     customerString.Substring(1, 5) & "-" & _
                                     customerString.Substring(6)
            Case "S"                         
               Return customerString.Substring(0, 1) & "/" & _
                                     customerString.Substring(1, 5) & "/" & _
                                     customerString.Substring(6)
            Case "P"
               Return customerString.Substring(0, 1) & "." & _
                                     customerString.Substring(1, 5) & "." & _
                                     customerString.Substring(6)
            Case Else
               Throw New FormatException( _
                         String.Format("The '{0}' format specifier is not supported.", fmt))
         End Select                                                     
      End If   
   End Function
End Class
' The example displays the following output:
'       7-92031-59
'       7-92031-59
'       7/92031/59
'       7.92031.59
'       The 'X' format specifier is not supported.

Przykład: dostawca przechwycenia i program formatujący cyfry rzymskieExample: An intercept provider and Roman numeral formatter

W tym przykładzie zdefiniowano niestandardowego dostawcę formatu, który implementuje interfejsy ICustomFormatter i IFormatProvider, aby wykonać dwie czynności:This example defines a custom format provider that implements the ICustomFormatter and IFormatProvider interfaces to do two things:

  • Wyświetla parametry przesłane do ICustomFormatter.Format implementacji.It displays the parameters passed to its ICustomFormatter.Format implementation. Dzięki temu możemy zobaczyć, jakie parametry Metoda Format(IFormatProvider, String, Object[]) przechodzi do implementacji formatowania niestandardowego dla każdego obiektu, który próbuje sformatować.This enables us to see what parameters the Format(IFormatProvider, String, Object[]) method is passing to the custom formatting implementation for each object that it tries to format. Może to być przydatne w przypadku debugowania aplikacji.This can be useful when you're debugging your application.

  • Jeśli obiekt, który ma być sformatowany jest wartością bajtu bez znaku, która ma zostać sformatowana przy użyciu standardowego ciągu formatu "R", niestandardowy program formatujący formatuje wartość liczbową jako cyfrę rzymską.If the object to be formatted is an unsigned byte value that is to be formatted by using the "R" standard format string, the custom formatter formats the numeric value as a Roman numeral.

using namespace System;
using namespace System::Globalization;

ref class InterceptProvider : IFormatProvider, ICustomFormatter
{
public:
   virtual Object^ GetFormat(Type^ formatType)
   {
      if (formatType == ICustomFormatter::typeid)   
         return this;
      else
         return nullptr;
   }
   
   virtual String^ Format(String^ format, Object^ obj, IFormatProvider^ provider) 
   {
      // Display information about method call.
      String^ formatString = format != nullptr ? format : "<null>";
      Console::WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, obj != nullptr ? obj : "<null>", formatString);
                        
      if (obj == nullptr) return String::Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj->GetType() == Byte::typeid && formatString->ToUpper()->Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String^ returnString = String::Empty;

         // Get the hundreds digit(s)
         result = Math::DivRem(value, 100, remainder);
         if (result > 0)  
            returnString = gcnew String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math::DivRem(value, 50, remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math::DivRem(value, 10, remainder);
         if (result > 0)
            returnString += gcnew String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math::DivRem(value, 5, remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += gcnew String('I', remainder);
         
         // Check whether we have too many X characters.
         int pos = returnString->IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString->IndexOf("L"); 
            if ((xPos >= 0) & (xPos == pos - 1))
               returnString = returnString->Replace("LXXXX", "XC");
            else
               returnString = returnString->Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString->IndexOf("IIII");
         if (pos >= 0)
            if (returnString->IndexOf("V") >= 0)
               returnString = returnString->Replace("VIIII", "IX");
            else
               returnString = returnString->Replace("IIII", "IV");    

         return returnString; 
      }   

      // Use default for all other formatting.
      if (obj->GetType() == IFormattable::typeid)
         return ((IFormattable^) obj)->ToString(format, CultureInfo::CurrentCulture);
      else
         return obj->ToString();
   }
};

void main()
{
   int n = 10;
   double value = 16.935;
   DateTime day = DateTime::Now;
   InterceptProvider^ provider = gcnew InterceptProvider();
   Console::WriteLine(String::Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
   Console::WriteLine(String::Format(provider, "{0}: {1:F}\n", "Today: ", 
                                    (DayOfWeek) DateTime::Now.DayOfWeek));
   Console::WriteLine(String::Format(provider, "{0:X}, {1}, {2}\n", 
                                    (Byte) 2, (Byte) 12, (Byte) 199));
   Console::WriteLine(String::Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                    (Byte) 2, (Byte) 12, (Byte) 199));
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX
using System;
using System.Globalization;

public class InterceptProvider : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public string Format(String format, Object obj, IFormatProvider provider) 
   {
      // Display information about method call.
      string formatString = format ?? "<null>";
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider.GetType().Name, obj ?? "<null>", formatString);
                        
      if (obj == null) return String.Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj is Byte && formatString.ToUpper().Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String returnString = String.Empty;

         // Get the hundreds digit(s)
         result = Math.DivRem(value, 100, out remainder);
         if (result > 0)  
            returnString = new String('C', result);
         value = (Byte) remainder;
         // Get the 50s digit
         result = Math.DivRem(value, 50, out remainder);
         if (result == 1)
            returnString += "L";
         value = (Byte) remainder;
         // Get the tens digit.
         result = Math.DivRem(value, 10, out remainder);
         if (result > 0)
            returnString += new String('X', result);
         value = (Byte) remainder; 
         // Get the fives digit.
         result = Math.DivRem(value, 5, out remainder);
         if (result > 0)
            returnString += "V";
         value = (Byte) remainder;
         // Add the ones digit.
         if (remainder > 0) 
            returnString += new String('I', remainder);
         
         // Check whether we have too many X characters.
         int pos = returnString.IndexOf("XXXX");
         if (pos >= 0) {
            int xPos = returnString.IndexOf("L"); 
            if (xPos >= 0 & xPos == pos - 1)
               returnString = returnString.Replace("LXXXX", "XC");
            else
               returnString = returnString.Replace("XXXX", "XL");   
         }
         // Check whether we have too many I characters
         pos = returnString.IndexOf("IIII");
         if (pos >= 0)
            if (returnString.IndexOf("V") >= 0)
               returnString = returnString.Replace("VIIII", "IX");
            else
               returnString = returnString.Replace("IIII", "IV");    

         return returnString; 
      }   

      // Use default for all other formatting.
      if (obj is IFormattable)
         return ((IFormattable) obj).ToString(format, CultureInfo.CurrentCulture);
      else
         return obj.ToString();
   }
}

public class Example
{
   public static void Main()
   {
      int n = 10;
      double value = 16.935;
      DateTime day = DateTime.Now;
      InterceptProvider provider = new InterceptProvider();
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
      Console.WriteLine(String.Format(provider, "{0}: {1:F}\n", "Today: ", 
                                      (DayOfWeek) DateTime.Now.DayOfWeek));
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
   }
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX
Imports System.Globalization

Public Class InterceptProvider : 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, obj As Object, provider As IFormatProvider) As String _
         Implements ICustomFormatter.Format

      Dim formatString As String = If(fmt IsNot Nothing, fmt, "<null>")
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, If(obj IsNot Nothing, obj, "<null>"), formatString)

      If obj Is Nothing Then Return String.Empty
            
      ' If this is a byte and the "R" format string, format it with Roman numerals.
      If TypeOf(obj) Is Byte AndAlso formatString.ToUpper.Equals("R") Then
         Dim value As Byte = CByte(obj)
         Dim remainder As Integer
         Dim result As Integer
         Dim returnString As String = String.Empty

         ' Get the hundreds digit(s)
         result = Math.DivRem(value, 100, remainder)
         If result > 0 Then returnString = New String("C"c, result)
         value = CByte(remainder)
         ' Get the 50s digit
         result = Math.DivRem(value, 50, remainder)
         If result = 1 Then returnString += "L"
         value = CByte(remainder)
         ' Get the tens digit.
         result = Math.DivRem(value, 10, remainder)
         If result > 0 Then returnString += New String("X"c, result)
         value = CByte(remainder) 
         ' Get the fives digit.
         result = Math.DivRem(value, 5, remainder)
         If result > 0 Then returnString += "V"
         value = CByte(remainder)
         ' Add the ones digit.
         If remainder > 0 Then returnString += New String("I"c, remainder)
         
         ' Check whether we have too many X characters.
         Dim pos As Integer = returnString.IndexOf("XXXX")
         If pos >= 0 Then
            Dim xPos As Integer = returnString.IndexOf("L") 
            If xPos >= 0 And xPos = pos - 1 Then
               returnString = returnString.Replace("LXXXX", "XC")
            Else
               returnString = returnString.Replace("XXXX", "XL")   
            End If         
         End If
         ' Check whether we have too many I characters
         pos = returnString.IndexOf("IIII")
         If pos >= 0 Then
            If returnString.IndexOf("V") >= 0 Then
               returnString = returnString.Replace("VIIII", "IX")
            Else
               returnString = returnString.Replace("IIII", "IV")    
            End If
         End If
         Return returnString 
      End If   

      ' Use default for all other formatting.
      If obj Is GetType(IFormattable)
         Return CType(obj, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
      Else
         Return obj.ToString()
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim n As Integer = 10
      Dim value As Double = 16.935
      Dim day As DateTime = Date.Now
      Dim provider As New InterceptProvider()
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}", n, value, day))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0}: {1:F}", "Today", 
                                      CType(Date.Now.DayOfWeek, DayOfWeek)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      CByte(2), CByte(12), CByte(199)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}", 
                                      CByte(2), CByte(12), CByte(199)))
   End Sub
End Module
' The example displays the following output:
'    Provider: InterceptProvider, Object: 10, Format String: N0
'    Provider: InterceptProvider, Object: 16.935, Format String: C2
'    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
'    10: $16.94 on 1/31/2013
'    
'    Provider: InterceptProvider, Object: Today: , Format String: <null>
'    Provider: InterceptProvider, Object: Thursday, Format String: F
'    Today: : Thursday
'    
'    Provider: InterceptProvider, Object: 2, Format String: X
'    Provider: InterceptProvider, Object: 12, Format String: <null>
'    Provider: InterceptProvider, Object: 199, Format String: <null>
'    2, 12, 199
'    
'    Provider: InterceptProvider, Object: 2, Format String: R
'    Provider: InterceptProvider, Object: 12, Format String: R
'    Provider: InterceptProvider, Object: 199, Format String: R
'    II, XII, CXCIX

Ciąg. format Q & AString.Format Q & A

Dlaczego zalecane jest Interpolacja ciągów dla wywołań metody String.Format?Why do you recommend string interpolation over calls to the String.Format method?

Interpolacja ciągów:String interpolation is:

  • Bardziej elastyczne.More flexible. Może być używana w dowolnym ciągu bez konieczności wywołania metody, która obsługuje formatowanie złożone.It can be used in any string without requiring a call to a method that supports composite formatting. W przeciwnym razie należy wywołać metodę Format lub inną metodę, która obsługuje formatowanie złożone, takie jak Console.WriteLine lub StringBuilder.AppendFormat.Otherwise, you have to call the Format method or another method that supports composite formatting, such as Console.WriteLine or StringBuilder.AppendFormat.

  • Bardziej czytelne.More readable. Ponieważ wyrażenie, które ma zostać wstawione do ciągu, pojawia się w wyrażeniu interpolowanym, a nie na liście argumentów, interpolowane ciągi są znacznie łatwiejsze do kodu i odczytywania.Because the expression to insert into a string appears in the interpolated expression rather than in a argument list, interpolated strings are far easier to code and to read. Ze względu na większą czytelność, interpolowane ciągi mogą zastąpić nie tylko wywołania metod formatu złożonego, ale mogą być również używane w operacjach łączenia ciągów, aby generować bardziej zwięzły, wyraźniejszy kod.Because of their greater readability, interpolated strings can replace not only calls to composite format methods, but they can also be used in string concatenation operations to produce more concise, clearer code.

Porównanie następujących dwóch przykładów kodu ilustruje najwyższą liczbę interpolowanych ciągów na łączenie ciągów i wywołania metod formatowania złożonego.A comparison of the following two code examples illustrates the superiority of interpolated strings over string concatenation and calls to composite formatting methods. Użycie wielu operacji łączenia ciągów w poniższym przykładzie daje pełny i trudny do odczytu kod.The use of multiple string concatenation operations in the following example produces verbose and hard-to-read code.

  string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
  string output = names[0] + ", " + names[1] + ", " + names[2] + ", " + 
                  names[3] + ", " + names[4] + ", " + names[5] + ", " + 
                  names[6];  

  output += "\n";  
  var date = DateTime.Now;
  output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", 
                          date, date.DayOfWeek);
  Console.WriteLine(output);                           
  // The example displays the following output:
  //     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
  //     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Module Example
   Public Sub Main()
      Dim names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" }
      Dim output = names(0) + ", " + names(1) + ", " + names(2) + ", " + 
                   names(3) + ", " + names(4) + ", " + names(5) + ", " + 
                   names(6)  
    
      output += vbCrLf  
      Dim dat = DateTime.Now
      output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", 
                              dat, dat.DayOfWeek)
      Console.WriteLine(output)                           
   End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.


Natomiast użycie ciągów interpolowanych w poniższym przykładzie daje dużo wyraźniejszy, bardziej zwięzły kod niż instrukcja łączenia ciągów i wywołanie metody Format w poprzednim przykładzie.In contrast, the use of interpolated strings in the following example produce much clearer, more concise code than the string concatenation statement and the call to the Format method in the previous example.

  string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
  string output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, " + 
                  $"{names[5]}, {names[6]}";  

  var date = DateTime.Now;
  output += $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}.";
  Console.WriteLine(output);                           
  // The example displays the following output:
  //     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
  //     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Module Example
   Public Sub Main()
      Dim names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" }
      Dim output = $"{names(0)}, {names(1)}, {names(2)}, {names(3)}, {names(4)}, " + 
                   $"{names(5)}, {names(6)}"  
    
      Dim dat = DateTime.Now
      output += $"{vbCrLf}It is {dat:t} on {dat:d}. The day of the week is {dat.DayOfWeek}." 
      Console.WriteLine(output)                           
   End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.


Gdzie mogę znaleźć listę wstępnie zdefiniowanych ciągów formatu, które mogą być używane z elementami formatowania?Where can I find a list of the predefined format strings that can be used with format items?

Jak mogę kontrolować wyrównanie ciągów wynikowych, które zastępują elementy formatu?How do I control the alignment of the result strings that replace format items?

Ogólna składnia elementu format jest następująca:The general syntax of a format item is:

{index[,alignment][: formatString]}  

gdzie wyrównania jest ze znakiem liczby całkowitej, która definiuje szerokość pola.where alignment is a signed integer that defines the field width. Jeśli ta wartość jest ujemna, tekst w polu jest wyrównany do lewej.If this value is negative, text in the field is left-aligned. Jeśli jest dodatnia, tekst jest wyrównany do prawej.If it is positive, text is right-aligned.

Jak mogę kontrolować liczbę cyfr po separatorze dziesiętnym?How do I control the number of digits after the decimal separator?

Wszystkie ciągi standardowego formatu liczbowego z wyjątkiem "D" (które są używane tylko z liczbami całkowitymi), "G", "R" i "X" zezwalają na specyfikator dokładności, który definiuje liczbę cyfr dziesiętnych w ciągu wynikowym.All standard numeric format strings except "D" (which is used with integers only), "G", "R", and "X" allow a precision specifier that defines the number of decimal digits in the result string. W poniższym przykładzie użyto standardowych ciągów formatu liczbowego do kontrolowania liczby cyfr dziesiętnych w ciągu wynikowym.The following example uses standard numeric format strings to control the number of decimal digits in the result string.

object[] values = { 1603, 1794.68235, 15436.14 };
string result;
foreach (var value in values) {
   result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}\n",
                          Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
   Console.WriteLine(result);
}                           
// The example displays output like the following:
//       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
//    
//       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
//    
//      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %
Module Example
   Public Sub Main()
      Dim values() As Object = { 1603, 1794.68235, 15436.14 }
      Dim result As String
      For Each value In values
         result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}",
                                value, CDbl(value) / 10000)
         Console.WriteLine(result) 
         Console.WriteLine()
      Next                             
   End Sub
End Module
' The example displays the following output:
'       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
'    
'       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
'    
'      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

Jeśli używasz niestandardowego ciągu formatu liczbowego, użyj specyfikatora formatu "0", aby kontrolować liczbę cyfr dziesiętnych w ciągu wynikowym, jak pokazano w poniższym przykładzie.If you're using a custom numeric format string, use the "0" format specifier to control the number of decimal digits in the result string, as the following example shows.

decimal value = 16309.5436m;
string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", 
                              value);
Console.WriteLine(result);
// The example displays the following output:
//        16309.54360    16,309.54    16309.544
Module Example
   Public Sub Main()
      Dim value As Decimal = 16309.5436d
      Dim result As String = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", 
                                           value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'    16309.54360    16,309.54    16309.544

Jak mogę kontrolować liczbę cyfr całkowitych?How do I control the number of integral digits?

Domyślnie operacje formatowania wyświetlają tylko niezerowe cyfry całkowite.By default, formatting operations only display non-zero integral digits. Jeśli są formatowane liczby całkowite, można użyć specyfikatora dokładności z ciągami formatu standardowego "D" i "X", aby kontrolować liczbę cyfr.If you are formatting integers, you can use a precision specifier with the "D" and "X" standard format strings to control the number of digits.

int value = 1326;
string result = String.Format("{0,10:D6} {0,10:X8}", value);
Console.WriteLine(result);
// The example displays the following output:
//     001326   0000052E
Module Example
   Public Sub Main()
      Dim value As Integer = 1326
      Dim result As String = String.Format("{0,10:D6} {0,10:X8}", value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'       001326   0000052E

Można uzupełnić liczbę całkowitą lub liczbową zmiennoprzecinkową zerami wiodącymi, aby utworzyć ciąg wynikowy z określoną liczbą cyfr całkowitych przy użyciu niestandardowego specyfikatora formatu liczbowego"0", jak pokazano w poniższym przykładzie.You can pad an integer or floating-point number with leading zeros to produce a result string with a specified number of integral digits by using the "0" custom numeric format specifier, as the following example shows.

int value = 16342;
string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", 
                              value);
Console.WriteLine(result);
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0
Module Example
   Public Sub Main()
      Dim value As Integer = 16342
      Dim result As String = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", 
                                           value)
      Console.WriteLine(result)
   End Sub
End Module
' The example displays the following output:
'           00016342       00016342.000    0,000,016,342.0

Ile elementów można uwzględnić na liście Format?How many items can I include in the format list?

Nie ma praktycznego limitu.There is no practical limit. Drugi parametr metody Format(IFormatProvider, String, Object[]) jest oznakowany atrybutem ParamArrayAttribute, który umożliwia dołączenie listy rozdzielanej lub tablicy obiektów jako listy formatów.The second parameter of the Format(IFormatProvider, String, Object[]) method is tagged with the ParamArrayAttribute attribute, which allows you to include either a delimited list or an object array as your format list.

Jak mogę uwzględnić literały klamrowe ("{" i "}") w ciągu wynikowym?How do I include literal braces ("{" and "}") in the result string?

Na przykład jak zapobiec występowaniu wyjątku FormatException przez następujące wywołanie metody?For example, how do you prevent the following method call from throwing a FormatException exception?

result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                       nOpen, nClose);
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                       nOpen, nClose)

Pojedynczy nawias otwierający lub zamykający jest zawsze interpretowany jako początek lub koniec elementu formatu.A single opening or closing brace is always interpreted as the beginning or end of a format item. Aby można było interpretować dosłownie, musi to być znak ucieczki.To be interpreted literally, it must be escaped. Nawias klamrowy zostanie dodany przez dodanie kolejnego nawiasu klamrowego ("{{" i "}}" zamiast "{" i "}"), jak w poniższym wywołaniu metody:You escape a brace by adding another brace ("{{" and "}}" instead of "{" and "}"), as in the following method call:

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose);
Console.WriteLine(result);
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose)

Jednak nawet nawiasy klamrowe są łatwo interpretowane nieprawidłowo.However, even escaped braces are easily misinterpreted. Zalecamy dołączenie nawiasów klamrowych na liście Format i użycie elementów formatu do wstawienia ich w ciągu wynikowym, jak pokazano w poniższym przykładzie.We recommend that you include braces in the format list and use format items to insert them in the result string, as the following example shows.

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                       nOpen, "{", nClose, "}");
Console.WriteLine(result);
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                       nOpen, "{", nClose, "}")

Dlaczego moje wywołanie metody String. Format powoduje zgłoszenie FormatException?Why does my call to the String.Format method throw a FormatException?

Najczęstszym powodem wyjątku jest to, że indeks elementu formatu nie odpowiada obiektowi na liście Format.The most common cause of the exception is that the index of a format item doesn't correspond to an object in the format list. Zazwyczaj oznacza to, że liczba indeksów elementów formatowania jest niepograna lub zapomniano dołączyć obiekt z listy format.Usually this indicates that you've misnumbered the indexes of format items or you've forgotten to include an object in the format list. Próba dołączenia pustego znaku w nawiasie klamrowym lub w prawo powoduje wyrzucanie FormatException.Attempting to include an unescaped left or right brace character also throws a FormatException. Czasami wyjątek jest wynikiem literówki; na przykład typowym błędem jest błąd "[" (lewy nawias) zamiast "{" (lewy nawias klamrowy).Occasionally, the exception is the result of a typo; for example, a typical mistake is to mistype "[" (the left bracket) instead of "{" (the left brace).

Jeśli format (System. IFormatProvider, system. String, system. Object []) obsługuje tablice parametrów, dlaczego mój kod zgłasza wyjątek, gdy używam tablicy?If the Format(System.IFormatProvider,System.String,System.Object[]) method supports parameter arrays, why does my code throw an exception when I use an array?

Na przykład poniższy kod zgłasza wyjątek FormatException:For example, the following code throws a FormatException exception:

Random rnd = new Random();
int[]  numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++) {
   int number = rnd.Next(1001);
   numbers[ctr] = number;
   total += number;
}   
numbers[3] = total;
Console.WriteLine("{0} + {1} + {2} = {3}", numbers);   
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim numbers(3) As Integer
      Dim total As Integer = 0
      For ctr = 0 To 2
         Dim number As Integer = rnd.Next(1001)
         numbers(ctr) = number
         total += number
      Next
      numbers(3) = total
      Console.WriteLine("{0} + {1} + {2} = {3}", numbers)   
   End Sub
End Module

Jest to problem z rozwiązaniem przeciążenia kompilatora.This is a problem of compiler overload resolution. Ponieważ kompilator nie może skonwertować tablicę liczb całkowitych na tablicę obiektów, traktuje tablicę liczb całkowitych jako pojedynczy argument, więc wywołuje metodę Format(String, Object).Because the compiler cannot convert an array of integers to an object array, it treats the integer array as a single argument, so it calls the Format(String, Object) method. Wyjątek jest zgłaszany, ponieważ istnieją cztery elementy formatujące, ale tylko jeden element na liście Format.The exception is thrown because there are four format items but only a single item in the format list.

Ponieważ ani nie Visual Basic C# ani nie można skonwertować tablicy typu Integer na tablicę obiektów, należy wykonać konwersję samodzielnie przed wywołaniem metody Format(String, Object[]).Because neither Visual Basic nor C# can convert an integer array to an object array, you have to perform the conversion yourself before calling the Format(String, Object[]) method. Poniższy przykład zawiera jedną implementację.The following example provides one implementation.

Random rnd = new Random();
int[]  numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++) {
   int number = rnd.Next(1001);
   numbers[ctr] = number;
   total += number;
}   
numbers[3] = total;
object[] values = new object[numbers.Length];
numbers.CopyTo(values, 0);
Console.WriteLine("{0} + {1} + {2} = {3}", values);   
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim numbers(3) As Integer
      Dim total As Integer = 0
      For ctr = 0 To 2
         Dim number As Integer = rnd.Next(1001)
         numbers(ctr) = number
         total += number
      Next
      numbers(3) = total
      Dim values(numbers.Length - 1) As Object
      numbers.CopyTo(values, 0) 
      Console.WriteLine("{0} + {1} + {2} = {3}", values)   
   End Sub
End Module

Format(String, Object)

Zamienia jeden lub więcej elementów formatu ciągu na ciąg reprezentujący określony obiekt.Replaces one or more format items in a string with the string representation of a specified object.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0);
public static string Format (string format, object arg0);
static member Format : string * obj -> string
Public Shared Function Format (format As String, arg0 As Object) As String

Parametry

arg0
Object

Obiekt do sformatowania.The object to format.

Zwraca

Kopia format, w której każdy element formatu jest zastępowany ciągiem reprezentującym arg0.A copy of format in which any format items are replaced by the string representation of arg0.

Wyjątki

Parametr format ma wartość null.format is null.

Element formatu w format jest nieprawidłowy.The format item in format is invalid.

lub-or- Indeks elementu formatu nie jest równy zero.The index of a format item is not zero.

Uwagi

Ważne

Zamiast wywoływać metodę String.Format metody lub używając ciągów formatowania złożonego, możesz użyć ciągi interpolowane Jeśli język je obsługuje.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Ciąg interpolowany jest ciąg zawierający wyrażeń interpolowanych.An interpolated string is a string that contains interpolated expressions. Każde wyrażenie interpolowane jest rozwiązany wartość wyrażenia i uwzględnione w ciągu wynikowym, jeśli ciąg jest przypisany.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Aby uzyskać więcej informacji, zobacz Interpolacja ciągów (C# odwołania) i ciągi interpolowane (odwołanie w Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Ta metoda używa funkcji formatowania złożonego , aby przekonwertować wartość wyrażenia na jego reprezentację ciągu i osadzić tę reprezentację w ciągu.This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string.

Jednak podczas wywoływania String.Format metody, nie jest konieczne skoncentrować się na określonego przeciążenia, które ma zostać wywołana.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Zamiast tego należy wywołać metodę z ciąg formatu złożonego zawierającego jeden lub więcej elementów formatu.Instead, you can call the method with a composite format string that includes one or more format items. Przypisz każdy element formatu indeksu liczbowego; Pierwszy indeks zaczyna się od 0.You assign each format item a numeric index; the first index starts at 0. Oprócz ciąg początkowy wywołania metody powinna mieć dowolną liczbę dodatkowych argumentów, ponieważ zawiera ona wartości indeksu.In addition to the initial string, your method call should have as many additional arguments as it has index values. Na przykład ciąg, którego elementy formatu miały indeksy od 0 do 1 powinny mieć argumentów 2; jeden z indeksami 0 do 5 powinna mieć 6 argumentów.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Twój kompilator języka zostanie następnie rozpoznać wywołania metody do określonego przeciążenia String.Format metody.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Aby uzyskać bardziej szczegółowe dokumentacją dotyczącą korzystania z String.Format metody, zobacz rozpoczęcie korzystania z metody String.Format i która metoda zostanie wywołana?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Przykład: formatowanie pojedynczego argumentuExample: Formatting a single argument

W poniższym przykładzie zastosowano metodę Format(String, Object) do osadzenia wieku osoby w środku ciągu.The following example uses the Format(String, Object) method to embed an individual's age in the middle of a string.

using namespace System;

void main()
{
   DateTime birthdate = DateTime(1993, 7, 28);
   array<DateTime>^ dates = gcnew array<DateTime> { DateTime(1993, 8, 16), 
                                                    DateTime(1994, 7, 28), 
                                                    DateTime(2000, 10, 16), 
                                                    DateTime(2003, 7, 27), 
                                                    DateTime(2007, 5, 27) };

   for each (DateTime dateValue in dates)
   {
      TimeSpan interval = dateValue - birthdate;
      // Get the approximate number of years, without accounting for leap years.
      int years = ((int)interval.TotalDays) / 365;
      // See if adding the number of years exceeds dateValue.
      String^ output;
      if (birthdate.AddYears(years) <= dateValue) {
         output = String::Format("You are now {0} years old.", years);
         Console::WriteLine(output);
      }   
      else {
         output = String::Format("You are now {0} years old.", years - 1);
         Console::WriteLine(output);
      }      
   }
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.
DateTime birthdate = new DateTime(1993, 7, 28);
DateTime[] dates = { new DateTime(1993, 8, 16), 
                     new DateTime(1994, 7, 28), 
                     new DateTime(2000, 10, 16), 
                     new DateTime(2003, 7, 27), 
                     new DateTime(2007, 5, 27) };

foreach (DateTime dateValue in dates)
{
   TimeSpan interval = dateValue - birthdate;
   // Get the approximate number of years, without accounting for leap years.
   int years = ((int) interval.TotalDays) / 365;
   // See if adding the number of years exceeds dateValue.
   string output;
   if (birthdate.AddYears(years) <= dateValue) {
      output = String.Format("You are now {0} years old.", years);
      Console.WriteLine(output);
   }   
   else {
      output = String.Format("You are now {0} years old.", years - 1);
      Console.WriteLine(output);
   }      
}
// The example displays the following output:
//       You are now 0 years old.
//       You are now 1 years old.
//       You are now 7 years old.
//       You are now 9 years old.
//       You are now 13 years old.
Module Example
   Public Sub Main()
      Dim birthdate As Date = #7/28/1993#
      Dim dates() As Date = { #9/16/1993#, #7/28/1994#, #10/16/2000#, _
                              #7/27/2003#, #5/27/2007# }
      For Each dateValue As Date In dates
         Dim interval As TimeSpan = dateValue - birthdate
         ' Get the approximate number of years, without accounting for leap years.
         Dim years As Integer = CInt(interval.TotalDays) \ 365
         ' See if adding the number of years exceeds dateValue.
         Dim output As String
         If birthdate.AddYears(years) <= dateValue Then
            output = String.Format("You are now {0} years old.", years)
            Console.WriteLine(output)
         Else
            output = String.Format("You are now {0} years old.", years - 1)
            Console.WriteLine(output)   
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       You are now 0 years old.
'       You are now 1 years old.
'       You are now 7 years old.
'       You are now 9 years old.
'       You are now 13 years old.

Zobacz też

Format(String, Object[])

Zamienia element formatu w określonym ciągu na ciąg reprezentujący odpowiadający obiekt w określonej tablicy.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

public:
 static System::String ^ Format(System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (string format, params object[] args);
static member Format : string * obj[] -> string
Public Shared Function Format (format As String, ParamArray args As Object()) As String

Parametry

args
Object[]

Tablica obiektów zawiera zero lub więcej obiektów do sformatowania.An object array that contains zero or more objects to format.

Zwraca

Kopia format, w której elementy formatu zostały zastąpione przez ciąg reprezentujący odpowiednie obiekty w args.A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Wyjątki

Parametr format lub args ma wartość null.format or args is null.

format jest nieprawidłowy.format is invalid.

lub-or- Indeks elementu formatu jest mniejszy od zera lub jest większy lub równy długości tablicy args.The index of a format item is less than zero, or greater than or equal to the length of the args array.

Uwagi

Ważne

Zamiast wywoływać metodę String.Format metody lub używając ciągów formatowania złożonego, możesz użyć ciągi interpolowane Jeśli język je obsługuje.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Ciąg interpolowany jest ciąg zawierający wyrażeń interpolowanych.An interpolated string is a string that contains interpolated expressions. Każde wyrażenie interpolowane jest rozwiązany wartość wyrażenia i uwzględnione w ciągu wynikowym, jeśli ciąg jest przypisany.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Aby uzyskać więcej informacji, zobacz Interpolacja ciągów (C# odwołania) i ciągi interpolowane (odwołanie w Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Ta metoda używa funkcji formatowania złożonego , aby przekonwertować wartość czterech lub więcej wyrażeń na ich reprezentacje ciągów i osadzić te reprezentacje w ciągu.This method uses the composite formatting feature to convert the value of four or more expressions to their string representations and to embed those representations in a string. Ponieważ parametr args jest oznaczony atrybutem System.ParamArrayAttribute, można przekazać obiekty do metody jako pojedyncze argumenty lub jako tablicę Object.Since the args parameter is marked with the System.ParamArrayAttribute attribute, you can pass the objects to the method as individual arguments or as an Object array.

Jednak podczas wywoływania String.Format metody, nie jest konieczne skoncentrować się na określonego przeciążenia, które ma zostać wywołana.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Zamiast tego należy wywołać metodę z ciąg formatu złożonego zawierającego jeden lub więcej elementów formatu.Instead, you can call the method with a composite format string that includes one or more format items. Przypisz każdy element formatu indeksu liczbowego; Pierwszy indeks zaczyna się od 0.You assign each format item a numeric index; the first index starts at 0. Oprócz ciąg początkowy wywołania metody powinna mieć dowolną liczbę dodatkowych argumentów, ponieważ zawiera ona wartości indeksu.In addition to the initial string, your method call should have as many additional arguments as it has index values. Na przykład ciąg, którego elementy formatu miały indeksy od 0 do 1 powinny mieć argumentów 2; jeden z indeksami 0 do 5 powinna mieć 6 argumentów.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Twój kompilator języka zostanie następnie rozpoznać wywołania metody do określonego przeciążenia String.Format metody.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Aby uzyskać bardziej szczegółowe dokumentacją dotyczącą korzystania z String.Format metody, zobacz rozpoczęcie korzystania z metody String.Format i która metoda zostanie wywołana?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Przykład: formatowanie więcej niż trzech argumentówExample: Formatting more than three arguments

Ten przykład tworzy ciąg, który zawiera dane z wysoką i niską temperaturą w określonym dniu.This example creates a string that contains data on the high and low temperature on a particular date. Ciąg formatu złożonego ma pięć elementów formatu w C# przykładzie i sześć w przykładzie Visual Basic.The composite format string has five format items in the C# example and six in the Visual Basic example. Dwa elementy formatu definiują szerokość odpowiadającego ciągu wartości, a pierwszy element formatu zawiera również ciąg standardowego formatu daty i godziny.Two of the format items define the width of their corresponding value's string representation, and the first format item also includes a standard date and time format string.

using namespace System;

void main()
{
   DateTime date1 = DateTime(2009, 7, 1);
   TimeSpan hiTime = TimeSpan(14, 17, 32);
   Decimal hiTemp = (Decimal) 62.1; 
   TimeSpan loTime = TimeSpan(3, 16, 10);
   Decimal loTemp = (Decimal)54.8; 

   String^ result1 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                    date1, hiTime, hiTemp, loTime, loTemp);
   Console::WriteLine(result1);
   Console::WriteLine();
           
   String^ result2 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                                    gcnew array<Object^> { date1, hiTime, hiTemp, loTime, loTemp });
   Console::WriteLine(result2);
}
// The example displays the following output:
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
DateTime date1 = new DateTime(2009, 7, 1);
TimeSpan hiTime = new TimeSpan(14, 17, 32);
decimal hiTemp = 62.1m; 
TimeSpan loTime = new TimeSpan(3, 16, 10);
decimal loTemp = 54.8m; 

string result1 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                               date1, hiTime, hiTemp, loTime, loTemp);
Console.WriteLine(result1);
Console.WriteLine();
     
string result2 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", 
                               new object[] { date1, hiTime, hiTemp, loTime, loTemp });
Console.WriteLine(result2);
// The example displays output like the following:
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
//       Temperature on 7/1/2009:
//          14:17:32: 62.1 degrees (hi)
//          03:16:10: 54.8 degrees (lo)
Module Example
   Public Sub Main()
      Dim date1 As Date = #7/1/2009#
      Dim hiTime As New TimeSpan(14, 17, 32)
      Dim hiTemp As Decimal = 62.1d 
      Dim loTime As New TimeSpan(3, 16, 10)
      Dim loTemp As Decimal = 54.8d 

      Dim result1 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
                                           date1, hiTime, hiTemp, loTime, loTemp, vbCrLf)
      Console.WriteLine(result1)
      Console.WriteLine()
           
      Dim result2 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
                                            New Object() { date1, hiTime, hiTemp, loTime, loTemp, vbCrLf })
      Console.WriteLine(result2)                                            
   End Sub
End Module
' The example displays the following output:
'       Temperature on 7/1/2009:
'          14:17:32: 62.1 degrees (hi)
'          03:16:10: 54.8 degrees (lo)
'
'       Temperature on 7/1/2009:
'          14:17:32: 62.1 degrees (hi)
'          03:16:10: 54.8 degrees (lo)

Można również przekazać obiekty do formatowania jako tablicę, a nie jako listę argumentów.You can also pass the objects to be formatted as an array rather than as an argument list.

using namespace System;

ref class CityInfo
{
public:
   CityInfo(String^ name, int population, Decimal area, int year)
   {
      this->Name = name;
      this->Population = population;
      this->Area = area;
      this->Year = year;
   }
   
   String^ Name; 
   int Population;
   Decimal Area;
   int Year;
};

ref class Example
{
public:
   static void ShowPopulationData(CityInfo^ city)
   {
      array<Object^>^ args = gcnew array<Object^> { city->Name, city->Year, city->Population, city->Area };
      String^ result = String::Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", 
                                    args);
      Console::WriteLine(result); 
   }
};

void main()
{
   CityInfo^ nyc2010 = gcnew CityInfo("New York", 8175133, (Decimal) 302.64, 2010);
   Example::ShowPopulationData(nyc2010);
   CityInfo^ sea2010 = gcnew CityInfo("Seattle", 608660, (Decimal) 83.94, 2010);      
   Example::ShowPopulationData(sea2010); 
}
// The example displays the following output:
//       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
//       Seattle in 2010: Population 608,660, Area 83.9 sq. feet
using System;

public class CityInfo
{
   public CityInfo(String name, int population, Decimal area, int year)
   {
      this.Name = name;
      this.Population = population;
      this.Area = area;
      this.Year = year;
   }
   
   public readonly String Name; 
   public readonly int Population;
   public readonly Decimal Area;
   public readonly int Year;
}

public class Example
{
   public static void Main()
   {
      CityInfo nyc2010 = new CityInfo("New York", 8175133, 302.64m, 2010);
      ShowPopulationData(nyc2010);
      CityInfo sea2010 = new CityInfo("Seattle", 608660, 83.94m, 2010);      
      ShowPopulationData(sea2010); 
   }

   private static void ShowPopulationData(CityInfo city)
   {
      object[] args = { city.Name, city.Year, city.Population, city.Area };
      String result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", 
                                    args);
      Console.WriteLine(result); 
   }
}
// The example displays the following output:
//       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
//       Seattle in 2010: Population 608,660, Area 83.9 sq. feet
Public Class CityInfo
   Public Sub New(name As String, population As Integer, area As Decimal, year As Integer)
      Me.Name = name
      Me.Population = population
      Me.Area = area
      Me.Year = year
   End Sub
   
   Public ReadOnly Name As String
   Public ReadOnly Population As Integer
   Public ReadOnly Area As Decimal
   Public ReadOnly Year As Integer
End Class

Module Example
   Public Sub Main()
      Dim nyc2010 As New CityInfo("New York", 8175133, 302.64d, 2010)
      ShowPopulationData(nyc2010)
      Dim sea2010 As New CityInfo("Seattle", 608660, 83.94d, 2010)      
      ShowPopulationData(sea2010) 
   End Sub
   
   Private Sub ShowPopulationData(city As CityInfo)
      Dim args() As Object = { city.Name, city.Year, city.Population, city.Area }
      Dim result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", args)
      Console.WriteLine(result) 
   End Sub
End Module
' The example displays the following output:
'       New York in 2010: Population 8,175,133, Area 302.6 sq. feet
'       Seattle in 2010: Population 608,660, Area 83.9 sq. feet   

Zobacz też

Format(IFormatProvider, String, Object)

Zamienia element formatu lub elementy w określonym ciągu na ciąg reprezentujący odpowiadający obiekt.Replaces the format item or items in a specified string with the string representation of the corresponding object. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.A parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0);
public static string Format (IFormatProvider provider, string format, object arg0);
static member Format : IFormatProvider * string * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object) As String

Parametry

provider
IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.An object that supplies culture-specific formatting information.

arg0
Object

Obiekt do sformatowania.The object to format.

Zwraca

Kopia format, w której element formatu lub elementy zostały zastąpione przez ciąg reprezentujący arg0.A copy of format in which the format item or items have been replaced by the string representation of arg0.

Wyjątki

Parametr format ma wartość null.format is null.

format jest nieprawidłowy.format is invalid.

lub-or- Indeks elementu formatu nie jest równy zero.The index of a format item is not zero.

Uwagi

Ważne

Zamiast wywoływać metodę String.Format metody lub używając ciągów formatowania złożonego, możesz użyć ciągi interpolowane Jeśli język je obsługuje.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Ciąg interpolowany jest ciąg zawierający wyrażeń interpolowanych.An interpolated string is a string that contains interpolated expressions. Każde wyrażenie interpolowane jest rozwiązany wartość wyrażenia i uwzględnione w ciągu wynikowym, jeśli ciąg jest przypisany.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Aby uzyskać więcej informacji, zobacz Interpolacja ciągów (C# odwołania) i ciągi interpolowane (odwołanie w Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Ta metoda używa funkcji formatowania złożonego , aby przekonwertować wartość wyrażenia na jego reprezentację ciągu i osadzić tę reprezentację w ciągu.This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string. W trakcie wykonywania konwersji Metoda używa formatowania z uwzględnieniem kultury lub niestandardowego programu formatującego.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Metoda konwertuje arg0 na jego reprezentację ciągu przez wywołanie metody ToString (IFormatProvider) lub, jeśli odpowiedni element formatu obiektu zawiera ciąg formatu, wywołując jego metodę ToString (String, IFormatProvider) .The method converts arg0 to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Jeśli te metody nie istnieją, wywołuje metodę ToString bez parametrów obiektu.If these methods don't exist, it calls the object's parameterless ToString method.

Jednak podczas wywoływania String.Format metody, nie jest konieczne skoncentrować się na określonego przeciążenia, które ma zostać wywołana.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Zamiast tego należy wywołać metodę z obiektu, który zawiera wrażliwe na ustawienia kulturowe lub niestandardowe formatowanie i ciąg formatu złożonego zawierającego jeden lub więcej elementów formatu.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Przypisz każdy element formatu indeksu liczbowego; Pierwszy indeks zaczyna się od 0.You assign each format item a numeric index; the first index starts at 0. Oprócz ciąg początkowy wywołania metody powinna mieć dowolną liczbę dodatkowych argumentów, ponieważ zawiera ona wartości indeksu.In addition to the initial string, your method call should have as many additional arguments as it has index values. Na przykład ciąg, którego elementy formatu miały indeksy od 0 do 1 powinny mieć argumentów 2; jeden z indeksami 0 do 5 powinna mieć 6 argumentów.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Twój kompilator języka zostanie następnie rozpoznać wywołania metody do określonego przeciążenia String.Format metody.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Aby uzyskać bardziej szczegółowe dokumentacją dotyczącą korzystania z String.Format metody, zobacz rozpoczęcie korzystania z metody String.Format i która metoda zostanie wywołana?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Format(IFormatProvider, String, Object[])

Zamienia elementy formatu w ciągu na ciąg reprezentujący odpowiadające obiekty w określonej tablicy.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.A parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (IFormatProvider provider, string format, params object[] args);
static member Format : IFormatProvider * string * obj[] -> string
Public Shared Function Format (provider As IFormatProvider, format As String, ParamArray args As Object()) As String

Parametry

provider
IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.An object that supplies culture-specific formatting information.

args
Object[]

Tablica obiektów zawiera zero lub więcej obiektów do sformatowania.An object array that contains zero or more objects to format.

Zwraca

Kopia format, w której elementy formatu zostały zastąpione przez ciąg reprezentujący odpowiednie obiekty w args.A copy of format in which the format items have been replaced by the string representation of the corresponding objects in args.

Wyjątki

Parametr format lub args ma wartość null.format or args is null.

format jest nieprawidłowy.format is invalid.

lub-or- Indeks elementu formatu jest mniejszy od zera lub jest większy lub równy długości tablicy args.The index of a format item is less than zero, or greater than or equal to the length of the args array.

Uwagi

Ważne

Zamiast wywoływać metodę String.Format metody lub używając ciągów formatowania złożonego, możesz użyć ciągi interpolowane Jeśli język je obsługuje.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Ciąg interpolowany jest ciąg zawierający wyrażeń interpolowanych.An interpolated string is a string that contains interpolated expressions. Każde wyrażenie interpolowane jest rozwiązany wartość wyrażenia i uwzględnione w ciągu wynikowym, jeśli ciąg jest przypisany.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Aby uzyskać więcej informacji, zobacz Interpolacja ciągów (C# odwołania) i ciągi interpolowane (odwołanie w Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Ta metoda używa funkcji formatowania złożonego , aby skonwertować cztery lub więcej wyrażeń do ich reprezentacji ciągów i osadzić te reprezentacje w ciągu.This method uses the composite formatting feature to convert four or more expressions to their string representations and to embed those representations in a string. W trakcie wykonywania konwersji Metoda używa formatowania z uwzględnieniem kultury lub niestandardowego programu formatującego.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Metoda konwertuje każdy argument Object na jego reprezentację ciągu przez wywołanie metody ToString (IFormatProvider) lub, jeśli odpowiedni element formatu obiektu zawiera ciąg formatu, wywołując jego metodę ToString (String, IFormatProvider) .The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Jeśli te metody nie istnieją, wywołuje metodę ToString bez parametrów obiektu.If these methods don't exist, it calls the object's parameterless ToString method.

Jednak podczas wywoływania String.Format metody, nie jest konieczne skoncentrować się na określonego przeciążenia, które ma zostać wywołana.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Zamiast tego należy wywołać metodę z obiektu, który zawiera wrażliwe na ustawienia kulturowe lub niestandardowe formatowanie i ciąg formatu złożonego zawierającego jeden lub więcej elementów formatu.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Przypisz każdy element formatu indeksu liczbowego; Pierwszy indeks zaczyna się od 0.You assign each format item a numeric index; the first index starts at 0. Oprócz ciąg początkowy wywołania metody powinna mieć dowolną liczbę dodatkowych argumentów, ponieważ zawiera ona wartości indeksu.In addition to the initial string, your method call should have as many additional arguments as it has index values. Na przykład ciąg, którego elementy formatu miały indeksy od 0 do 1 powinny mieć argumentów 2; jeden z indeksami 0 do 5 powinna mieć 6 argumentów.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Twój kompilator języka zostanie następnie rozpoznać wywołania metody do określonego przeciążenia String.Format metody.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Aby uzyskać bardziej szczegółowe dokumentacją dotyczącą korzystania z String.Format metody, zobacz rozpoczęcie korzystania z metody String.Format i która metoda zostanie wywołana?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Przykład: formatowanie wrażliwe na kulturęExample: Culture-sensitive formatting

W tym przykładzie użyto metody Format(IFormatProvider, String, Object[]), aby wyświetlić reprezentację ciągu niektórych wartości daty i godziny oraz wartości liczbowych przy użyciu kilku różnych kultur.This example uses the Format(IFormatProvider, String, Object[]) method to display the string representation of some date and time values and numeric values by using several different cultures.

string[] cultureNames = { "en-US", "fr-FR", "de-DE", "es-ES" };

DateTime dateToDisplay = new DateTime(2009, 9, 1, 18, 32, 0);
double value = 9164.32;

Console.WriteLine("Culture     Date                                Value\n");
foreach (string cultureName in cultureNames)
{
   System.Globalization.CultureInfo culture = new System.Globalization.CultureInfo(cultureName);
   string output = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", 
                                 culture.Name, dateToDisplay, value);
   Console.WriteLine(output);
}    
// The example displays the following output:
//    Culture     Date                                Value
//    
//    en-US       Tuesday, September 01, 2009         9,164.32
//    fr-FR       mardi 1 septembre 2009              9 164,32
//    de-DE       Dienstag, 1. September 2009         9.164,32
//    es-ES       martes, 01 de septiembre de 2009    9.164,32
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "de-DE", "es-ES" }
      
      Dim dateToDisplay As Date = #9/1/2009 6:32PM#
      Dim value As Double = 9164.32

      Console.WriteLine("Culture     Date                                Value")
      Console.WriteLine()      
      For Each cultureName As String In cultureNames
         Dim culture As New CultureInfo(cultureName)
         Dim output As String = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", _
                                              culture.Name, dateToDisplay, value)
         Console.WriteLine(output)
      Next    
   End Sub
End Module
' The example displays the following output:
'       Culture     Date                                Value
'       
'       en-US       Tuesday, September 01, 2009         9,164.32
'       fr-FR       mardi 1 septembre 2009              9 164,32
'       de-DE       Dienstag, 1. September 2009         9.164,32
'       es-ES       martes, 01 de septiembre de 2009    9.164,32

Zobacz też

Format(String, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący dwa określone obiekty.Replaces the format items in a string with the string representation of two specified objects.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (string format, object arg0, object arg1);
static member Format : string * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object) As String

Parametry

arg0
Object

Pierwszy obiekt do sformatowania.The first object to format.

arg1
Object

Drugi obiekt do sformatowania.The second object to format.

Zwraca

Kopia format, w której elementy formatu są zamieniane na ciąg reprezentujący arg0 i arg1.A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Wyjątki

Parametr format ma wartość null.format is null.

format jest nieprawidłowy.format is invalid.

lub-or- Indeks elementu formatu nie jest równy zero lub jeden.The index of a format item is not zero or one.

Uwagi

Ważne

Zamiast wywoływać metodę String.Format metody lub używając ciągów formatowania złożonego, możesz użyć ciągi interpolowane Jeśli język je obsługuje.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Ciąg interpolowany jest ciąg zawierający wyrażeń interpolowanych.An interpolated string is a string that contains interpolated expressions. Każde wyrażenie interpolowane jest rozwiązany wartość wyrażenia i uwzględnione w ciągu wynikowym, jeśli ciąg jest przypisany.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Aby uzyskać więcej informacji, zobacz Interpolacja ciągów (C# odwołania) i ciągi interpolowane (odwołanie w Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Ta metoda używa funkcji formatowania złożonego do konwersji wartości dwóch wyrażeń na ich reprezentacje ciągów i osadzania tych reprezentacji w ciągu.This method uses the composite formatting feature to convert the value of two expressions to their string representations and to embed those representations in a string.

Jednak podczas wywoływania String.Format metody, nie jest konieczne skoncentrować się na określonego przeciążenia, które ma zostać wywołana.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Zamiast tego należy wywołać metodę z ciąg formatu złożonego zawierającego jeden lub więcej elementów formatu.Instead, you can call the method with a composite format string that includes one or more format items. Przypisz każdy element formatu indeksu liczbowego; Pierwszy indeks zaczyna się od 0.You assign each format item a numeric index; the first index starts at 0. Oprócz ciąg początkowy wywołania metody powinna mieć dowolną liczbę dodatkowych argumentów, ponieważ zawiera ona wartości indeksu.In addition to the initial string, your method call should have as many additional arguments as it has index values. Na przykład ciąg, którego elementy formatu miały indeksy od 0 do 1 powinny mieć argumentów 2; jeden z indeksami 0 do 5 powinna mieć 6 argumentów.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Twój kompilator języka zostanie następnie rozpoznać wywołania metody do określonego przeciążenia String.Format metody.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Aby uzyskać bardziej szczegółowe dokumentacją dotyczącą korzystania z String.Format metody, zobacz rozpoczęcie korzystania z metody String.Format i która metoda zostanie wywołana?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Przykład: formatowanie dwóch argumentówExample: Formatting two arguments

Ten przykład używa metody Format(String, Object, Object) do wyświetlania danych czasowych i temperatury przechowywanych w obiekcie generycznym Dictionary<TKey,TValue>.This example uses the Format(String, Object, Object) method to display time and temperature data stored in a generic Dictionary<TKey,TValue> object. Należy zauważyć, że ciąg formatu ma trzy elementy formatu, chociaż istnieją tylko dwa obiekty do sformatowania.Note that the format string has three format items, although there are only two objects to format. Wynika to z faktu, że pierwszy obiekt na liście (wartość daty i godziny) jest używany przez dwa elementy formatu: pierwszy element formatu wyświetla godzinę, a druga wyświetla datę.This is because the first object in the list (a date and time value) is used by two format items: The first format item displays the time, and the second displays the date.

using namespace System;
using namespace System::Collections::Generic;

void main()
{
   Dictionary<DateTime, Double>^ temperatureInfo = gcnew Dictionary<DateTime, Double>(); 
   temperatureInfo->Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46);
   temperatureInfo->Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81);
      
   Console::WriteLine("Temperature Information:\n");
   String^ output;   
   for each (KeyValuePair<DateTime, Double>^ item in temperatureInfo)
   {
      output = String::Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}�F", 
                              item->Key, item->Value);
      Console::WriteLine(output);
   }
}
// The example displays the following output:
//       Temperature Information:
//       
//       Temperature at  2:00 PM on  6/1/2010:  87.5�F
//       Temperature at 10:00 AM on 12/1/2010:  36.8�F
Dictionary<DateTime, Double> temperatureInfo = new Dictionary<DateTime, Double>(); 
temperatureInfo.Add(new DateTime(2010, 6, 1, 14, 0, 0), 87.46);
temperatureInfo.Add(new DateTime(2010, 12, 1, 10, 0, 0), 36.81);

Console.WriteLine("Temperature Information:\n");
string output;   
foreach (var item in temperatureInfo)
{
   output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", 
                          item.Key, item.Value);
   Console.WriteLine(output);
}
// The example displays output like the following:
//       Temperature Information:
//       
//       Temperature at  2:00 PM on  6/1/2010:  87.5°F
//       Temperature at 10:00 AM on 12/1/2010:  36.8°F
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim temperatureInfo As New Dictionary(Of Date, Double) 
      temperatureInfo.Add(#6/1/2010 2:00PM#, 87.46)
      temperatureInfo.Add(#12/1/2010 10:00AM#, 36.81)
      
      Console.WriteLine("Temperature Information:")
      Console.WriteLine()
      Dim output As String   
      For Each item In temperatureInfo
         output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", _
                                item.Key, item.Value)
         Console.WriteLine(output)
      Next
   End Sub
End Module
' The example displays the following output:
'       Temperature Information:
'       
'       Temperature at  2:00 PM on  6/1/2010:  87.5°F
'       Temperature at 10:00 AM on 12/1/2010:  36.8°F

Zobacz też

Format(IFormatProvider, String, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący dwa określone obiekty.Replaces the format items in a string with the string representation of two specified objects. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.A parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1);
static member Format : IFormatProvider * string * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object) As String

Parametry

provider
IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.An object that supplies culture-specific formatting information.

arg0
Object

Pierwszy obiekt do sformatowania.The first object to format.

arg1
Object

Drugi obiekt do sformatowania.The second object to format.

Zwraca

Kopia format, w której elementy formatu są zamieniane na ciąg reprezentujący arg0 i arg1.A copy of format in which format items are replaced by the string representations of arg0 and arg1.

Wyjątki

Parametr format ma wartość null.format is null.

format jest nieprawidłowy.format is invalid.

lub-or- Indeks elementu formatu nie jest równy zero lub jeden.The index of a format item is not zero or one.

Uwagi

Ważne

Zamiast wywoływać metodę String.Format metody lub używając ciągów formatowania złożonego, możesz użyć ciągi interpolowane Jeśli język je obsługuje.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Ciąg interpolowany jest ciąg zawierający wyrażeń interpolowanych.An interpolated string is a string that contains interpolated expressions. Każde wyrażenie interpolowane jest rozwiązany wartość wyrażenia i uwzględnione w ciągu wynikowym, jeśli ciąg jest przypisany.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Aby uzyskać więcej informacji, zobacz Interpolacja ciągów (C# odwołania) i ciągi interpolowane (odwołanie w Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Ta metoda używa funkcji formatowania złożonego , aby przekonwertować dwa wyrażenia na ich reprezentacje ciągów i osadzić te reprezentacje w ciągu.This method uses the composite formatting feature to convert two expressions to their string representations and to embed those representations in a string. W trakcie wykonywania konwersji Metoda używa formatowania z uwzględnieniem kultury lub niestandardowego programu formatującego.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Metoda konwertuje każdy argument Object na jego reprezentację ciągu przez wywołanie metody ToString (IFormatProvider) lub, jeśli odpowiedni element formatu obiektu zawiera ciąg formatu, wywołując jego metodę ToString (String, IFormatProvider) .The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Jeśli te metody nie istnieją, wywołuje metodę ToString bez parametrów obiektu.If these methods don't exist, it calls the object's parameterless ToString method.

Jednak podczas wywoływania String.Format metody, nie jest konieczne skoncentrować się na określonego przeciążenia, które ma zostać wywołana.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Zamiast tego należy wywołać metodę z obiektu, który zawiera wrażliwe na ustawienia kulturowe lub niestandardowe formatowanie i ciąg formatu złożonego zawierającego jeden lub więcej elementów formatu.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Przypisz każdy element formatu indeksu liczbowego; Pierwszy indeks zaczyna się od 0.You assign each format item a numeric index; the first index starts at 0. Oprócz ciąg początkowy wywołania metody powinna mieć dowolną liczbę dodatkowych argumentów, ponieważ zawiera ona wartości indeksu.In addition to the initial string, your method call should have as many additional arguments as it has index values. Na przykład ciąg, którego elementy formatu miały indeksy od 0 do 1 powinny mieć argumentów 2; jeden z indeksami 0 do 5 powinna mieć 6 argumentów.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Twój kompilator języka zostanie następnie rozpoznać wywołania metody do określonego przeciążenia String.Format metody.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Aby uzyskać bardziej szczegółowe dokumentacją dotyczącą korzystania z String.Format metody, zobacz rozpoczęcie korzystania z metody String.Format i która metoda zostanie wywołana?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Format(String, Object, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący trzy określone obiekty.Replaces the format items in a string with the string representation of three specified objects.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (string format, object arg0, object arg1, object arg2);
static member Format : string * obj * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Parametry

arg0
Object

Pierwszy obiekt do sformatowania.The first object to format.

arg1
Object

Drugi obiekt do sformatowania.The second object to format.

arg2
Object

Trzeci obiekt do sformatowania.The third object to format.

Zwraca

Kopia format, w której elementy formatu zostały zastąpione przez ciąg reprezentujący arg0, arg1i arg2.A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Wyjątki

Parametr format ma wartość null.format is null.

format jest nieprawidłowy.format is invalid.

lub-or- Indeks elementu formatu jest mniejszy niż zero lub większy niż dwa.The index of a format item is less than zero, or greater than two.

Uwagi

Ważne

Zamiast wywoływać metodę String.Format metody lub używając ciągów formatowania złożonego, możesz użyć ciągi interpolowane Jeśli język je obsługuje.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Ciąg interpolowany jest ciąg zawierający wyrażeń interpolowanych.An interpolated string is a string that contains interpolated expressions. Każde wyrażenie interpolowane jest rozwiązany wartość wyrażenia i uwzględnione w ciągu wynikowym, jeśli ciąg jest przypisany.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Aby uzyskać więcej informacji, zobacz Interpolacja ciągów (C# odwołania) i ciągi interpolowane (odwołanie w Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Ta metoda używa funkcji formatowania złożonego do konwersji wartości trzech wyrażeń do ich reprezentacji ciągów i osadzania tych reprezentacji w ciągu.This method uses the composite formatting feature to convert the value of three expressions to their string representations and to embed those representations in a string.

Jednak podczas wywoływania String.Format metody, nie jest konieczne skoncentrować się na określonego przeciążenia, które ma zostać wywołana.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Zamiast tego należy wywołać metodę z ciąg formatu złożonego zawierającego jeden lub więcej elementów formatu.Instead, you can call the method with a composite format string that includes one or more format items. Przypisz każdy element formatu indeksu liczbowego; Pierwszy indeks zaczyna się od 0.You assign each format item a numeric index; the first index starts at 0. Oprócz ciąg początkowy wywołania metody powinna mieć dowolną liczbę dodatkowych argumentów, ponieważ zawiera ona wartości indeksu.In addition to the initial string, your method call should have as many additional arguments as it has index values. Na przykład ciąg, którego elementy formatu miały indeksy od 0 do 1 powinny mieć argumentów 2; jeden z indeksami 0 do 5 powinna mieć 6 argumentów.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Twój kompilator języka zostanie następnie rozpoznać wywołania metody do określonego przeciążenia String.Format metody.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Aby uzyskać bardziej szczegółowe dokumentacją dotyczącą korzystania z String.Format metody, zobacz rozpoczęcie korzystania z metody String.Format i która metoda zostanie wywołana?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Przykład: formatowanie trzech argumentówExample: Formatting three arguments

W tym przykładzie zastosowano metodę Format(String, Object, Object, Object), aby utworzyć ciąg, który ilustruje wynik operacji logicznej And z dwiema wartościami całkowitymi.This example uses the Format(String, Object, Object, Object) method to create a string that illustrates the result of a Boolean And operation with two integer values. Należy zauważyć, że ciąg formatu zawiera sześć elementów formatu, ale metoda ma tylko trzy elementy na liście parametrów, ponieważ każdy element jest sformatowany na dwa różne sposoby.Note that the format string includes six format items, but the method has only three items in its parameter list, because each item is formatted in two different ways.

using namespace System;

void main()
{
   String^ formatString = "    {0,10} ({0,8:X8})\n" + 
                           "And {1,10} ({1,8:X8})\n" + 
                           "  = {2,10} ({2,8:X8})";
   int value1 = 16932;
   int value2 = 15421;
   String^ result = String::Format(formatString, 
                                   value1, value2, value1 & value2);
   Console::WriteLine(result);
}
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)
string formatString = "    {0,10} ({0,8:X8})\n" + 
                      "And {1,10} ({1,8:X8})\n" + 
                      "  = {2,10} ({2,8:X8})";
int value1 = 16932;
int value2 = 15421;
string result = String.Format(formatString, 
                              value1, value2, value1 & value2);
Console.WriteLine(result);
// The example displays the following output:
//                16932 (00004224)
//       And      15421 (00003C3D)
//         =         36 (00000024)
Public Module Example
   Public Sub Main()
      Dim formatString As String = "    {0,10} ({0,8:X8})" + vbCrLf +  _
                                   "And {1,10} ({1,8:X8})" + vbCrLf + _
                                   "  = {2,10} ({2,8:X8})"
      Dim value1 As Integer = 16932
      Dim value2 As Integer = 15421
      Dim result As String = String.Format(formatString, _
                                           value1, value2, value1 And value2)
      Console.WriteLine(result)                          
   End Sub
End Module
' The example displays the following output:
'                16932 (00004224)
'       And      15421 (00003C3D)
'         =         36 (00000024)

Zobacz też

Format(IFormatProvider, String, Object, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący trzy określone obiekty.Replaces the format items in a string with the string representation of three specified objects. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.An parameter supplies culture-specific formatting information.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1, object arg2);
static member Format : IFormatProvider * string * obj * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String

Parametry

provider
IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.An object that supplies culture-specific formatting information.

arg0
Object

Pierwszy obiekt do sformatowania.The first object to format.

arg1
Object

Drugi obiekt do sformatowania.The second object to format.

arg2
Object

Trzeci obiekt do sformatowania.The third object to format.

Zwraca

Kopia format, w której elementy formatu zostały zastąpione przez ciąg reprezentujący arg0, arg1i arg2.A copy of format in which the format items have been replaced by the string representations of arg0, arg1, and arg2.

Wyjątki

Parametr format ma wartość null.format is null.

format jest nieprawidłowy.format is invalid.

lub-or- Indeks elementu formatu jest mniejszy niż zero lub większy niż dwa.The index of a format item is less than zero, or greater than two.

Uwagi

Ważne

Zamiast wywoływać metodę String.Format metody lub używając ciągów formatowania złożonego, możesz użyć ciągi interpolowane Jeśli język je obsługuje.Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. Ciąg interpolowany jest ciąg zawierający wyrażeń interpolowanych.An interpolated string is a string that contains interpolated expressions. Każde wyrażenie interpolowane jest rozwiązany wartość wyrażenia i uwzględnione w ciągu wynikowym, jeśli ciąg jest przypisany.Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. Aby uzyskać więcej informacji, zobacz Interpolacja ciągów (C# odwołania) i ciągi interpolowane (odwołanie w Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).

Ta metoda używa funkcji formatowania złożonego , aby przekonwertować trzy wyrażenia na ich reprezentacje ciągów i osadzić te reprezentacje w ciągu.This method uses the composite formatting feature to convert three expressions to their string representations and to embed those representations in a string. W trakcie wykonywania konwersji Metoda używa formatowania z uwzględnieniem kultury lub niestandardowego programu formatującego.In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. Metoda konwertuje każdy argument Object na jego reprezentację ciągu przez wywołanie metody ToString (IFormatProvider) lub, jeśli odpowiedni element formatu obiektu zawiera ciąg formatu, wywołując jego metodę ToString (String, IFormatProvider) .The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. Jeśli te metody nie istnieją, wywołuje metodę ToString bez parametrów obiektu.If these methods don't exist, it calls the object's parameterless ToString method.

Jednak podczas wywoływania String.Format metody, nie jest konieczne skoncentrować się na określonego przeciążenia, które ma zostać wywołana.However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. Zamiast tego należy wywołać metodę z obiektu, który zawiera wrażliwe na ustawienia kulturowe lub niestandardowe formatowanie i ciąg formatu złożonego zawierającego jeden lub więcej elementów formatu.Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. Przypisz każdy element formatu indeksu liczbowego; Pierwszy indeks zaczyna się od 0.You assign each format item a numeric index; the first index starts at 0. Oprócz ciąg początkowy wywołania metody powinna mieć dowolną liczbę dodatkowych argumentów, ponieważ zawiera ona wartości indeksu.In addition to the initial string, your method call should have as many additional arguments as it has index values. Na przykład ciąg, którego elementy formatu miały indeksy od 0 do 1 powinny mieć argumentów 2; jeden z indeksami 0 do 5 powinna mieć 6 argumentów.For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. Twój kompilator języka zostanie następnie rozpoznać wywołania metody do określonego przeciążenia String.Format metody.Your language compiler will then resolve your method call to a particular overload of the String.Format method.

Aby uzyskać bardziej szczegółowe dokumentacją dotyczącą korzystania z String.Format metody, zobacz rozpoczęcie korzystania z metody String.Format i która metoda zostanie wywołana?.For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.

Dotyczy