Złożone formatowanieComposite Formatting

Funkcja formatowania złożonego .NET przyjmuje listę obiektów i ciąg formatu złożonego jako dane wejściowe.The .NET composite formatting feature takes a list of objects and a composite format string as input. Ciąg formatu złożonego składa się ze stałego tekstu zmieszanego z indeksowanymi symbolami zastępczymi (nazywanymi też elementami formatu), które odpowiadają obiektom na liście.A composite format string consists of fixed text intermixed with indexed placeholders, called format items, that correspond to the objects in the list. Operacja formatowania zwraca ciąg wynikowy, który składa się z oryginalnego stałego tekstu zmieszanego z ciągiem reprezentującym obiekty na liście.The formatting operation yields a result string that consists of the original fixed text intermixed with the string representation of the objects in the list.

Ważne

Zamiast korzystać z ciągów formatu złożonego, można użyć interpolowanych ciągów , jeśli używany język i wersja językowa są obsługiwane.Instead of using composite format strings, you can use interpolated strings if the language and language version that you're using support 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ówC# (odwołanie) i ciągi interpolowane (odwołanie Visual Basic).For more information, see String interpolation (C# Reference) and Interpolated strings (Visual Basic Reference).

Funkcja formatowania złożonego jest obsługiwana przez metody, takie jak:The composite formatting feature is supported by methods such as the following:

Złożony ciąg formatującyComposite Format String

Ciąg formatu złożonego i lista obiektów są używane jako argumenty metod, które obsługują funkcję formatowania złożonego.A composite format string and object list are used as arguments of methods that support the composite formatting feature. Ciąg formatu złożonego składa się z zera lub większej liczby serii stałego tekstu zmieszanego z co najmniej jednym elementem formatu.A composite format string consists of zero or more runs of fixed text intermixed with one or more format items. Stały tekst to dowolnie wybrany ciąg, a każdy element formatu odpowiada obiektowi lub strukturze opakowanej na liście.The fixed text is any string that you choose, and each format item corresponds to an object or boxed structure in the list. Funkcja formatowania złożonego zwraca nowy ciąg wynikowy, w którym każdy element formatu jest zamieniany na ciąg reprezentujący odpowiadający mu obiekt na liście.The composite formatting feature returns a new result string where each format item is replaced by the string representation of the corresponding object in the list.

Rozważmy następujący Format fragment kodu.Consider the following Format code fragment.

string name = "Fred";
String.Format("Name = {0}, hours = {1:hh}", name, DateTime.Now);
Dim name As String = "Fred"
String.Format("Name = {0}, hours = {1:hh}", name, DateTime.Now)

Stały tekst to "Name = " i ", hours = ".The fixed text is "Name = " and ", hours = ". Elementy formatu są{0}"", których indeks jest równy 0, który odnosi się do obiektu namei "{1:hh}", którego indeks wynosi 1, co odpowiada obiektowi DateTime.Now.The format items are "{0}", whose index is 0, which corresponds to the object name, and "{1:hh}", whose index is 1, which corresponds to the object DateTime.Now.

Formatuj element składniFormat Item Syntax

Każdy element formatu ma następującą postać i składa się z następujących składników:Each format item takes the following form and consists of the following components:

{indeks [,wyrównanie] [:FormatString]}{ index[,alignment][:formatString]}

Dopasowujące nawiasy klamrowe („{” i „}”) są wymagane.The matching braces ("{" and "}") are required.

Składnik indeksuIndex Component

Obowiązkowy składnik indeksu , nazywany także specyfikatorem parametru, jest liczbą rozpoczynającą się od 0, która identyfikuje odpowiadający element na liście obiektów.The mandatory index component, also called a parameter specifier, is a number starting from 0 that identifies a corresponding item in the list of objects. Oznacza to, że element formatu, którego specyfikator parametru to 0, formatuje pierwszy obiekt na liście, element formatu, którego specyfikator parametru to 1, formatuje drugi obiekt na liście itd.That is, the format item whose parameter specifier is 0 formats the first object in the list, the format item whose parameter specifier is 1 formats the second object in the list, and so on. Poniższy przykład zawiera cztery specyfikatory parametrów, numerowane od zera do trzech, aby reprezentować liczby podstawowe mniejsze niż dziesięć:The following example includes four parameter specifiers, numbered zero through three, to represent prime numbers less than ten:

string primes;
primes = String.Format("Prime numbers less than 10: {0}, {1}, {2}, {3}",
                       2, 3, 5, 7 );
