String.Format Metódus

Definíció

Névtér:: System

Szerelvények:: mscorlib.dll, System.Runtime.dll

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Az objektumok értékét sztringekké alakítja a megadott formátumok alapján, és beszúrja őket egy másik sztringbe.

Ha még nem használja a String.Format metódust, a Rövid áttekintésért tekintse meg a String.Format metódus első lépéseit .

Túlterhelések

Name	Description
Format(IFormatProvider, String, Object, Object, Object)	A sztringben lévő formázási elemeket három megadott objektum sztringképére cseréli. Egy paraméter kultúrára vonatkozó formázási információkat tartalmaz.
Format(IFormatProvider, String, Object, Object)	A sztringben lévő formázási elemeket két megadott objektum sztringképére cseréli. Egy paraméter kultúrára vonatkozó formázási információkat tartalmaz.
Format(String, Object, Object)	A sztringben lévő formázási elemeket két megadott objektum sztringképére cseréli.
Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)	A formázási elemet vagy elemeket CompositeFormat lecseréli a megadott formátumban lévő megfelelő objektumok sztringre történő megjelenítésére.
Format(IFormatProvider, CompositeFormat, Object[])	A formázási elemet vagy elemeket CompositeFormat lecseréli a megadott formátumban lévő megfelelő objektumok sztringre történő megjelenítésére.
Format(String, Object, Object, Object)	A sztringben lévő formázási elemeket három megadott objektum sztringképére cseréli.
Format(IFormatProvider, String, Object[])	A sztringben lévő formázási elemeket lecseréli egy adott tömb megfelelő objektumainak sztring-ábrázolásaira. Egy paraméter kultúrára vonatkozó formázási információkat tartalmaz.
Format(IFormatProvider, String, Object)	A megadott sztringben lévő formázási elemet vagy elemeket a megfelelő objektum sztringképére cseréli. Egy paraméter kultúrára vonatkozó formázási információkat tartalmaz.
Format(String, ReadOnlySpan<Object>)	A megadott sztring formázási elemét lecseréli egy adott sztringben lévő megfelelő objektum sztringre való megjelenítésére.
Format(String, Object[])	A megadott sztring formázási elemét lecseréli egy adott tömb megfelelő objektumának sztringre való megjelenítésére.
Format(String, Object)	Egy sztring egy vagy több formázási elemét lecseréli egy adott objektum sztringképére.
Format(IFormatProvider, String, ReadOnlySpan<Object>)	A sztringben lévő formázási elemeket lecseréli a megadott időtartamban lévő megfelelő objektumok sztring-ábrázolásaira. Egy paraméter kultúrára vonatkozó formázási információkat tartalmaz.
Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)	A formázási elemet vagy elemeket CompositeFormat lecseréli a megadott formátumban lévő megfelelő objektumok sztringre történő megjelenítésére.
Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)	A formázási elemet vagy elemeket CompositeFormat lecseréli a megadott formátumban lévő megfelelő objektumok sztringre történő megjelenítésére.
Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)	A formázási elemet vagy elemeket CompositeFormat lecseréli a megadott formátumban lévő megfelelő objektumok sztringre történő megjelenítésére.

Példák

Ebben a cikkben számos példa található, amelyek a Format metódust hívják meg. Letöltheti String.Format példák teljes készletét is, amelyek a C# .NET Core-projekt részét képezik.

Az alábbiakban néhány példát talál a cikkben:

Formátumlánc létrehozása

Karakterlánc beszúrása
A formátumelem
Azonos indexet tartalmazó elemek formázása

Ismerkedés a String.Format metódussal

Használja a String.Format, ha egy objektum, változó vagy kifejezés értékét egy másik sztringbe kell beszúrnia. Beszúrhatja például egy Decimal érték értékét egy sztringbe, hogy egyetlen sztringként jelenjen meg a felhasználó számára:

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.

let pricePerOunce = 17.36m
String.Format("The current price is {0} per ounce.", pricePerOunce)
|> printfn "%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.

Szabályozhatja az érték formázását:

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.

let pricePerOunce = 17.36m
String.Format("The current price is {0:C2} per ounce.", pricePerOunce)
|> printfn "%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.

A formázás mellett az igazítást és a szóközt is szabályozhatja.

Karakterlánc beszúrása

String.Format egy formázási sztringgel kezdődik, amelyet egy vagy több olyan objektum vagy kifejezés követ, amelyet sztringekké konvertálunk, és beszúrunk egy megadott helyre a formátumsztringben. Például:

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

let temp = 20.4m
String.Format("The temperature is {0}°C.", temp)
|> printfn "%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.'

A {0} a formátumstringben egy formátumelem. 0 annak az objektumnak az indexe, amelynek szövegértéke beillesztésre kerül az adott pozícióba. (Az indexek 0-nál kezdődnek.) Ha a beszúrni kívánt objektum nem sztring, a rendszer meghívja a ToString metódusát, hogy átalakítsa egyké, mielőtt beszúrja az eredménysztringbe.

Íme egy másik példa, amely két formátumelemet és két objektumot használ az objektumlistában:

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.'

String.Format("At {0}, the temperature is {1}°C.", DateTime.Now, 20.4)
|> printfn "%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.'

Az objektumlistában annyi formázási elem és objektum szerepelhet, amennyit csak szeretne, feltéve, hogy az összes formátumelem indexe tartalmaz egyező objektumot az objektumlistában. Nem kell aggódnia amiatt, hogy melyik függvény túlterhelést használja; a fordító kiválasztja a megfelelőt.

Formázás vezérlése

A formázási sztringgel rendelkező formázási elem indexét követve szabályozhatja az objektumok formázását. {0:d} például a "d" formátumú sztringet alkalmazza az objektumlista első objektumára. Íme egy példa egyetlen objektummal és két formázási elemet tartalmazó elemekkel:

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'

String.Format("It is now {0:d} at {0:t}", DateTime.Now)
|> printfn "%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'

Számos típus támogatja a formátumsztringeket, beleértve az összes numerikus típust (mind a standard, mind az egyéni formátumsztringeket), az összes dátumot és időpontot (mind a standard, mind az egyéni formátumsztringeket) és az időintervallumokat (standard és egyéni formátumsztringeket egyaránt), az enumerálási típusokat és a GUID-ket. A formátumsztringek támogatását a saját típusaihoz is hozzáadhatja.

Térköz szabályozása

Az eredménysztringbe beszúrt sztring szélességét olyan szintaxissal határozhatja meg, mint {0,12}például egy 12 karakterből álló sztring beszúrása. Ebben az esetben az első objektum sztringképe jobbra van igazítva a 12 karakteres mezőben. (Ha az első objektum sztring-ábrázolása több mint 12 karakter hosszúságú, akkor a rendszer figyelmen kívül hagyja az előnyben részesített mezőszélességeket, és a teljes sztring be lesz szúrva az eredménysztringbe.)

Az alábbi példa egy 6 karakter hosszú mezőt definiál az "Év" szöveg és néhány évszám tárolására, valamint egy 15 karakter hosszú mezőt a "Népesség" szöveg és néhány népesség adat tárolására. Vegye figyelembe, hogy a karakterek jobbra vannak igazítva a mezőben.

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

open System
open System.Text
 
let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let sb = StringBuilder()
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population")) |> ignore
for i = 0 to years.Length - 1 do
   sb.Append(String.Format("{0,6} {1,15:N0}\n", years[i], population[i])) |> ignore

