Összetett formázás

  • Cikk

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 sztringek olyan rögzített szövegből állnak, amely indexelt helyőrzőkkel, úgynevezett formátumelemekkel van elegyítve. 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. Minden interpolált kifejezés feloldva van a kifejezés értékével, és a sztring hozzárendelésekor az eredménysztring része lesz. 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 sztring

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övegfuttatásból állnak, amelyek egy vagy több formázási elemhez kapcsolódnak. A rögzített szöveg tetszőleges tetszőleges sztring, és minden formázási elem egy objektumnak vagy egy dobozos szerkezetnek felel meg a listában. 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 és , hours = a Name = . A formátumelemek azok {0}, amelyek 0 indexe az objektumnak namefelel meg, és {1:hh}amelyek 1 indexe az objektumnak DateTime.Nowfelel meg.

Elem szintaxisának formázása

Minden formázási elem a következő űrlapot veszi fel, és a következő összetevőkből áll:

{index[,alignment][: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-megadója 0 a lista első objektumának formázása. 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.Format("Name = {0}, hours = {1:hh}", "Fred", DateTime.Now);

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

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 a második, az első és a harmadik objektumot egy összetett formázási sztring, például {1} {0} {2}a . 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.

Igazítási összetevő

Az opcionális igazítási összetevő egy aláírt egész szám, amely az előnyben részesített formázott mezőszélességre utal. Ha az igazítás értéke kisebb, mint a formázott sztring hossza, a program figyelmen kívül hagyja az igazítást, és a formázott sztring hosszát használja a mezőszélességként. A mezőben a formázott adatok jobbra vannak igazítva, ha az igazítás pozitív, és balról igazított, ha az igazítás negatív. Ha paddingra van szükség, a rendszer fehér területet használ. Ha az igazítás meg van adva, vesszőre van szükség.

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 sztringje balra igazítja a neveket egy 20 karakteres mezőben, és jobbra igazítja az óráikat egy 5 karakteres mezőben. Az "N1" standard formátumú sztring az órákat egy tört számjegygel 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. Megadhatja a következőket:

  • 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 objektum DateTime .
  • Enumerálási formátum sztringje , ha a megfelelő objektum enumerálási érték.

Ha a formatString nincs megadva, a függvény numerikus, dátum- és idő- vagy enumerálási típus általános ("G") formátumkijelölőt használ. A formatString megadása esetén 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 cikkeket és ICustomFormatter a IFormattable felületi cikkeket.

Típus- vagy típuskategória Lásd:
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 származtatási System.Enumtípus) Sztringek számbavétele
Numerikus típusok (BigInteger, Byte, Decimal, Double, Int16, Int32, Int64SByte, SingleUInt16, UInt32, ) UInt64 Standard numerikus formázó sztringek

Egyéni numerikus formázási sztringek
Guid Guid.ToString(String)
TimeSpan Standard TimeSpan Formátum sztringek

Egyéni TimeSpan formátumsztringek

Kapcsos zárójelek menekülése

A nyitó és záró kapcsos zárójelek formátumelem kezdő és záró elemként vannak értelmezve. A konstans nyitó vagy záró kapcsos zárójel megjelenítéséhez menekülési sorozatot 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ázó elemhez tartozó kapcsos zárójelek a .NET és a .NET-keretrendszer között eltérően vannak elemezve.

.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 ({{) megmenekül, és egy nyitó kapcsos zárójelet ad.
  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 megmenekül, és egy záró kapcsos zárójelet ad.
  6. A megjelenített végeredmény a literális sztring. {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átumelemek kapcsos zárójelei egymás után, a talált sorrendben lesznek értelmezve. A beágyazott zárójelek értelmezése nem támogatott.

A megmenekült kapcsos zárójelek értelmezése váratlan 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 ({{) megmenekül, és egy nyitó kapcsos zárójelet ad.
  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átumválasztóként lesz értelmezve, de a következő két 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 sztring. {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 megmenekült kapcsos zárójelek félreértelmezését és az elemek formázását, ha külön formázza a kapcsos zárójeleket és az elemeket. Ez azt jelzi, hogy az első formátumműveletben egy konstans 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 megjelenítsen egy konstans záró 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 visszaad egy implementációt ICustomFormatter , az összetett formázási metódus hívása során gyorsítótárazza.

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 az implementációt IFormatProvider 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 hívás eredménye ICustomFormatter.Format lesz visszaadva.

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

  4. A rendszer meghívja a típus paraméter nélküli ToString metódusát, amely felülbírálja Object.ToString() 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.

Kódpéldák

Az alábbi példa egy összetett formázással létrehozott sztringet, egy másikat pedig egy objektum metódusával ToString hozott 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 metódust használja a Console.WriteLine pénznemértékek értékének formázására myNumber :

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

// 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 az igazítás 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