Console.WriteLine(primes);
// The example displays the following output:
//      Prime numbers less than 10: 2, 3, 5, 7
Dim primes As String
primes = String.Format("Prime numbers less than 10: {0}, {1}, {2}, {3}",
                       2, 3, 5, 7 )
Console.WriteLine(primes)
' The example displays the following output:
'      Prime numbers less than 10: 2, 3, 5, 7

Wiele elementów formatu może odwoływać się do tego samego elementu na liście obiektów, jeśli będą miały określony taki sam specyfikator parametru.Multiple format items can refer to the same element in the list of objects by specifying the same parameter specifier. Na przykład można sformatować tę samą wartość liczbową w formacie szesnastkowym, naukowym i liczbowym, określając ciąg formatu złożonego, taki jak: "0x{0:X} {0:E} ",jakpokazano{0:N}w poniższym przykładzie.For example, you can format the same numeric value in hexadecimal, scientific, and number format by specifying a composite format string such as : "0x{0:X} {0:E} {0:N}", as the following example shows.

string multiple = String.Format("0x{0:X} {0:E} {0:N}",
                                Int64.MaxValue);
Console.WriteLine(multiple);
// The example displays the following output:
//      0x7FFFFFFFFFFFFFFF 9.223372E+018 9,223,372,036,854,775,807.00
Dim multiple As String = String.Format("0x{0:X} {0:E} {0:N}",
                                       Int64.MaxValue)
Console.WriteLine(multiple)
' The example displays the following output:
'      0x7FFFFFFFFFFFFFFF 9.223372E+018 9,223,372,036,854,775,807.00

Każdy element formatu może odwoływać się do dowolnego obiektu na liście.Each format item can refer to any object in the list. Na przykład jeśli istnieją trzy obiekty, można sformatować drugi, pierwszy i trzeci obiekt przez określenie ciągu formatu złożonego, takiego jak: "{1} {0} {2}".For example, if there are three objects, you can format the second, first, and third object by specifying a composite format string like this: "{1} {0} {2}". Obiekt, do którego nie odwołuje się element formatu, zostanie zignorowany.An object that is not referenced by a format item is ignored. Jest FormatException generowany w czasie wykonywania, jeśli specyfikator parametru wyznacza element poza granicami listy obiektów.A FormatException is thrown at runtime if a parameter specifier designates an item outside the bounds of the list of objects.

Składnik wyrównaniaAlignment Component

Opcjonalny składnik wyrównania jest ze znakiem liczby całkowitej wskazującej preferowaną szerokość pola sformatowanego.The optional alignment component is a signed integer indicating the preferred formatted field width. Jeśli wartość wyrównania jest mniejsza niż długość sformatowanego ciągu, wyrównanie jest ignorowane i długość sformatowanego ciągu jest używana jako szerokość pola.If the value of alignment is less than the length of the formatted string, alignment is ignored and the length of the formatted string is used as the field width. Sformatowane dane w polu są wyrównane do prawej, jeśli wyrównanie jest dodatnie i wyrównane do lewej, jeśli wyrównanie jest ujemne.The formatted data in the field is right-aligned if alignment is positive and left-aligned if alignment is negative. Jeśli potrzebne jest dopełnienie, będą używane znaki odstępu.If padding is necessary, white space is used. Przecinek jest wymagany w przypadku określenia wyrównania.The comma is required if alignment is specified.

W poniższym przykładzie zdefiniowano dwie tablice, z których jedna zawiera nazwy pracowników i drugi zawierający godziny, w których pracują w okresie dwóch tygodni.The following example defines two arrays, one containing the names of employees and the other containing the hours they worked over a two-week period. Ciąg formatu złożonego w lewo — wyrównuje nazwy w polu 20 znaków, a następnie w polu 5-znakowym wyrównanym do prawej godziny.The composite format string left-aligns the names in a 20-character field, and right-aligns their hours in a 5-character field. Należy zauważyć, że ciąg formatu standardowego "N1" służy również do formatowania godzin przy użyciu jednej cyfry ułamkowej.Note that the "N1" standard format string is also used to format the hours with one fractional digit.

using System;