printfn $"{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

Vezérlés igazítása

Alapértelmezés szerint a karakterláncok jobbra vannak igazítva a mezőn belül, ha megadja a mező szélességét. Ahhoz, hogy a szövegeket egy mezőben balra igazítsa, a mező szélességét negatív előjellel kell megadni, például {0,-12} egy 12 karakteres balra igazított mező meghatározásához.

Az alábbi példa hasonló az előzőhöz, azzal a kivételel, hogy balról igazítja a címkéket és az adatokat is.

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

let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let mutable s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population")
for i = 0 to years.Length - 1 do
    s <- s + String.Format("{0,-10} {1,-10:N0}\n", years[i], population[i])
printfn $"\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 az összetett formázási funkciót használja. További információ: Összetett formázás.

Melyik metódust hívhatom meg?

Objective	Meghívandó metódus
Egy vagy több objektum formázása az aktuális kultúra konvencióinak használatával.	A `provider` paramétert tartalmazó túlterhelések kivételével a fennmaradó Format túlterhelések közé tartozik egy String paraméter, amelyet egy vagy több objektumparaméter követ. Emiatt nem kell meghatároznia, hogy melyik Format túlterheléstípus kívánja meghívni. A nyelvi fordító az argumentumlista alapján kiválasztja a megfelelő túlterhelést azon túlterhelések közül, amelyek nem rendelkeznek `provider` paraméterrel. Ha például az argumentumlista öt argumentumot tartalmaz, a fordító meghívja a Format(String, Object[]) metódust.
Egy vagy több objektum formázása egy adott kultúra konvencióinak használatával.	Minden Format`provider` paraméterrel kezdődő túlterhelést egy String paraméter és egy vagy több objektumparaméter követi. Emiatt nem szükséges meghatározni, hogy melyik konkrét Format túlterhelést szeretné meghívni. A nyelvi fordító kiválasztja a megfelelő túlterhelést az argumentumlista alapján `provider` paraméterrel rendelkező túlterhelések közül. Ha például az argumentumlista öt argumentumot tartalmaz, a fordító meghívja a Format(IFormatProvider, String, Object[]) metódust.
Egyéni formázási műveletet hajthat végre ICustomFormatter implementációval vagy IFormattable implementációval.	A négy túlterhelés bármelyike `provider` paraméterrel. A fordító kiválasztja a megfelelő túlterhelést a `provider` paraméterrel rendelkező túlterhelések közül az argumentumlista alapján.

A Formátum metódus röviden

A Format metódus minden túlterhelése a összetett formázási funkciót használja, hogy nulla alapú indexelt helyőrzőket, az úgynevezett formázási elemeket, egy összetett formátumú sztringbe foglaljon bele. Futásidőben a rendszer minden formázási elemet lecserél a paraméterlistában szereplő megfelelő argumentum sztring reprezentációjára. Ha az argumentum értéke null, a formátumelem helyébe String.Emptykerül. A Format(String, Object, Object, Object) metódus következő hívása például egy formázási sztringet tartalmaz, amely három formázási elemet tartalmaz, {0}, {1}és {2}, valamint egy három elemet tartalmazó argumentumlistát.

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.

open System

let dat = DateTime(2012, 1, 17, 9, 30, 0) 
let city = "Chicago"
let temp = -16
String.Format("At {0} in {1}, the temperature was {2} degrees.", dat, city, temp)
|> printfn "%s"
// 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.

A formátumelem

A formátumelemek szintaxisa a következő:

{index[,width][:formatString]}

A zárójelek a választható elemeket jelölik. A nyitó és záró kapcsos zárójelek megléte kötelező. (Ha konstans nyitó vagy záró zárójelet szeretne belefoglalni a formátumsztringbe, tekintse meg a Kapcsos zárójelek szakaszt az Összetett formázás cikkben.)

Például egy pénznemérték formázására szolgáló formázási elem a következőképpen jelenhet meg:

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

open System

String.Format("{0,-10:C}", 126347.89m)         
|> printfn "%s"

String.Format("{0,-10:C}", 126347.89D)

A formátumelemek a következő elemeket tartalmaznak:

index
Annak az argumentumnak a nullaalapú indexe, amelynek sztringkénti megjelenítése szerepel ezen pozícióban a sztringben. Ha ez az argumentum null, a sztring ebben a pozícióban egy üres sztringet fog tartalmazni.

width
Optional. Aláírt egész szám, amely annak a mezőnek a teljes hosszát jelzi, amelybe az argumentumot beszúrják, és hogy jobbra igazított (pozitív egész szám) vagy balra igazított (negatív egész szám). Ha kihagyja width, a megfelelő argumentum sztring-ábrázolása be lesz szúrva egy olyan mezőbe, amelyben nincsenek bevezető vagy záró szóközök.

Ha az érték width kisebb, mint a beszúrni kívánt argumentum hossza, akkor a program figyelmen kívül hagyja, width és az argumentum sztring-ábrázolásának hosszát használja a mezőszélességként.

formatString
Optional. A megfelelő argumentum eredménysztringjének formátumát meghatározó sztring. Ha kihagyja formatString, a függvény meghívja a megfelelő argumentum paraméter nélküli ToString metódusát a sztring-ábrázolás létrehozásához. Ha megadja a formatString, akkor a formátumelem által hivatkozott argumentumnak implementálnia kell a IFormattable illesztőt. A formázási sztringeket támogató típusok a következők:

Minden integrál és lebegőpontos típus. (Lásd: Standard numerikus formátumú karakterláncok és egyéni numerikus formázási karakterláncok.)
DateTime és DateTimeOffset. (Lásd standard dátum- és időformátum-sztringek és egyéni dátum- és időformátum-sztringek.)
Minden enumerálási típus. (Lásd felsorolási formátum sztringek.)
TimeSpan értékek. (Lásd: Standard TimeSpan Format Strings és Custom TimeSpan Format Strings.)
Guid. (Lásd a Guid.ToString(String) módszert.)

Azonban bármely egyéni típus implementálhatja IFormattable vagy bővítheti egy meglévő típus implementációját IFormattable .

Az alábbi példa a width és formatString argumentumokat használja formázott kimenet létrehozásához.

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

// Create a list of 5-tuples with population data for three U.S. cities, 1940-1950.
let cities = 
    [ "Los Angeles", DateTime(1940, 1, 1), 1504277, DateTime(1950, 1, 1), 1970358
      "New York", DateTime(1940, 1, 1), 7454995, DateTime(1950, 1, 1), 7891957
      "Chicago", DateTime(1940, 1, 1), 3396808, DateTime(1950, 1, 1), 3620962
      "Detroit", DateTime(1940, 1, 1), 1623452, DateTime(1950, 1, 1), 1849568 ]

// Display header
String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n", "City", "Year", "Population", "Change (%)")
|> printfn "%s"

for name, year1, pop1, year2, pop2 in cities do
    String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                  name, year1, pop1, year2, pop2,
                  double (pop2 - pop1) / double pop1)
    |> printfn "%s"
// 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 Example4
    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 %

Argumentumok formázása

A formázási elemek a karakterlánc elejétől egymás után feldolgozásra kerülnek. Minden formázási elem rendelkezik egy indexel, amely megfelel a metódus argumentumlistájának egy objektumának. A Format metódus lekéri az argumentumot, és az alábbiak szerint nyeri ki annak sztring ábrázolását.

