Összetett formázás

A .NET összetett formázási funkciója bemenetként egy objektumlistát és egy összetett formázási sztringet használ. Az összetett formázási sztring rögzített szövegből áll, amely indexelt helyőrzőkkel, úgynevezett formátumelemekkel van keverve. Ezek a formátumelemek a listában szereplő objektumoknak felelnek meg. A formázási művelet olyan eredménysztringet eredményez, amely az eredeti rögzített szövegből áll, amely a lista objektumainak sztringképével van elegyítve.

Fontos

Összetett formátumú sztringek használata helyett interpolált sztringeket is használhat, ha az ön által használt nyelv és annak verziója támogatja őket. Az interpolált sztringek interpolált kifejezéseket tartalmaznak. Az interpolált kifejezések feloldásra kerülnek a kifejezések értékével, és amikor a karakterlánc hozzárendelésre kerül, ezek az eredmény részét képezik. További információ: Sztring interpoláció (C# referencia) és interpolált sztringek (Visual Basic Reference).

A következő metódusok támogatják az összetett formázási funkciót:

Összetett formázási karakterlánc

Az összetett formázási funkciót támogató metódusok argumentumai egy összetett formátumú sztring és objektumlista. Az összetett formázási sztringek nulla vagy több rögzített szövegszakaszból állnak, amelyeket egy vagy több formázási elem kever. A rögzített szöveg bármilyen sztring lehet, és minden formázási elem a listában található objektumnak vagy egy beágyazott struktúrának felel meg. Az egyes objektumok sztringábrázolása a megfelelő formátumelemet helyettesíti.

Vegye figyelembe a következő Format kódrészletet:

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

String.Format("Name = {0}, hours = {1:hh}", "Fred", DateTime.Now)

A rögzített szöveg Name = és , hours = . A formátumelemek a {0}, amelyek 0 indexe a karakterlánc literálnak "Fred" felel meg, és a {1:hh}, amelyek 1 indexe az DateTime.Now értékének felel meg.

Elem szintaxisának formázása

Minden formátum elem a következő formát ölti, és a következő összetevőkből áll:

{index[,width][:formatString]}

A megfelelő kapcsos zárójelek ({ és }) megadása kötelező.

Index összetevő

A kötelező index összetevő, amelyet paraméterkijelölőnek is neveznek, egy 0-tól kezdődő szám, amely azonosítja az objektumok listájában szereplő megfelelő elemet. Vagyis az a formátumelem, amelynek paraméter-specifikációja 0, formázza a lista első objektumát. Az a formátumelem, amelynek paraméterkijelölője 1 a második objektumot formázza a listában, és így tovább. Az alábbi példában négy, nullától háromig számozott paraméter-meghatározó szerepel, amelyek 10-nél kisebb prímszámokat jelölnek:

string primes = string.Format("Four prime numbers: {0}, {1}, {2}, {3}",
                              2, 3, 5, 7);
Console.WriteLine(primes);

// The example displays the following output:
//      Four prime numbers: 2, 3, 5, 7

Dim primes As String = String.Format("Four prime numbers: {0}, {1}, {2}, {3}",
                                      2, 3, 5, 7)
Console.WriteLine(primes)

'The example displays the following output
'     Four prime numbers 2, 3, 5, 7

Több formátumelem is hivatkozhat ugyanarra az elemre az objektumok listájában ugyanazzal a paraméterkijelölővel. Ugyanazt a számértéket például hexadecimális, tudományos és számformátumban is formázhatja egy összetett formátumú sztring megadásával, például "0x{0:X} {0:E} {0:N}"az alábbi példában látható módon:

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

Minden formázási elem hivatkozhat a lista bármely objektumára. Ha például három objektum van, formázhatja az első, a második és a harmadik objektumot egy összetett formázási sztring, például {1} {0} {2}. A formátumelem által nem hivatkozott objektumok figyelmen kívül lesznek hagyva. Az A FormatException parancs futásidőben lesz eldobva, ha egy paraméter-meghatározó az objektumok listájának határain kívül eső elemet jelöl ki.

Szélesség komponens

Az opcionális width összetevő egy aláírt egész szám, amely az előnyben részesített formázott mezőszélességre utal. Ha az érték width kisebb, mint a formázott sztring hossza, width figyelmen kívül van hagyva, és a mezőszélesség megegyezik a formázott sztring hosszával. A mező formázott adatai jobbra vannak igazítva, ha width pozitív, és balra, ha width negatív. Ha paddingra van szükség, a rendszer fehér területet használ. A vessző megadása kötelező, ha width meg van adva.

Az alábbi példa két tömböt határoz meg, az egyik az alkalmazottak nevét tartalmazza, a másik pedig a két hét alatt ledolgozott órákat tartalmazza. Az összetett formátum karakterlánc balra igazítja a neveket egy 20 karakteres mezőben, és jobbra igazítja az órákat egy 5 karakteres mezőben. Az "N1" szabvány formátumú karakterlánc az órákat egy tizedesjeggyel formázza.

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 counter = 0; counter < names.Length; counter++)
    Console.WriteLine("{0,-20} {1,5:N1}", names[counter], hours[counter]);