public class Example
{
   public static void Main()
   {
      string[] names = { "Adam", "Bridgette", "Carla", "Daniel",
                         "Ebenezer", "Francine", "George" };
      decimal[] hours = { 40, 6.667m, 40.39m, 82, 40.333m, 80,
                                 16.75m };

      Console.WriteLine("{0,-20} {1,5}\n", "Name", "Hours");
      for (int ctr = 0; ctr < names.Length; ctr++)
         Console.WriteLine("{0,-20} {1,5:N1}", names[ctr], hours[ctr]);

   }
}
// The example displays the following output:
//       Name                 Hours
//
//       Adam                  40.0
//       Bridgette              6.7
//       Carla                 40.4
//       Daniel                82.0
//       Ebenezer              40.3
//       Francine              80.0
//       George                16.8
Module Example
   Public Sub Main()
      Dim names() As String = { "Adam", "Bridgette", "Carla", "Daniel",
                                "Ebenezer", "Francine", "George" }
      Dim hours() As Decimal = { 40, 6.667d, 40.39d, 82, 40.333d, 80,
                                 16.75d }

      Console.WriteLine("{0,-20} {1,5}", "Name", "Hours")
      Console.WriteLine()
      For ctr As Integer = 0 To names.Length - 1
         Console.WriteLine("{0,-20} {1,5:N1}", names(ctr), hours(ctr))
      Next
   End Sub
End Module
' The example displays the following output:
'       Name                 Hours
'
'       Adam                  40.0
'       Bridgette              6.7
'       Carla                 40.4
'       Daniel                82.0
'       Ebenezer              40.3
'       Francine              80.0
'       George                16.8

Element ciągu formatującegoFormat String Component

Opcjonalny składnik FormatString jest ciągiem formatu, który jest odpowiedni dla typu formatowanego obiektu.The optional formatString component is a format string that is appropriate for the type of object being formatted. Określ standardowy lub niestandardowy ciąg formatu liczbowego, jeśli odpowiedni obiekt jest wartością liczbową, standardowym lub niestandardowym ciągiem formatu daty i godziny, jeśli odpowiedni obiekt DateTime jest obiektem lub ciągiem formatu wyliczenia , jeśli odpowiada Obiekt jest wartością wyliczenia.Specify a standard or custom numeric format string if the corresponding object is a numeric value, a standard or custom date and time format string if the corresponding object is a DateTime object, or an enumeration format string if the corresponding object is an enumeration value. Jeśli element FormatString nie zostanie określony, używany jest specyfikator formatu ogólnego ("G") dla typu liczbowego, daty i godziny lub wyliczenia.If formatString is not specified, the general ("G") format specifier for a numeric, date and time, or enumeration type is used. Dwukropek jest wymagany, jeśli jest określony parametr FormatString .The colon is required if formatString is specified.

Poniższa tabela zawiera listę typów lub kategorii typów w bibliotece klas programu .NET Framework, które obsługują wstępnie zdefiniowany zestaw ciągów formatu i zawiera łącza do tematów zawierających opisy obsługiwanych ciągów formatu.The following table lists types or categories of types in the .NET Framework class library that support a predefined set of format strings, and provides links to the topics that list the supported format strings. Należy zauważyć, że formatowanie ciągów jest rozszerzalnym mechanizmem, który umożliwia definiowanie nowych ciągów formatu dla każdego istniejącego typu, podobnie jak definiowanie zestawu ciągów formatu obsługiwanych przez typ zdefiniowany przez aplikację.Note that string formatting is an extensible mechanism that makes it possible to define new format strings for all existing types as well as to define a set of format strings supported by an application-defined type. Aby uzyskać więcej informacji, zobacz IFormattable tematy ICustomFormatter dotyczące interfejsu i.For more information, see the IFormattable and ICustomFormatter interface topics.

Typ lub kategoria typówType or type category ZobaczSee
Typy daty i godziny (DateTime, DateTimeOffset)Date and time types (DateTime, DateTimeOffset) Standardowe ciągi formatujące datę i godzinęStandard Date and Time Format Strings

Niestandardowe ciągi formatujące datę i godzinęCustom Date and Time Format Strings
Typy wyliczeniowe (wszystkie typy System.Enumpochodne od)Enumeration types (all types derived from System.Enum) Ciągi formatujące wyliczeniaEnumeration Format Strings
Typy liczbowe (BigInteger, Byte, Decimal ,,UInt64, ,Int64 ,,UInt32, ,,)UInt16 Int32 Double Int16 SByte SingleNumeric types (BigInteger, Byte, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64) Standardowe ciągi formatujące liczbyStandard Numeric Format Strings