Ha az argumentum null, a metódus String.Empty szúr be az eredménysztringbe. Nem kell aggódnia a NullReferenceException kezelésével a null argumentumok esetén.
Ha a Format(IFormatProvider, String, Object[]) túlterhelést hív meg, és az provider objektum IFormatProvider.GetFormat implementációja nem null értékű ICustomFormatter implementációt ad vissza, az argumentumot a rendszer átadja a ICustomFormatter.Format(String, Object, IFormatProvider) metódusnak. Ha a formátumelem argumentumot formatString is tartalmaz, a rendszer az első argumentumként továbbítja a metódusnak. Ha a ICustomFormatter implementáció elérhető, és nem null értékű sztringet hoz létre, a rendszer az argumentum sztring-ábrázolásaként adja vissza a sztringet; ellenkező esetben a következő lépés végre lesz hajtva.
Ha az argumentum implementálja a IFormattable felületet, meghívja annak IFormattable.ToString implementációját.
A rendszer meghívja az argumentum paraméter nélküli ToString metódusát, amely felülbírálja vagy örökli az alaposztály implementációját.

Egy példa, amely elfogja a ICustomFormatter.Format metódus hívásait, és lehetővé teszi annak meglátását, hogy a Format metódus milyen információkat ad át egy formázási metódusnak az összetett formátumú karakterláncban található formátumelemenként, lásd, Egy elfogási szolgáltató és a római számformátum-formázó.

További információ: Rendelés feldolgozása.

Azonos indexű elemek formázása

A Format metódus a FormatException kivételt dobja, ha egy indexelem indexe nagyobb vagy egyenlő az argumentumlistában szereplő argumentumok számával. A format azonban több formázási elemet tartalmazhatnak, mint az argumentumok, amennyiben több formátumelem is rendelkezik ugyanazzal az indexel. A következő példában a Format(String, Object) metódus meghívása során az argumentumlista egyetlen argumentummal rendelkezik, de a formátumsztring két formátumelemet tartalmaz: az egyik egy szám tizedesjegyét, a másik pedig a hexadecimális értékét jeleníti meg.

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

open System

let values= [| Int16.MinValue; -27s; 0s; 1042s; Int16.MaxValue |]
printfn "%10s  %10s\n" "Decimal" "Hex"
for value in values do
    String.Format("{0,10:G}: {0,10:X}", value)
    |> printfn "%s"
// The example displays the following output:
//       Decimal         Hex
//    
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF

Module Example1
    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

Formátum és kultúra

Az argumentumlistában szereplő objektumok általában az aktuális kultúra konvencióinak használatával szöveggé konvertálódnak, és ez a kultúra a CultureInfo.CurrentCulture tulajdonság alapján kerül meghatározásra. Ezt a viselkedést a Format paramétert tartalmazó provider egyik túlterhelésének meghívásával szabályozhatja. A provider paraméter egy IFormatProvider implementáció, amely a formázási folyamat moderálásához használt egyéni és kultúraspecifikus formázási információkat nyújt.

A IFormatProvider felület egyetlen tagból áll, GetFormat, amely a formázási információkat tartalmazó objektum visszaadásáért felelős. A .NET három IFormatProvider implementációval rendelkezik, amelyek kultúraspecifikus formázást biztosítanak:

CultureInfo. A GetFormat metódus egy kultúraspecifikus NumberFormatInfo objektumot ad vissza a numerikus értékek formázásához, valamint egy kultúraspecifikus DateTimeFormatInfo objektumot a dátum- és időértékek formázásához.
DateTimeFormatInfo, amely a dátum- és időértékek kultúraspecifikus formázásához használatos. A GetFormat metódusa önmagát adja vissza.
NumberFormatInfo, amely a numerikus értékek kultúraspecifikus formázásához használatos. A GetFormat(Type) metódusa önmagát adja vissza.

Egyéni formázási műveletek

A Format metódus bármelyik olyan túlterhelését meghívhatja, amely provider típusú IFormatProvider paraméterrel rendelkezik, egyéni formázási műveletek végrehajtásának céljából. Egy egész számot például azonosító számként vagy telefonszámként is formázhat. Egyéni formázás végrehajtásához a provider argumentumnak a IFormatProvider és ICustomFormatter interfészeket is implementálnia kell. Amikor a Format metódus ICustomFormatter argumentumként provider implementációt ad át, a Format metódus meghívja a IFormatProvider.GetFormat implementációját, és egy ICustomFormattertípusú objektumot kér le. Ezután meghívja a visszaadott ICustomFormatter objektum Format metódusát a neki átadott összetett sztring egyes formázási elemeinek formázásához.

További információ az egyéni formázási megoldásokról: Egyéni numerikus formázási szolgáltatók definiálása és használata és ICustomFormatter. Az egész számokat formázott egyéni számokká konvertáló példa: Példa: Egyéni formázási művelet. Az aláíratlan bájtokat római számokká konvertáló példa: Példa: Metszetszolgáltató és római számformátumozó.

Példa: Egyéni formázási művelet

Ez a példa egy formátumszolgáltatót határoz meg, amely egy egész számot az x-xxxxx-xx űrlapon ügyfélfiókszámként formáz.

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.

open System

type CustomerFormatter() = 
    interface IFormatProvider with
        member this.GetFormat(formatType) =
            if formatType = typeof<ICustomFormatter> then
                this
            else
                null

    interface ICustomFormatter with
        member this.Format(format, arg, formatProvider: IFormatProvider) = 
            if this.Equals formatProvider |> not then
                null
            else
                let format = 
                    if String.IsNullOrEmpty format then "G"
                    else format.ToUpper()
                
                let customerString = 
                    let s = string arg
                    if s.Length < 8 then
                        s.PadLeft(8, '0')
                    else s
                
                match format with
                | "G" ->
                    customerString.Substring(0, 1) + "-" +
                        customerString.Substring(1, 5) + "-" +
                        customerString.Substring 6
                | "S" ->                          
                    customerString.Substring(0, 1) + "/" +
                        customerString.Substring(1, 5) + "/" +
                        customerString.Substring 6
                | "P" ->                          
                    customerString.Substring(0, 1) + "." +
                        customerString.Substring(1, 5) + "." +
                        customerString.Substring 6
                | _ ->
                    raise (FormatException $"The '{format}' format specifier is not supported.")

let acctNumber = 79203159
String.Format(CustomerFormatter(), "{0}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:G}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:S}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:P}", acctNumber)
|> printfn "%s"
try
    String.Format(CustomerFormatter(), "{0:X}", acctNumber)
    |> printfn "%s"
with :? FormatException as e ->
    printfn $"{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.

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.

Példa: Adatelfogási szolgáltató és római számok formázója

Ez a példa egy egyéni formátumszolgáltatót határoz meg, amely a ICustomFormatter és IFormatProvider interfészeket implementálja két dolog végrehajtásához:

Megjeleníti a ICustomFormatter.Format implementációnak átadott paramétereket. Ez lehetővé teszi, hogy lássuk, milyen paramétereket ad át a Format(IFormatProvider, String, Object[]) metódus az egyes formázni próbált objektumok egyéni formázási implementációjának. Ez hasznos lehet az alkalmazás hibakeresése során.
Ha a formázandó objektum egy aláíratlan bájtérték, amelyet az "R" standard formátumú sztring használatával kell formázni, az egyéni formázó római számként formázza a numerikus értéket.

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 FormatExample12
{
   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

open System
open System.Globalization

type InterceptProvider() =
    interface IFormatProvider with
        member this.GetFormat(formatType) =
            if formatType = typeof<ICustomFormatter> then
                this
            else
                null
    interface ICustomFormatter with
        member _.Format(format, obj, provider: IFormatProvider) = 
            // Display information about method call.
            let formatString =
                if format = null then "<null>" else format
            printfn $"Provider: {provider.GetType().Name}, Object: %A{obj}, Format String: %s{formatString}"
                                
            if obj = null then
                String.Empty
            else
                // If this is a byte and the "R" format string, format it with Roman numerals.
                match obj with
                | :? byte as value when formatString.ToUpper().Equals "R" -> 
                    let mutable returnString = String.Empty

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

                // Use default for all other formatting.
                | :? IFormattable as x ->
                    x.ToString(format, CultureInfo.CurrentCulture)
                | _ ->
                    string obj

let n = 10
let value = 16.935
let day = DateTime.Now
let provider = InterceptProvider()
String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day)
|> printfn "%s"
String.Format(provider, "{0}: {1:F}\n", "Today: ", DateTime.Now.DayOfWeek)
|> printfn "%s"
String.Format(provider, "{0:X}, {1}, {2}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
// 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 TypeOf obj Is IFormattable Then
         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

GYIK

Miért ajánlod a karakterlánc interpolációt a `String.Format` metódus hívásaival szemben?

A sztring interpolációja a következő:

Rugalmasabb. Bármilyen sztringben használható anélkül, hogy az összetett formázást támogató metódus hívására lenne szükség. Ellenkező esetben meg kell hívnia a Format metódust, vagy más olyan metódust, amely támogatja az összetett formázást, például Console.WriteLine vagy StringBuilder.AppendFormat.
Olvashatóbb. Mivel a sztringbe beszúrni kívánt kifejezés nem argumentumlistában, hanem interpolált kifejezésben jelenik meg, az interpolált sztringek könnyebben kódolva és olvashatók. Az interpolált sztringek a sztringösszefűzési műveletekben is használhatók tömörebb, világosabb kód létrehozásához.

A következő két példakód összehasonlítása szemlélteti, hogy az interpolált sztringek miért jobbak a sztringösszefűzésnél és az összetett formázási metódushívásoknál. A következő példában több sztringösszefűzési művelet használata részletes és nehezen olvasható kódot eredményez.

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.

open System

let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output = 
    names[0] + ", " + names[1] + ", " + names[2] + ", " + 
    names[3] + ", " + names[4] + ", " + names[5] + ", " + 
    names[6] + "\n"

let date = DateTime.Now
output + String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", date, date.DayOfWeek)
|> printfn "%s"
// 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 Example12
    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.

Ezzel szemben az interpolált sztringek az alábbi példában sokkal világosabb, tömörebb kódot eredményeznek, mint a sztringösszefűzési utasítás és az előző példában a Format metódus hívása.

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.

open System

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

let date = DateTime.Now
output + $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}."
|> printfn "%s" 
// 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 Example13
    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.

Hol találhatók az előre definiált formázási sztringek?

Az összes egész és lebegőpontos típusról lásd: Standard numerikus formátum és egyedi numerikus formátum.
A dátum- és időértékekhez lásd a Standard dátum- és időformátum karaktersorozatok és Custom dátum- és időformátum karaktersorozatok.
Az enumerálási értékekről lásd a Enumeráció formázási karakterláncokcímű témakört.
Az TimeSpan értékekről a Standard TimeSpan Format Strings és Custom TimeSpan Format Stringscímű cikkben olvashat.
Az Guid értékekért tekintse meg a Guid.ToString(String) referencialap Megjegyzések szakaszát.

Hogyan szabályozhatom a formázási elemeket helyettesítő eredménysztringek igazítását?

A formátumelem általános szintaxisa a következő:

{index[,width][: formatString]}

width egy aláírt egész szám, amely meghatározza a mező szélességét. Ha ez az érték negatív, a mezőben lévő szöveg balra igazítva lesz. Ha pozitív, a szöveg jobbra van igazítva.

Hogyan szabályozhatom a tizedesjel utáni számjegyek számát?

Az összes standard numerikus formátumú sztring lehetővé teszi egy precíziós megadást, amely meghatározza az eredménysztring tizedesjegyeinek számát, kivéve a "D" (amely csak egész számokkal használható), a "G", az "R" és az "X" formátumú képzéseket. Az alábbi példa standard numerikus formátumú sztringeket használ az eredménysztring tizedesjegyeinek számának szabályozásához.

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 %

open System

let values: obj list = [ 1603, 1794.68235, 15436.14 ]
for value in values do
   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.)
   |> printfn "%s"
// 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 Example7
    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 %

Ha egyéni numerikus formátumú sztringet használ, a "0" formátumjelölővel szabályozhatja az eredménysztring tizedesjegyeinek számát, ahogyan az alábbi példa mutatja.

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

let value = 16309.5436m
String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", value)
|> printfn "%s"
// The example displays the following output:
//        16309.54360    16,309.54    16309.544

Module Example8
    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

Hogyan szabályozhatom az integrál számjegyek számát?

Alapértelmezés szerint a formázási műveletek csak a nem nulla számjegyeket jelenítik meg. Egész számok formázása esetén a "D" és az "X" szabványos formátumsztringek használatával szabályozhatja a számjegyek számát.

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

open System

let value = 1326
String.Format("{0,10:D6} {0,10:X8}", value)
|> printfn "%s"
// The example displays the following output:
//     001326   0000052E

Module Example10
    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

Egy egész szám vagy lebegőpontos szám kezdő nullákkal való kitöltésével egy adott számú integráljegyet tartalmazó eredménysztringet hozhat létre a "0" egyéni numerikus formátumkijelölőhasználatával, ahogy az alábbi példa is mutatja.

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

open System

let value = 16342
String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", value)
|> printfn "%s"
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0

Module Example9
    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

Hány elemet vehetek fel a formátumlistában?

Nincs gyakorlati korlát. A Format(IFormatProvider, String, Object[]) metódus második paramétere a ParamArrayAttribute attribútummal van megjelölve, amely lehetővé teszi egy tagolt lista vagy egy objektumtömb formázási listaként való hozzáadását.

Hogyan lehet a kapcsos zárójeleket ("{" és "}") belefoglalni az eredményszövegbe?

Hogyan akadályozhatja meg például, hogy a következő metódushívás FormatException kivételt eredményezze?

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

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

Mindig egyetlen nyitó vagy záró kapcsos zárójelet formátumelem kezdeteként vagy végén értelmeznek. A szó szerinti értelmezéshez meg kell szökni. Úgy kerülheti el a kapcsos zárójelet, hogy kettős kapcsos zárójelet ad hozzá ("{{" és "}}" a "{" és "}" helyett), ahogyan a következő metódushívásnál:

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

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

Azonban még az elkerülő karakterekkel ellátott kapcsos zárójelek is könnyen félreértelmezhetők. Javasoljuk, hogy a formázási listában szerepeltesse a kapcsos zárójeleket, és a formázási elemek használatával szúrja be őket az eredményláncba, ahogyan az az alábbi példában látható.

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

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

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