// 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

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}\n", "Name", "Hours")

For counter = 0 To names.Length - 1
    Console.WriteLine("{0,-20} {1,5:N1}", names(counter), hours(counter))
Next

'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

Sztringösszetevő formázása

Az opcionális formatString összetevő egy formátumsztring, amely megfelel a formázott objektum típusának. Adhatja meg:

  • Standard vagy egyéni numerikus formátumú sztring, ha a megfelelő objektum numerikus érték.
  • Standard vagy egyéni dátum- és időformátum-sztring, ha a megfelelő objektum egy DateTime objektum.
  • Enumerálási formátum sztringje, ha a megfelelő objektum enumerálási érték.

Ha formatString nincs megadva, a rendszer a numerikus, dátum- és idő- vagy enumerálási típus általános ("G") formátum-megadóját használja. Ha formatString meg van adva, akkor a kettőspont megadása kötelező.

Az alábbi táblázat a .NET-osztálytár olyan típusait vagy kategóriáit sorolja fel, amelyek támogatják az előre definiált formázási sztringeket, és hivatkozásokat tartalmaz a támogatott formázási sztringeket listázó cikkekre. A sztringformázás egy bővíthető mechanizmus, amely lehetővé teszi az új formázási sztringek definiálását az összes meglévő típushoz, valamint az alkalmazás által definiált típus által támogatott formátumsztringek készletét.

További információkért tekintse meg a IFormattable és ICustomFormatter felületi cikkeket.

Típus vagy típuskategória Nézze
Dátum- és időtípusok (DateTime, DateTimeOffset) Szabványos dátum- és időformátum-karakterláncok

Egyéni dátum- és időformátum-karakterláncok
Enumerálási típusok (az összes System.Enum-ból származtatott típus) Sztringek számbavétele
Numerikus típusok (BigInteger, Byte, Decimal, Double, Int16, Int32, Int64SByte, SingleUInt16, UInt32, ) UInt64 Standard numerikus formátum karakterláncok

Egyéni numerikus formázási formátumok
Guid Guid.ToString(String)
TimeSpan Standard TimeSpan formátum karakterláncok

Egyéni Időtartam Formátum Sztringek

Kapcsos zárójelek kikerülése

A nyitó és záró kapcsos zárójelek formátum elem kezdő és befejező részeként értelmezendők. A szó szerinti nyitó vagy záró kapcsos zárójel megjelenítéséhez escape szekvenciát kell használnia. Adjon meg két nyitó zárójelet ({{) a rögzített szövegben egy nyitó zárójel ({) megjelenítéséhez, vagy két záró zárójelet (}}) egy záró zárójel (}) megjelenítéséhez.

A formátum elemet tartalmazó kapcsos zárójelek eltérően vannak elemezve a .NET és a .NET Framework között.

.NET