Niestandardowe ciągi formatujące liczbyCustom Numeric Format Strings
Guid Guid.ToString(String)
TimeSpan Standardowe ciągi formatujące TimeSpanStandard TimeSpan Format Strings

Niestandardowe ciągi formatujące TimeSpanCustom TimeSpan Format Strings

Unikanie nawiasów klamrowychEscaping Braces

Klamrowe nawiasy otwierający i zamykający są interpretowane jako rozpoczęcie i zakończenie elementu formatu.Opening and closing braces are interpreted as starting and ending a format item. W związku z tym należy użyć sekwencji ucieczki, aby wyświetlić literał otwierającego nawiasu klamrowego lub zamykającego nawiasu klamrowego.Consequently, you must use an escape sequence to display a literal opening brace or closing brace. Należy określić dwa otwierające nawiasy klamrowe („{{”) w stałym tekście, aby wyświetlić jeden otwierający nawias klamrowy („{”), bądź dwa zamykające nawiasy klamrowe („}}”), aby wyświetlić jeden zamykający nawias klamrowy („}”).Specify two opening braces ("{{") in the fixed text to display one opening brace ("{"), or two closing braces ("}}") to display one closing brace ("}"). Nawiasy klamrowe w elemencie formatu są interpretowane sekwencyjnie w kolejności, w jakiej są napotykane.Braces in a format item are interpreted sequentially in the order they are encountered. Interpretowanie zagnieżdżonych nawiasów klamrowych nie jest obsługiwane.Interpreting nested braces is not supported.

Sposób interpretowania nawiasów klamrowych poprzedzonych znakiem ucieczki może prowadzić do nieoczekiwanych rezultatów.The way escaped braces are interpreted can lead to unexpected results. Rozważmy na przykład element formatu "{{{0:D}}}", który jest przeznaczony do wyświetlania nawiasu otwierającego, wartości liczbowej sformatowanej jako liczba dziesiętna i zamykającego nawiasu klamrowego.For example, consider the format item "{{{0:D}}}", which is intended to display an opening brace, a numeric value formatted as a decimal number, and a closing brace. Jednak element formatu jest w rzeczywistości interpretowany w następujący sposób:However, the format item is actually interpreted in the following manner:

  1. Pierwsze dwa otwierające nawiasy klamrowe są traktowane jako nawias i znak ucieczki, przez co są zwracane jako jeden otwierający nawias klamrowy.The first two opening braces ("{{") are escaped and yield one opening brace.

  2. Kolejne trzy znaki („{0:”) są interpretowane jako początek elementu formatu.The next three characters ("{0:") are interpreted as the start of a format item.

  3. Następny znak („D”) powinien zostać zinterpretowany jako standardowy specyfikator formatu liczb dziesiętnych, ale kolejne dwa nawiasy klamrowe („}}”) zostaną zwrócone jako pojedynczy nawias klamrowy.The next character ("D") would be interpreted as the Decimal standard numeric format specifier, but the next two escaped braces ("}}") yield a single brace. Ponieważ wynikowy ciąg („D}”) nie jest standardowym specyfikatorem formatu liczb, wynikowy ciąg zostanie zinterpretowany jako ciąg formatu niestandardowego, co oznacza wyświetlenie literału ciągu „D}”.Because the resulting string ("D}") is not a standard numeric format specifier, the resulting string is interpreted as a custom format string that means display the literal string "D}".

  4. Ostatni nawias klamrowy („}”) jest interpretowany jako zakończenie elementu formatu.The last brace ("}") is interpreted as the end of the format item.

  5. Wyświetlony wynik końcowy będzie ciągiem literału „{D}”.The final result that is displayed is the literal string, "{D}". Wartość liczbowa, która miała zostać sformatowana, nie zostanie wyświetlona.The numeric value that was to be formatted is not displayed.

Jednym ze sposobów pisania kodu tak, aby uniknąć błędnej interpretacji nawiasów klamrowych ze znakami ucieczki jest formatowanie nawiasów klamrowych i elementów formatu rozdzielnie.One way to write your code to avoid misinterpreting escaped braces and format items is to format the braces and format item separately. Oznacza to, że w pierwszej operacji formatowania wyświetlany jest otwierający nawias klamrowy literału, w następnej operacji wyświetlany jest wynik elementu formatu, a następnie w ostatniej operacji wyświetlany jest zamykający nawias klamrowy literału.That is, in the first format operation display a literal opening brace, in the next operation display the result of the format item, then in the final operation display a literal closing brace. To podejście pokazano w poniższym przykładzie.The following example illustrates this approach.