Miért a String.Format metódus hívása a FormatException metódust adja vissza?

A kivétel leggyakoribb oka, hogy egy formátumelem indexe nem felel meg a formátumlistában szereplő objektumnak. Ez általában azt jelzi, hogy helytelenül számozták a formázási elemek indexeit, vagy elfelejtett egy objektumot felvenni a formátumlistában. Ha egy kibontatlan bal vagy jobb kapcsos zárójel karaktert próbál felvenni, az is FormatException-t dob. Esetenként a kivétel egy elírás eredménye; Egy tipikus hiba például a "[" (bal oldali zárójel) begépelése a "{" (a bal oldali zárójel) helyett.

Ha a Format(System.IFormatProvider,System.String,System.Object[]) metódus támogatja a paramétertömböket, miért okoz kivételt a kódom egy tömb használatakor?

A következő kód például FormatException kivételt eredményez:

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($"{numbers} + {1} + {2} = {3}");

open System

let rnd = Random()
let mutable total = 0
let numbers = Array.zeroCreate<int> 4
for i = 0 to 2 do
   let number = rnd.Next 1001
   numbers[i] <- number
   total <- total + number
numbers[3] <- total
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)


Module Example5a
    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

Ez a fordító túlterhelésének feloldásával kapcsolatos probléma. Mivel a fordító nem konvertálhat egész számokból álló tömböt objektumtömbbe, egyetlen argumentumként kezeli az egész tömböt, ezért meghívja a Format(String, Object) metódust. A kivétel azért van, mert négy formázási elem van, de csak egyetlen elem szerepel a formátumlistában.

Mivel sem a Visual Basic, sem a C# nem konvertálhat egész számokat objektumtömbökké, a Format(String, Object[]) metódus meghívása előtt saját maga kell elvégeznie az átalakítást. Az alábbi példa egy megvalósítást mutat be.

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($"{values} + {1} + {2} = {3}");

open System

let rnd = Random()
let numbers = Array.zeroCreate<int> 4
let mutable total = 0
for i = 0 to 2 do
   let number = rnd.Next 1001
   numbers[i] <- number
   total <- total + number
numbers[3] <- total
let values = Array.zeroCreate<obj> numbers.Length
numbers.CopyTo(values, 0)
Console.WriteLine("{0} + {1} + {2} = {3}", values)

Imports System.Collections.Generic

Module Example6
    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

Megjegyzések

Important

Ahelyett, hogy meghívja a String.Format metódust, vagy kompozit formátumú stringeket használna, interpolált stringeket is használhat, ha a nyelv támogatja őket. Az interpolált karakterlánc olyan, amely interpolált kifejezésekettartalmaz. 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ó: String interpoláció (C# referencia) és Interpolált sztringek (Visual Basic referencia).

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

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A sztringben lévő formázási elemeket három megadott objektum sztringképére cseréli. Egy paraméter kultúrára vonatkozó formázási információkat tartalmaz.

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

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

Paraméterek

provider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz.

format: String

Összetett formátumú sztring.

arg0: Object

Az első formázandó objektum.

arg1: Object

A második formázandó objektum.

arg2: Object

A harmadik formázandó objektum.

Válaszok

String

Annak a másolatnak a másolata format , amelyben a formátumelemek helyébe a következő sztringek arg0jelennek meg: , arg1és arg2.

Kivételek

ArgumentNullException

format az null.

FormatException

format érvénytelen.

-vagy-

A formátumelem indexe nullánál kisebb, vagy kettőnél nagyobb.

Megjegyzések

Important

Ez a módszer az összetett formázási funkcióval három kifejezést alakít át a sztringreprezentációkká, és beágyazza ezeket a reprezentációkat egy sztringbe. Az átalakítás végrehajtásakor a metódus kulturális szempontból érzékeny formázást vagy egyéni formázót használ. A metódus az egyes argumentumokat a Object metódus meghívásával, vagy ha az objektum megfelelő formátumeleme tartalmaz egy formátumsztringet, a ToString(String,IFormatProvider) metódus meghívásával konvertálja az egyes argumentumokat. Ha ezek a metódusok nem léteznek, meghívja az objektum paraméter nélküli ToString metódusát.

A metódus meghívásakor String.Format azonban nem szükséges a meghívni kívánt túlterhelésre összpontosítani. Ehelyett meghívhatja a metódust egy olyan objektummal, amely kultúraérzékeny vagy egyéni formázást biztosít, valamint egy vagy több formázási elemet tartalmazó összetett formázási sztringet . Minden formázási elemet numerikus indexként rendel hozzá; az első index 0-kor kezdődik. A kezdeti sztring mellett a metódushívásnak annyi további argumentumot kell megadnia, mint az indexértékeket. Például egy olyan sztringnek, amelynek formátumelemei 0 és 1 indexekkel rendelkeznek, 2 argumentummal kell rendelkezniük; A 0–5 indexekkel rendelkezőknek 6 argumentummal kell rendelkezniük. A nyelvi fordító ezután feloldja a metódus egy adott túlterhelésére irányuló metódushívást String.Format .

A metódus használatáról részletesebb dokumentációt a String.FormatString.Format metódus használatának első lépései és a Melyik metódus hívása című témakörben talál.

A következőre érvényes:

Format(IFormatProvider, String, Object, Object)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A sztringben lévő formázási elemeket két megadott objektum sztringképére cseréli. Egy paraméter kultúrára vonatkozó formázási információkat tartalmaz.

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

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

Paraméterek

provider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz.

format: String

Összetett formátumú sztring.

arg0: Object

Az első formázandó objektum.

arg1: Object

A második formázandó objektum.

Válaszok

String

Annak a másolatnak a másolataformat, amelyben a formátumelemek helyébe az és arg0a sztringek jelennek megarg1.

Kivételek

ArgumentNullException

format az null.

FormatException

format érvénytelen.

-vagy-

A formátumelem indexe nem nulla vagy egy.

Megjegyzések

Important

Ez a módszer az összetett formázási funkcióval konvertál két kifejezést sztringre, és beágyazza ezeket a reprezentációkat egy sztringbe. Az átalakítás végrehajtásakor a metódus kulturális szempontból érzékeny formázást vagy egyéni formázót használ. A metódus az egyes argumentumokat a Object metódus meghívásával, vagy ha az objektum megfelelő formátumeleme tartalmaz egy formátumsztringet, a ToString(String,IFormatProvider) metódus meghívásával konvertálja az egyes argumentumokat. Ha ezek a metódusok nem léteznek, meghívja az objektum paraméter nélküli ToString metódusát.

A metódus használatáról részletesebb dokumentációt a String.FormatString.Format metódus használatának első lépései és a Melyik metódus hívása című témakörben talál.

A következőre érvényes:

Format(String, Object, Object)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A sztringben lévő formázási elemeket két megadott objektum sztringképére cseréli.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);