A kapcsos zárójelek egy formátumelem körül is megmenekülhetnek. Vegyük például a formátumelemet {{{0:D}}}, amely egy nyitó zárójelet, egy decimális számként formázott numerikus értéket és egy záró zárójelet jelenít meg. A formátumelem értelmezése a következő módon történik:

  1. Az első két nyitó kapcsos zárójel ({{) ki van ékelve, és egy nyitó kapcsos zárójelet eredményez.
  2. A következő három karakter ({0:) formátumelem kezdeteként lesz értelmezve.
  3. A következő karakter (D) a Decimális standard numerikus formátumkijelölőjeként lesz értelmezve.
  4. A következő zárójel (}) a formátumelem végeként lesz értelmezve.
  5. Az utolsó két záró kapcsos zárójel át van alakítva, és egy záró kapcsos zárójelet eredményez.
  6. A megjelenített végeredmény a literális karakterlánc, {6324}.
int value = 6324;
string output = string.Format("{{{0:D}}}", value);

Console.WriteLine(output);
// The example displays the following output:
//       {6324}

Dim value As Integer = 6324
Dim output As String = String.Format("{{{0:D}}}", value)

Console.WriteLine(output)

'The example displays the following output
'      {6324}

.NET-keretrendszer

A formátumelemekben szereplő kapcsos zárójelek az előfordulásuk sorrendjében lesznek értelmezve. A beágyazott zárójelek értelmezése nem támogatott.

Az elkerített kapcsos zárójelek értelmezése meglepő eredményekhez vezethet. Vegyük például a formátumelemet {{{0:D}}}, amely egy nyitó zárójelet, egy decimális számként formázott numerikus értéket és egy záró zárójelet jelenít meg. A formátumelem azonban a következő módon lesz értelmezve:

  1. Az első két nyitó kapcsos zárójel ({{) ki van ékelve, és egy nyitó kapcsos zárójelet eredményez.
  2. A következő három karakter ({0:) formátumelem kezdeteként lesz értelmezve.
  3. A következő karakter (D) a decimális számformátum szabványos választójaként van értelmezve, de a következő két escaped kapcsos zárójel (}}) egyetlen kapcsos zárójelet eredményez. Mivel az eredményül kapott sztring (D}) nem szabványos numerikus formátumkijelölő, az eredményül kapott sztringet egyéni formátumsztringként értelmezi a rendszer, amely a literális sztring D}megjelenítését jelenti.
  4. Az utolsó kapcsos zárójel (}) a formátumelem végeként lesz értelmezve.
  5. A megjelenített végeredmény a literális karakterlánc, {D}. A formázandó numerikus érték nem jelenik meg.
int value = 6324;
string output = string.Format("{{{0:D}}}",
                              value);
Console.WriteLine(output);

// The example displays the following output:
//       {D}

Dim value As Integer = 6324
Dim output As String = String.Format("{{{0:D}}}",
                                     value)
Console.WriteLine(output)

'The example displays the following output:
'      {D}

A kód írásának egyik módja, hogy elkerülje a megkülönböztetett kapcsos zárójelek és a formázási elemek félreértelmezését, ha külön formázza a kapcsos zárójeleket és a formázási elemeket. Ez azt jelenti, hogy az első formázási műveletben egy szó szerinti nyitó zárójel jelenik meg. A következő műveletben jelenítse meg a formátumelem eredményét, majd a végső műveletben jelenítsen meg egy szó szerinti zárójelet. Az alábbi példa a következő megközelítést szemlélteti:

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}

Megrendelés feldolgozása

Ha az összetett formázási metódus hívása olyan argumentumot tartalmaz IFormatProvider , amelynek értéke nem null, a futtatókörnyezet meghívja a metódust IFormatProvider.GetFormat , hogy implementációt ICustomFormatter kérjen. Ha a metódus vissza tud adni egy ICustomFormatter implementációt, az a hívás során gyorsítótárazódik az összetett formázási metódusban.