int value = 6324;
string output = string.Format("{0}{1:D}{2}", 
                             "{", value, "}");
Console.WriteLine(output);
// The example displays the following output:
//       {6324}                            
Dim value As Integer = 6324
Dim output As String = String.Format("{0}{1:D}{2}", _
                                     "{", value, "}")
Console.WriteLine(output)   
' The example displays the following output:
'       {6324}

Kolejność przetwarzaniaProcessing Order

Jeśli wywołanie metody formatowania złożonego zawiera IFormatProvider argument IFormatProvider.GetFormat , którego wartość nie nulljest, środowisko uruchomieniowe wywołuje metodę, aby zażądać ICustomFormatter implementacji.If the call to the composite formatting method includes an IFormatProvider argument whose value is not null, the runtime calls its IFormatProvider.GetFormat method to request an ICustomFormatter implementation. Jeśli metoda może zwrócić ICustomFormatter implementację, jest buforowana na czas trwania wywołania metody formatowania złożonego.If the method is able to return an ICustomFormatter implementation, it's cached for the duration of the call of the composite formatting method.

Każda wartość na liście parametrów, która odnosi się do elementu formatu, jest konwertowana na ciąg w następujący sposób:Each value in the parameter list that corresponds to a format item is converted to a string as follows:

  1. Jeśli wartość do sformatowania jest null, zwracany jest pusty ciąg. String.EmptyIf the value to be formatted is null, an empty string String.Empty is returned.

  2. Jeśli implementacja jest dostępna, środowisko uruchomieniowe wywołuje jego Format metodę. ICustomFormatterIf an ICustomFormatter implementation is available, the runtime calls its Format method. Przekazuje ona metodę, jeśli jest obecny, lub null Jeśli nie IFormatProvider , wraz z implementacją.It passes the method the format item's formatString value, if one is present, or null if it's not, along with the IFormatProvider implementation. Jeśli wywołanie ICustomFormatter.Format metody zwróci nullmetodę, wykonanie przechodzi do następnego kroku; w przeciwnym razie zwracany jest wynik ICustomFormatter.Format wywołania.If the call to the ICustomFormatter.Format method returns null, execution proceeds to the next step; otherwise, the result of the ICustomFormatter.Format call is returned.

  3. Jeśli wartość implementuje IFormattable interfejs, wywoływana jest ToString(String, IFormatProvider) metoda interfejsu.If the value implements the IFormattable interface, the interface's ToString(String, IFormatProvider) method is called. Metoda jest przenoszona przez wartość FormatString , jeśli jest obecna w elemencie formatu lub null Jeśli nie jest.The method is passed the formatString value, if one is present in the format item, or null if it's not. IFormatProvider Argument jest określany w następujący sposób:The IFormatProvider argument is determined as follows:

  4. ToString Metoda bez parametrów typu, która zastępuje Object.ToString() lub dziedziczy zachowanie klasy podstawowej, jest wywoływana.The type's parameterless ToString method, which either overrides Object.ToString() or inherits the behavior of its base class, is called. W tym przypadku ciąg formatu określony przez składnik FormatString w elemencie formatu, jeśli jest obecny, jest ignorowany.In this case, the format string specified by the formatString component in the format item, if it's present, is ignored.

Wyrównanie zostanie zastosowane po wykonaniu poprzednich kroków.Alignment is applied after the preceding steps have been performed.

Przykłady koduCode Examples

W poniższym przykładzie pokazano jeden ciąg utworzony przy użyciu formatowania złożonego i inny utworzony przy użyciu ToString metody obiektu.The following example shows one string created using composite formatting and another created using an object's ToString method. Oba typy formatowania dają równoważne wyniki.Both types of formatting produce equivalent results.

string FormatString1 = String.Format("{0:dddd MMMM}", DateTime.Now);
string FormatString2 = DateTime.Now.ToString("dddd MMMM");
Dim FormatString1 As String = String.Format("{0:dddd MMMM}", DateTime.Now)
Dim FormatString2 As String = DateTime.Now.ToString("dddd MMMM") 

Przy założeniu, że bieżący dzień jest czwartek w maju, wartość obu ciągów w powyższym przykładzie znajduje Thursday May się w Stanach Zjednoczonych Kultura angielska.Assuming that the current day is a Thursday in May, the value of both strings in the preceding example is Thursday May in the U.S. English culture.