public static string Format(string format, object arg0, 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

Paraméterek

format: String

Összetett formátumú sztring.

arg0: Object

Az első formázandó objektum.

arg1: Object

A második formázandó objektum.

Válaszok

String

Annak a másolatnak a másolataformat, amelyben a formátumelemek helyébe az és arg0a sztringek jelennek megarg1.

Kivételek

ArgumentNullException

format az null.

FormatException

format érvénytelen.

-vagy-

A formátumelem indexe nem nulla vagy egy.

Megjegyzések

Important

Ez a módszer az összetett formázási funkcióval konvertálja a két kifejezés értékét a sztringreprezentációkká, és beágyazza ezeket a reprezentációkat egy sztringbe.

A metódus meghívásakor String.Format azonban nem szükséges a meghívni kívánt túlterhelésre összpontosítani. Ehelyett meghívhatja a metódust egy összetett formázási sztringgel , amely egy vagy több formázási elemet tartalmaz. Minden formázási elemet numerikus indexként rendel hozzá; az első index 0-kor kezdődik. A kezdeti sztring mellett a metódushívásnak annyi további argumentumot kell megadnia, mint az indexértékeket. Például egy olyan sztringnek, amelynek formátumelemei 0 és 1 indexekkel rendelkeznek, 2 argumentummal kell rendelkezniük; A 0–5 indexekkel rendelkezőknek 6 argumentummal kell rendelkezniük. A nyelvi fordító ezután feloldja a metódus egy adott túlterhelésére irányuló metódushívást String.Format .

A metódus használatáról részletesebb dokumentációt a String.FormatString.Format metódus használatának első lépései és a Melyik metódus hívása című témakörben talál.

Példa: Két argumentum formázása

Ez a példa a metódust használja egy Format(String, Object, Object) általános Dictionary<TKey,TValue> objektumban tárolt idő- és hőmérsékletadatok megjelenítésére. Vegye figyelembe, hogy a formátumsztring három formátumelemet tartalmaz, bár csak két objektumot kell formázni. Ennek az az oka, hogy a lista első objektumát (dátum- és időértéket) két formátumelem használja: az első formátumelem az időt, a második pedig a dátumot.

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

open System
open System.Collections.Generic

let temperatureInfo = Dictionary<DateTime, float>() 
temperatureInfo.Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46)
temperatureInfo.Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81)

printfn $"Temperature Information:\n"
for item in temperatureInfo do
   String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", item.Key, item.Value)
   |> printfn "%s"
// 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

Lásd még

A következőre érvényes:

Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A formázási elemet vagy elemeket CompositeFormat lecseréli a megadott formátumban lévő megfelelő objektumok sztringre történő megjelenítésére.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, ReadOnlySpan<System::Object ^> args);

public static string Format(IFormatProvider? provider, System.Text.CompositeFormat format, scoped ReadOnlySpan<object?> args);

public static string Format(IFormatProvider? provider, System.Text.CompositeFormat format, ReadOnlySpan<object?> args);

static member Format : IFormatProvider * System.Text.CompositeFormat * ReadOnlySpan<obj> -> string

Public Shared Function Format (provider As IFormatProvider, format As CompositeFormat, args As ReadOnlySpan(Of Object)) As String

Paraméterek

provider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz.

format: CompositeFormat

Egy CompositeFormat.

args: ReadOnlySpan<Object>

Formázandó objektumok száma.

Válaszok

String

A formázott sztring.

Kivételek

ArgumentNullException

format az null.

FormatException

A formátumelem indexe nagyobb vagy egyenlő a megadott argumentumok számával.

A következőre érvényes:

Format(IFormatProvider, CompositeFormat, Object[])

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A formázási elemet vagy elemeket CompositeFormat lecseréli a megadott formátumban lévő megfelelő objektumok sztringre történő megjelenítésére.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, ... cli::array <System::Object ^> ^ args);

public static string Format(IFormatProvider? provider, System.Text.CompositeFormat format, params object?[] args);

static member Format : IFormatProvider * System.Text.CompositeFormat * obj[] -> string

Public Shared Function Format (provider As IFormatProvider, format As CompositeFormat, ParamArray args As Object()) As String

Paraméterek

provider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz.

format: CompositeFormat

Egy CompositeFormat.

args: Object[]

Formázandó objektumok tömbje.

Válaszok

String

A formázott sztring.

Kivételek

ArgumentNullException

format vagy args az null.

FormatException

A formátumelem indexe nagyobb vagy egyenlő a megadott argumentumok számával.

A következőre érvényes:

Format(String, Object, Object, Object)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A sztringben lévő formázási elemeket három megadott objektum sztringképére cseréli.

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

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

Paraméterek

format: String

Összetett formátumú sztring.

arg0: Object

Az első formázandó objektum.

arg1: Object

A második formázandó objektum.

arg2: Object

A harmadik formázandó objektum.

Válaszok

String

Annak a másolatnak a másolata format , amelyben a formátumelemek helyébe a következő sztringek arg0jelennek meg: , arg1és arg2.

Kivételek

ArgumentNullException

format az null.

FormatException

format érvénytelen.

-vagy-

A formátumelem indexe nullánál kisebb, vagy kettőnél nagyobb.

Megjegyzések

Important

Ez a módszer az összetett formázási funkcióval konvertálja a három kifejezés értékét a sztringreprezentációkká, és beágyazza ezeket a reprezentációkat egy sztringbe.

A metódus használatáról részletesebb dokumentációt a String.FormatString.Format metódus használatának első lépései és a Melyik metódus hívása című témakörben talál.

Példa: Három argumentum formázása

Ez a példa a Format(String, Object, Object, Object) metódus használatával hoz létre egy sztringet, amely egy logikai And művelet eredményét szemlélteti két egész számmal. Vegye figyelembe, hogy a formátumsztring hat formázási elemet tartalmaz, de a metódus csak három elemet tartalmaz a paraméterlistában, mivel mindegyik elem kétféleképpen van formázva.

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)

open System

let formatString = 
    "    {0,10} ({0,8:X8})\nAnd {1,10} ({1,8:X8})\n  = {2,10} ({2,8:X8})"

let value1 = 16932
let value2 = 15421
String.Format(formatString, value1, value2, value1 &&& value2)
|> printfn "%s"
// 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)

Lásd még

A következőre érvényes:

Format(IFormatProvider, String, Object[])

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A sztringben lévő formázási elemeket lecseréli egy adott tömb megfelelő objektumainak sztring-ábrázolásaira. Egy paraméter kultúrára vonatkozó formázási információkat tartalmaz.

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

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

Paraméterek

provider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz.

format: String

Összetett formátumú sztring.

args: Object[]

Olyan objektumtömb, amely nulla vagy több formázandó objektumot tartalmaz.

Válaszok

String

Annak a másolatnak a másolata format , amelyben a formátumelemek helyébe a megfelelő objektumok argssztring-ábrázolása került.

Kivételek

ArgumentNullException

format vagy args az null.

FormatException

format érvénytelen.

-vagy-

A formátumelem indexe kisebb, mint nulla, vagy nagyobb, mint a args tömb hossza.

Megjegyzések

Important

Ez a módszer az összetett formázási funkcióval konvertál négy vagy több kifejezést a sztringreprezentációkká, és beágyazza ezeket a reprezentációkat egy sztringbe. Az átalakítás végrehajtásakor a metódus kulturális szempontból érzékeny formázást vagy egyéni formázót használ. A metódus az egyes argumentumokat a Object metódus meghívásával, vagy ha az objektum megfelelő formátumeleme tartalmaz egy formátumsztringet, a ToString(String,IFormatProvider) metódus meghívásával konvertálja az egyes argumentumokat. Ha ezek a metódusok nem léteznek, meghívja az objektum paraméter nélküli ToString metódusát.

A metódus használatáról részletesebb dokumentációt a String.FormatString.Format metódus használatának első lépései és a Melyik metódus hívása című témakörben talál.