A paraméterlistában a formátumelemnek megfelelő értékek az alábbiak szerint lesznek sztringgé alakítva:

  1. Ha a formázandó érték az null, a rendszer üres sztringet String.Empty ad vissza.

  2. ICustomFormatter Ha egy implementáció elérhető, a futtatókörnyezet meghívja a metódustFormat. A futtatókörnyezet átadja a formátumelem formatString értékét (vagy null ha nem jelenik meg) a metódusnak. A futtatókörnyezet a IFormatProvider implementációt is átadja a metódusnak. Ha a ICustomFormatter.Format metódus hívása nullvisszatér, a végrehajtás a következő lépésre folytatódik. Ellenkező esetben a ICustomFormatter.Format hívás eredménye vissza lesz adva.

  3. Ha az érték implementálja az IFormattable interfészt, az interfész metódusa ToString(String, IFormatProvider) lesz meghívva. Ha az egyik szerepel a formátumelemben, az formatString értéket a rendszer átadja a metódusnak. Ellenkező esetben az null átadásra kerül. Az IFormatProvider argumentum meghatározása az alábbiak szerint történik:

  4. A típus paraméter nélküli ToString metódusa van meghívva, amely vagy felülbírálja a Object.ToString()-et, vagy örökli az alaposztály viselkedését. Ebben az esetben a rendszer figyelmen kívül hagyja a formatString formátumelem összetevője által megadott formátumsztringet, ha jelen van.

Az igazítás az előző lépések végrehajtása után lesz alkalmazva.

Példakódok

Az alábbi példa egy összetett formázással létrehozott karaktersorozatot és egy másikat mutat be, amelyet egy objektum metódusával ToString hoztak létre. Mindkét formázási típus egyenértékű eredményeket eredményez.

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")

Feltételezve, hogy az aktuális nap egy májusi csütörtök, az előző példában szereplő mindkét sztring értéke az amerikai angol kultúrában van Thursday May .

Console.WriteLine ugyanazt a funkciót teszi elérhetővé, mint a String.Format. A két metódus közötti egyetlen különbség az, hogy String.Format az eredményt sztringként adja vissza, míg Console.WriteLine az eredményt az objektumhoz társított kimeneti adatfolyamba Console írja. Az alábbi példa a Console.WriteLine metódust használja arra, hogy a myNumber értékét pénznemként formázza.

int myNumber = 100;
Console.WriteLine($"{myNumber:C}");

// The example displays the following output
// if en-US is the current culture:
//        $100.00

Dim myNumber As Integer = 100
Console.WriteLine("{0:C}", myNumber)

'The example displays the following output
'if en-US Is the current culture:
'       $100.00

Az alábbi példa több objektum formázását mutatja be, például egy objektum formázását két különböző módon:

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

Az alábbi példa a szélesség formázásban való használatát mutatja be. A formázott argumentumok függőleges sávkarakterek (|) közé kerülnek az eredményként kapott igazítás kiemeléséhez.

string firstName = "Fred";
string lastName = "Opals";
int myNumber = 100;

string formatFirstName = string.Format("First Name = |{0,10}|", firstName);
string formatLastName = string.Format("Last Name =  |{0,10}|", lastName);
string formatPrice = string.Format("Price =      |{0,10:C}|", myNumber);
Console.WriteLine(formatFirstName);
Console.WriteLine(formatLastName);
Console.WriteLine(formatPrice);
Console.WriteLine();

formatFirstName = string.Format("First Name = |{0,-10}|", firstName);
formatLastName = string.Format("Last Name =  |{0,-10}|", lastName);
formatPrice = string.Format("Price =      |{0,-10:C}|", myNumber);
Console.WriteLine(formatFirstName);
Console.WriteLine(formatLastName);
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 firstName As String = "Fred"
Dim lastName As String = "Opals"
Dim myNumber As Integer = 100

Dim formatFirstName As String = String.Format("First Name = |{0,10}|", firstName)
Dim formatLastName As String = String.Format("Last Name =  |{0,10}|", lastName)
Dim formatPrice As String = String.Format("Price =      |{0,10:C}|", myNumber)
Console.WriteLine(formatFirstName)
Console.WriteLine(formatLastName)
Console.WriteLine(formatPrice)
Console.WriteLine()

formatFirstName = String.Format("First Name = |{0,-10}|", firstName)
formatLastName = String.Format("Last Name =  |{0,-10}|", lastName)
formatPrice = String.Format("Price =      |{0,-10:C}|", myNumber)
Console.WriteLine(formatFirstName)
Console.WriteLine(formatLastName)
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   |

Lásd még

  • Last updated on