Console.WriteLineudostępnia te same funkcje co String.Format.Console.WriteLine exposes the same functionality as String.Format. Jedyną różnicą między dwoma metodami jest String.Format zwrócenie wyniku w postaci ciągu, podczas gdy Console.WriteLine zapisuje wynik do strumienia Console wyjściowego skojarzonego z obiektem.The only difference between the two methods is that String.Format returns its result as a string, while Console.WriteLine writes the result to the output stream associated with the Console object. W poniższym przykładzie zastosowano Console.WriteLine metodę, aby sformatować MyInt wartość do wartości walutowej.The following example uses the Console.WriteLine method to format the value of MyInt to a currency value.

int MyInt = 100;
Console.WriteLine("{0:C}", MyInt);
// The example displays the following output 
// if en-US is the current culture:
//        $100.00
Dim MyInt As Integer = 100
Console.WriteLine("{0:C}", MyInt)
' The example displays the following output
' if en-US is the current culture:
'        $100.00

W poniższym przykładzie pokazano formatowanie wielu obiektów, w tym formatowanie jednego obiektu na dwa różne sposoby.The following example demonstrates formatting multiple objects, including formatting one object two different ways.

string myName = "Fred";
Console.WriteLine(String.Format("Name = {0}, hours = {1:hh}, minutes = {1:mm}",
      myName, DateTime.Now));
// Depending on the current time, the example displays output like the following:
//    Name = Fred, hours = 11, minutes = 30                 
Dim myName As String = "Fred"
Console.WriteLine(String.Format("Name = {0}, hours = {1:hh}, minutes = {1:mm}", _
                  myName, DateTime.Now))
' Depending on the current time, the example displays output like the following:
'    Name = Fred, hours = 11, minutes = 30                 

W poniższym przykładzie pokazano użycie wyrównania w formatowaniu.The following example demonstrates the use of alignment in formatting. Sformatowane argumenty są umieszczane między pionowymi znakami kreski|(), aby wyróżnić wyniki wyrównania.The arguments that are formatted are placed between vertical bar characters (|) to highlight the resulting alignment.

string myFName = "Fred";
string myLName = "Opals";
int myInt = 100;
string FormatFName = String.Format("First Name = |{0,10}|", myFName);
string FormatLName = String.Format("Last Name = |{0,10}|", myLName);
string FormatPrice = String.Format("Price = |{0,10:C}|", myInt); 
Console.WriteLine(FormatFName);
Console.WriteLine(FormatLName);
Console.WriteLine(FormatPrice);
Console.WriteLine();

FormatFName = String.Format("First Name = |{0,-10}|", myFName);
FormatLName = String.Format("Last Name = |{0,-10}|", myLName);
FormatPrice = String.Format("Price = |{0,-10:C}|", myInt);
Console.WriteLine(FormatFName);
Console.WriteLine(FormatLName);
Console.WriteLine(FormatPrice);
// The example displays the following output on a system whose current
// culture is en-US:
//          First Name = |      Fred|
//          Last Name = |     Opals|
//          Price = |   $100.00|
//
//          First Name = |Fred      |
//          Last Name = |Opals     |
//          Price = |$100.00   |
   Dim myFName As String = "Fred"
   Dim myLName As String = "Opals"

   Dim myInt As Integer = 100
   Dim FormatFName As String = String.Format("First Name = |{0,10}|", myFName)
   Dim FormatLName As String = String.Format("Last Name = |{0,10}|", myLName)
   Dim FormatPrice As String = String.Format("Price = |{0,10:C}|", myInt)
   Console.WriteLine(FormatFName)
   Console.WriteLine(FormatLName)
   Console.WriteLine(FormatPrice)
   Console.WriteLine()
   
   FormatFName = String.Format("First Name = |{0,-10}|", myFName)
   FormatLName = String.Format("Last Name = |{0,-10}|", myLName)
   FormatPrice = String.Format("Price = |{0,-10:C}|", myInt)
   Console.WriteLine(FormatFName)
   Console.WriteLine(FormatLName)
   Console.WriteLine(FormatPrice)
   ' The example displays the following output on a system whose current
   ' culture is en-US:
   '          First Name = |      Fred|
   '          Last Name = |     Opals|
   '          Price = |   $100.00|
   '
   '          First Name = |Fred      |
   '          Last Name = |Opals     |
   '          Price = |$100.00   |

Zobacz takżeSee also