Példa: Kultúraérzékeny formázás

Ez a példa a Format(IFormatProvider, String, Object[]) metódussal jeleníti meg bizonyos dátum- és időértékek, valamint numerikus értékek sztringképét több különböző kultúra használatával.

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

open System
open System.Globalization

let cultureNames = [| "en-US"; "fr-FR"; "de-DE"; "es-ES" |]

let dateToDisplay = DateTime(2009, 9, 1, 18, 32, 0)
let value = 9164.32

printfn "Culture     Date                                Value\n"
for cultureName in cultureNames do
    let culture = CultureInfo cultureName
    String.Format(culture, "{0,-11} {1,-35:D} {2:N}", culture.Name, dateToDisplay, value)
    |> printfn "%s"
// 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 Example2
   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

Lásd még

A következőre érvényes:

Format(IFormatProvider, String, Object)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A megadott sztringben lévő formázási elemet vagy elemeket a megfelelő objektum sztringképére cseréli. Egy paraméter kultúrára vonatkozó formázási információkat tartalmaz.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0);

public static string Format(IFormatProvider provider, string format, 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

Paraméterek

provider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz.

format: String

Összetett formátumú sztring.

arg0: Object

A formázandó objektum.

Válaszok

String

Annak a példánynak a másolata format , amelyben a formátumelem vagy elemek helyébe a következő sztring látható arg0:

Kivételek

ArgumentNullException

format az null.

FormatException

format érvénytelen.

-vagy-

A formátumelem indexe nem nulla.

Megjegyzések

Important

Ez a metódus az összetett formázási funkcióval konvertálja egy kifejezés értékét a sztringre, és beágyazza azt egy sztringbe. Az átalakítás végrehajtásakor a metódus kulturális szempontból érzékeny formázást vagy egyéni formázót használ. A metódus a arg0 metódus meghívásával, vagy ha az objektum megfelelő formátumeleme tartalmaz egy formátumsztringet, a ToString(String,IFormatProvider) metódus meghívásával konvertálja a sztringre. Ha ezek a metódusok nem léteznek, meghívja az objektum paraméter nélküli ToString metódusát.

A metódus használatáról részletesebb dokumentációt a String.FormatString.Format metódus használatának első lépései és a Melyik metódus hívása című témakörben talál.

A következőre érvényes:

Format(String, ReadOnlySpan<Object>)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A megadott sztring formázási elemét lecseréli egy adott sztringben lévő megfelelő objektum sztringre való megjelenítésére.

public:
 static System::String ^ Format(System::String ^ format, ReadOnlySpan<System::Object ^> args);

public static string Format(string format, scoped ReadOnlySpan<object?> args);

static member Format : string * ReadOnlySpan<obj> -> string

Public Shared Function Format (format As String, args As ReadOnlySpan(Of Object)) As String

Paraméterek

format: String

Összetett formátumú sztring.

args: ReadOnlySpan<Object>

Olyan objektumfedés, amely nulla vagy több formázandó objektumot tartalmaz.

Válaszok

String

Annak a másolatnak a másolata format , amelyben a formátumelemek helyébe a megfelelő objektumok argssztring-ábrázolása került.

A következőre érvényes:

Format(String, Object[])

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A megadott sztring formázási elemét lecseréli egy adott tömb megfelelő objektumának sztringre való megjelenítésére.

public:
 static System::String ^ Format(System::String ^ format, ... cli::array <System::Object ^> ^ args);

public static string Format(string format, params 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

Paraméterek

format: String

Összetett formátumú sztring.

args: Object[]

Olyan objektumtömb, amely nulla vagy több formázandó objektumot tartalmaz.

Válaszok

String

Annak a másolatnak a másolata format , amelyben a formátumelemek helyébe a megfelelő objektumok argssztring-ábrázolása került.

Kivételek

ArgumentNullException

format vagy args az null.

FormatException

format érvénytelen.

-vagy-

A formátumelem indexe kisebb, mint nulla, vagy nagyobb, mint a args tömb hossza.

Megjegyzések

Important

Ez a módszer az összetett formázási funkcióval konvertálja a négy vagy több kifejezés értékét a sztringreprezentációkká, és beágyazza ezeket a reprezentációkat egy sztringbe. Mivel a args paraméter az attribútummal System.ParamArrayAttribute van megjelölve, az objektumokat egyéni argumentumként vagy tömbként is átadhatja a metódusnak Object .

A metódus használatáról részletesebb dokumentációt a String.FormatString.Format metódus használatának első lépései és a Melyik metódus hívása című témakörben talál.

Példa: Háromnál több argumentum formázása

Ez a példa létrehoz egy sztringet, amely egy adott dátum magas és alacsony hőmérsékletén lévő adatokat tartalmaz. Az összetett formázási sztring a C# példában öt, a Visual Basic példában pedig hat formátumelemet tartalmaz. A formátumelemek közül kettő határozza meg a megfelelő érték sztring-ábrázolásának szélességét, az első formátumelem pedig egy szabványos dátum- és időformátum-sztringet is tartalmaz.

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)

let date1 = DateTime(2009, 7, 1)
let hiTime = TimeSpan(14, 17, 32)
let hiTemp = 62.1m 
let loTime = TimeSpan(3, 16, 10)
let loTemp = 54.8m 

String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", date1, hiTime, hiTemp, loTime, loTemp)
|> printfn "%s\n"
      
String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", [| date1 :> obj; hiTime; hiTemp; loTime; loTemp |])
|> printfn "%s"
// 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)

Az argumentumlista helyett tömbként formázandó objektumokat is átadhatja.

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 FormatExample10
{
   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

open System

type CityInfo =
  { Name: string
    Population: int
    Area: Decimal
    Year: int }

let showPopulationData city =
    let args: obj[] = [| city.Name; city.Year; city.Population; city.Area |]
    String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", args)
    |> printfn "%s"

{ Name = "New York"; Population = 8175133; Area = 302.64m; Year = 2010 }
|> showPopulationData

 
{ Name = "Seattle"; Population = 608660; Area = 83.94m; Year = 2010 }      
|> showPopulationData 

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

Lásd még

A következőre érvényes:

Format(String, Object)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Egy sztring egy vagy több formázási elemét lecseréli egy adott objektum sztringképére.

public:
 static System::String ^ Format(System::String ^ format, System::Object ^ arg0);

public static string Format(string format, 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

Paraméterek

format: String

Összetett formátumú sztring.

arg0: Object

A formázandó objektum.

Válaszok

String

Annak a másolatnak a másolata format , amelyben a formátumelemek helyébe a következő sztringek jelennek meg arg0:

Kivételek

ArgumentNullException

format az null.

FormatException

A formátumelem format érvénytelen.

-vagy-

A formátumelem indexe nem nulla.

Megjegyzések

Important

Ez a metódus az összetett formázási funkcióval konvertálja egy kifejezés értékét a sztringre, és beágyazza azt egy sztringbe.

A metódus használatáról részletesebb dokumentációt a String.FormatString.Format metódus használatának első lépései és a Melyik metódus hívása című témakörben talál.

Példa: Egyetlen argumentum formázása

Az alábbi példa a Format(String, Object) metódus használatával ágyazza be az egyén életkorát egy sztring közepébe.

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.

let birthdate = DateTime(1993, 7, 28)
let dates = 
    [ DateTime(1993, 8, 16) 
      DateTime(1994, 7, 28)
      DateTime(2000, 10, 16)
      DateTime(2003, 7, 27)
      DateTime(2007, 5, 27) ]

for dateValue in dates do
    let interval = dateValue - birthdate
    // Get the approximate number of years, without accounting for leap years.
    let years = (int interval.TotalDays) / 365
    // See if adding the number of years exceeds dateValue.
    if birthdate.AddYears years <= dateValue then
        String.Format("You are now {0} years old.", years)
    else
        String.Format("You are now {0} years old.", years - 1)
    |> printfn "%s"
// 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.

Lásd még

A következőre érvényes:

Format(IFormatProvider, String, ReadOnlySpan<Object>)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A sztringben lévő formázási elemeket lecseréli a megadott időtartamban lévő megfelelő objektumok sztring-ábrázolásaira. Egy paraméter kultúrára vonatkozó formázási információkat tartalmaz.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, ReadOnlySpan<System::Object ^> args);

public static string Format(IFormatProvider? provider, string format, scoped ReadOnlySpan<object?> args);

static member Format : IFormatProvider * string * ReadOnlySpan<obj> -> string

Public Shared Function Format (provider As IFormatProvider, format As String, args As ReadOnlySpan(Of Object)) As String

Paraméterek

provider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz.

format: String

Összetett formátumú sztring.

args: ReadOnlySpan<Object>

Olyan objektumfedés, amely nulla vagy több formázandó objektumot tartalmaz.

Válaszok

String

Annak a másolatnak a másolata format , amelyben a formátumelemek helyébe a megfelelő objektumok argssztring-ábrázolása került.

A következőre érvényes:

Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A formázási elemet vagy elemeket CompositeFormat lecseréli a megadott formátumban lévő megfelelő objektumok sztringre történő megjelenítésére.

public:
generic <typename TArg0, typename TArg1, typename TArg2>
 static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0, TArg1 arg1, TArg2 arg2);

public static string Format<TArg0,TArg1,TArg2>(IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0, TArg1 arg1, TArg2 arg2);

static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 * 'TArg1 * 'TArg2 -> string

Public Shared Function Format(Of TArg0, TArg1, TArg2) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0, arg1 As TArg1, arg2 As TArg2) As String

Típusparaméterek

TArg0

Az első formázandó objektum típusa.

TArg1

A formázandó második objektum típusa.

TArg2

A formázandó harmadik objektum típusa.

Paraméterek

provider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz.

format: CompositeFormat

Egy CompositeFormat.

arg0: TArg0

Az első formázandó objektum.

arg1: TArg1

A második formázandó objektum.

arg2: TArg2

A harmadik formázandó objektum.

Válaszok

String

A formázott sztring.

Kivételek

ArgumentNullException

format az null.

FormatException

A formátumelem indexe nagyobb vagy egyenlő a megadott argumentumok számával.

A következőre érvényes:

Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A formázási elemet vagy elemeket CompositeFormat lecseréli a megadott formátumban lévő megfelelő objektumok sztringre történő megjelenítésére.

public:
generic <typename TArg0, typename TArg1>
 static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0, TArg1 arg1);

public static string Format<TArg0,TArg1>(IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0, TArg1 arg1);

static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 * 'TArg1 -> string

Public Shared Function Format(Of TArg0, TArg1) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0, arg1 As TArg1) As String

Típusparaméterek

TArg0

Az első formázandó objektum típusa.

TArg1

A formázandó második objektum típusa.

Paraméterek

provider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz.

format: CompositeFormat

Egy CompositeFormat.

arg0: TArg0

Az első formázandó objektum.

arg1: TArg1

A második formázandó objektum.

Válaszok

String

A formázott sztring.

Kivételek

ArgumentNullException

format az null.

FormatException

A formátumelem indexe nagyobb vagy egyenlő a megadott argumentumok számával.

A következőre érvényes:

Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

Forrás:: String.Manipulation.cs

A formázási elemet vagy elemeket CompositeFormat lecseréli a megadott formátumban lévő megfelelő objektumok sztringre történő megjelenítésére.

public:
generic <typename TArg0>
 static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0);

public static string Format<TArg0>(IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0);

static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 -> string

Public Shared Function Format(Of TArg0) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0) As String

Típusparaméterek

TArg0

Az első formázandó objektum típusa.

Paraméterek

provider: IFormatProvider

Egy objektum, amely kultúraspecifikus formázási információkat tartalmaz.

format: CompositeFormat

Egy CompositeFormat.

arg0: TArg0

Az első formázandó objektum.

Válaszok

String

A formázott sztring.

Kivételek

ArgumentNullException

format az null.

FormatException

A formátumelem indexe nagyobb vagy egyenlő a megadott argumentumok számával.

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?

String.Format Metódus

Definíció

Túlterhelések

Példák

Formátumlánc létrehozása

Formázott kimenet vezérlése

Tegyük a formátum-sztringeket kultúrafüggővé

A formázási művelet testreszabása

Ismerkedés a String.Format metódussal

Karakterlánc beszúrása

Formázás vezérlése

Térköz szabályozása

Vezérlés igazítása

Melyik metódust hívhatom meg?

A Formátum metódus röviden

A formátumelem

Argumentumok formázása

Azonos indexű elemek formázása

Formátum és kultúra

Egyéni formázási műveletek

Példa: Egyéni formázási művelet

Példa: Adatelfogási szolgáltató és római számok formázója

GYIK

Miért ajánlod a karakterlánc interpolációt a String.Format metódus hívásaival szemben?

Hol találhatók az előre definiált formázási sztringek?

Hogyan szabályozhatom a formázási elemeket helyettesítő eredménysztringek igazítását?

Hogyan szabályozhatom a tizedesjel utáni számjegyek számát?

Hogyan szabályozhatom az integrál számjegyek számát?

Hány elemet vehetek fel a formátumlistában?

Hogyan lehet a kapcsos zárójeleket ("{" és "}") belefoglalni az eredményszövegbe?

Miért a String.Format metódus hívása a FormatException metódust adja vissza?

Ha a Format(System.IFormatProvider,System.String,System.Object[]) metódus támogatja a paramétertömböket, miért okoz kivételt a kódom egy tömb használatakor?

Megjegyzések

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

Paraméterek

Válaszok

Kivételek

Megjegyzések

A következőre érvényes:

Format(IFormatProvider, String, Object, Object)

Paraméterek

Válaszok

Kivételek

Megjegyzések

A következőre érvényes:

Format(String, Object, Object)

Paraméterek

Válaszok

Kivételek

Megjegyzések

Példa: Két argumentum formázása

Lásd még

A következőre érvényes:

Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)

Paraméterek

Válaszok

Kivételek

A következőre érvényes:

Format(IFormatProvider, CompositeFormat, Object[])

Paraméterek

Válaszok

Kivételek

A következőre érvényes:

Format(String, Object, Object, Object)

Paraméterek

Válaszok

Kivételek

Megjegyzések

Példa: Három argumentum formázása

Lásd még

A következőre érvényes:

Format(IFormatProvider, String, Object[])

Paraméterek

Válaszok

Kivételek

Megjegyzések

Példa: Kultúraérzékeny formázás

Lásd még

A következőre érvényes:

Format(IFormatProvider, String, Object)

Miért ajánlod a karakterlánc interpolációt a `String.Format` metódus hívásaival szemben?