Áttekintés: Számok, dátumok, enumerálások és egyéb típusok formázása a .NET-ben
A formázás egy osztály vagy struktúra egy példányának vagy enumerálási értékének sztring-ábrázolássá alakításának folyamata. A cél az, hogy az eredményül kapott sztring megjelenjen a felhasználók számára, vagy később deszerializálja az eredeti adattípus visszaállításához. Ez a cikk bemutatja a .NET által biztosított formázási mechanizmusokat.
Feljegyzés
Az elemzés a formázás inverze. Az elemzési művelet egy adattípus egy példányát hozza létre a sztring-ábrázolásból. További információ: Sztringek elemzése. A szerializálással és a deszerializálással kapcsolatos információkért lásd: Szerializálás a .NET-ben.
A formázás alapvető mechanizmusa a metódus alapértelmezett implementációja Object.ToString , amelyet a jelen témakör későbbi, Alapértelmezett formázás a ToString metódus használatával című szakaszában olvashat. A .NET azonban számos módot kínál az alapértelmezett formázási támogatás módosítására és kiterjesztésére. Ezek a következők:
Felül kell bírálni az Object.ToString objektum értékének egyéni sztring-ábrázolását meghatározó metódust. További információ: A ToString metódus felülbírálása szakasz a jelen témakör későbbi részében.
Olyan formátumjelölők definiálása, amelyek lehetővé teszik egy objektum értékének sztring-ábrázolását, hogy több űrlapot is használjon. Az "X" formátumválasztó például az alábbi utasításban egy egész számot hexadecimális érték sztring-ábrázolására konvertál.
int integerValue = 60312; Console.WriteLine(integerValue.ToString("X")); // Displays EB98.Dim integerValue As Integer = 60312 Console.WriteLine(integerValue.ToString("X")) ' Displays EB98.A formátumkijelölőkkel kapcsolatos további információkért tekintse meg a ToString Metódus és a Sztringek formázása szakaszt .
Formátumszolgáltatók használata egy adott kultúra formázási konvencióinak implementálásához. Az alábbi utasítás például egy pénznemértéket jelenít meg az en-US kultúra formázási konvencióit használva.
double cost = 1632.54; Console.WriteLine(cost.ToString("C", new System.Globalization.CultureInfo("en-US"))); // The example displays the following output: // $1,632.54Dim cost As Double = 1632.54 Console.WriteLine(cost.ToString("C", New System.Globalization.CultureInfo("en-US"))) ' The example displays the following output: ' $1,632.54A formátumszolgáltatókkal való formázással kapcsolatos további információkért lásd a Formátumszolgáltatók szakaszt.
A felület implementálása a IFormattable sztringátalakítás és az Convert összetett formázás támogatásához. További információ: IFormattable Interface (IFormattable Interface ) szakasz.
Összetett formázás használata egy érték sztringképének beágyazásához egy nagyobb sztringbe. További információkért tekintse meg az Összetett formázás szakaszt.
Sztringinterpolációval olvashatóbb szintaxissal ágyazhatja be egy érték sztringképét egy nagyobb sztringbe. További információ: Sztring interpoláció.
Teljes egyéni formázási megoldás implementálása ICustomFormatter és IFormatProvider biztosítása. További információkért tekintse meg az Egyéni formázás az ICustomFormatter szakaszt.
Az alábbi szakaszok ezeket a metódusokat vizsgálják az objektumok sztringre való átalakításához.
Alapértelmezett formázás a ToString metódussal
Minden származtatott típus System.Object automatikusan örököl egy paraméter nélküli ToString metódust, amely alapértelmezés szerint visszaadja a típus nevét. Az alábbi példa az alapértelmezett ToString módszert mutatja be. Egy olyan osztályt Automobile határoz meg, amelynek nincs implementációja. Az osztály példányosítása és metódusának meghívásakor ToString megjeleníti a típusnevét. Vegye figyelembe, hogy a ToString metódus nem szerepel explicit módon a példában. A Console.WriteLine(Object) metódus implicit módon argumentumként meghívja a ToString neki átadott objektum metódusát.
using System;
public class Automobile
{
// No implementation. All members are inherited from Object.
}
public class Example9
{
public static void Main()
{
Automobile firstAuto = new Automobile();
Console.WriteLine(firstAuto);
}
}
// The example displays the following output:
// Automobile
Public Class Automobile
' No implementation. All members are inherited from Object.
End Class
Module Example9
Public Sub Main9()
Dim firstAuto As New Automobile()
Console.WriteLine(firstAuto)
End Sub
End Module
' The example displays the following output:
' Automobile
Figyelmeztetés
A Windows 8.1-től kezdve a Windows-futtatókörnyezet egyetlen IStringable IStringable.ToString metódussal rendelkező felületet tartalmaz, amely alapértelmezett formázási támogatást nyújt. Javasoljuk azonban, hogy a felügyelt típusok ne implementálják a IStringable felületet. További információ: "A Windows-futtatókörnyezet és a IStringable felület" szakasz a Object.ToString referenciaoldalon.
Mivel az interfészeken kívül minden típus származik belőle Object, ezt a funkciót automatikusan biztosítja az egyéni osztályok vagy struktúrák számára. Az alapértelmezett ToString módszer által kínált funkciók azonban korlátozottak: Bár azonosítja a típust, nem ad meg semmilyen információt a típus egy példányáról. Egy objektum sztring-ábrázolásához felül kell bírálnia a metódust ToString , ha olyan objektumot szeretne ábrázolni, amely az adott objektumról nyújt információt.
Feljegyzés
A struktúrák öröklődnek , ValueTypeamelyből a rendszer Objectszármazik. A felülbírálások Object.ToStringellenére ValueType a megvalósítás azonos.
A ToString metódus felülbírálása
A típus nevének megjelenítése gyakran korlátozott, és nem teszi lehetővé, hogy a típusok felhasználói megkülönböztetik az egyik példányt a másiktól. Felülbírálhatja azonban a ToString metódust, hogy hasznosabb képet adjon egy objektum értékéről. Az alábbi példa definiál egy Temperature objektumot, és felülbírálja annak metódusát ToString a hőmérséklet Celsius-fokban való megjelenítéséhez.
public class Temperature
{
private decimal temp;
public Temperature(decimal temperature)
{
this.temp = temperature;
}
public override string ToString()
{
return this.temp.ToString("N1") + "°C";
}
}
public class Example12
{
public static void Main()
{
Temperature currentTemperature = new Temperature(23.6m);
Console.WriteLine($"The current temperature is {currentTemperature}");
}
}
// The example displays the following output:
// The current temperature is 23.6°C.
Public Class Temperature
Private temp As Decimal
Public Sub New(temperature As Decimal)
Me.temp = temperature
End Sub
Public Overrides Function ToString() As String
Return Me.temp.ToString("N1") + "°C"
End Function
End Class
Module Example13
Public Sub Main13()
Dim currentTemperature As New Temperature(23.6D)
Console.WriteLine("The current temperature is " +
currentTemperature.ToString())
End Sub
End Module
' The example displays the following output:
' The current temperature is 23.6°C.
A .NET-ben az ToString egyes primitív értéktípusok metódusa felül lett bírálva az objektum értékének megjelenítéséhez a neve helyett. Az alábbi táblázat az egyes primitív típusok felülbírálását mutatja be. Vegye figyelembe, hogy a felülbírált metódusok többsége a metódus másik túlterhelését ToString hívja meg, és átadja neki a "G" formátumjelölőt, amely meghatározza a típus általános formátumát, valamint egy IFormatProvider objektumot, amely az aktuális kultúrát képviseli.
| Típus | ToString felülbírálás |
|---|---|
| Boolean | Boolean.TrueStringBoolean.FalseStringVagy vagy . |
| Byte | Az aktuális kultúra értékének Byte formázására szolgáló hívásokByte.ToString("G", NumberFormatInfo.CurrentInfo). |
| Char | Sztringként adja vissza a karaktert. |
| DateTime | Az aktuális kultúra dátum- és időértékének formázására szolgáló hívások DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) . |
| Decimal | Az aktuális kultúra értékének Decimal formázására szolgáló hívásokDecimal.ToString("G", NumberFormatInfo.CurrentInfo). |
| Double | Az aktuális kultúra értékének Double formázására szolgáló hívásokDouble.ToString("G", NumberFormatInfo.CurrentInfo). |
| Int16 | Az aktuális kultúra értékének Int16 formázására szolgáló hívásokInt16.ToString("G", NumberFormatInfo.CurrentInfo). |
| Int32 | Az aktuális kultúra értékének Int32 formázására szolgáló hívásokInt32.ToString("G", NumberFormatInfo.CurrentInfo). |
| Int64 | Az aktuális kultúra értékének Int64 formázására szolgáló hívásokInt64.ToString("G", NumberFormatInfo.CurrentInfo). |
| SByte | Az aktuális kultúra értékének SByte formázására szolgáló hívásokSByte.ToString("G", NumberFormatInfo.CurrentInfo). |
| Single | Az aktuális kultúra értékének Single formázására szolgáló hívásokSingle.ToString("G", NumberFormatInfo.CurrentInfo). |
| UInt16 | Az aktuális kultúra értékének UInt16 formázására szolgáló hívásokUInt16.ToString("G", NumberFormatInfo.CurrentInfo). |
| UInt32 | Az aktuális kultúra értékének UInt32 formázására szolgáló hívásokUInt32.ToString("G", NumberFormatInfo.CurrentInfo). |
| UInt64 | Az aktuális kultúra értékének UInt64 formázására szolgáló hívásokUInt64.ToString("G", NumberFormatInfo.CurrentInfo). |
A ToString metódus és a sztringek formázása
Az alapértelmezett ToString módszerre vagy felülírásra való támaszkodás ToString akkor megfelelő, ha egy objektum egyetlen sztring-ábrázolással rendelkezik. Az objektumok értéke azonban gyakran több ábrázolásból áll. A hőmérséklet például Fahrenheit fokban, Celsius-fokban vagy kelvinben kifejezhető. Hasonlóképpen a 10 egész szám számos módon ábrázolható, például 10, 10,0, 1,0e01 vagy 10,00 USD.
Ha egyetlen érték több sztringreprezentációt szeretne engedélyezni, a .NET formátumsztringeket használ. A formázási sztringek olyan sztringek, amelyek egy vagy több előre definiált formátumjelölőt tartalmaznak, amelyek egy karakterből vagy karaktercsoportból állnak, amelyek meghatározzák, hogy a metódus hogyan formázza a ToString kimenetét. A formátumsztring ezután paraméterként lesz átadva az objektum metódusának ToString , és meghatározza, hogyan jelenjen meg az objektum értékének sztringje.
A .NET-ben minden numerikus típus, dátum- és időtípus, valamint enumerálási típus támogatja az előre definiált formátumjelölőket. Formátumsztringek használatával az alkalmazás által definiált adattípusok több sztring-ábrázolását is definiálhatja.
Standard formátumú sztringek
A szabványos formázási sztring egyetlen formátumkijelölőt tartalmaz, amely betűrendes karakter, amely meghatározza annak az objektumnak a sztringképét, amelyre alkalmazva van, valamint egy opcionális pontosság-meghatározót, amely befolyásolja, hogy hány számjegy jelenjen meg az eredménysztringben. Ha a pontosság-kijelölő nincs megadva, vagy nem támogatott, a szabványos formátumkijelölő egy szabványos formátumsztringnek felel meg.
A .NET az összes numerikus típushoz, dátum- és időtípushoz, valamint az összes enumerálási típushoz szabványos formátumkijelölőket határoz meg. Ezek a kategóriák például támogatják a "G" szabványos formátumkijelölőt, amely egy ilyen típusú érték általános sztring-ábrázolását határozza meg.
Az enumerálási típusok szabványos formátumú sztringjei közvetlenül vezérli az érték sztringképét. Az enumerálási érték metódusának ToString átadott formátumsztringek határozzák meg, hogy az érték a sztring nevével (a "G" és az "F" formátumjelölővel), annak mögöttes integrálértékével (a "D" formátumjelölővel) vagy hexadecimális értékével (az "X" formátumjelölővel) jelenik-e meg. Az alábbi példa bemutatja, hogy a standard formátumú sztringek használatával formázza az DayOfWeek enumerálási értékeket.
DayOfWeek thisDay = DayOfWeek.Monday;
string[] formatStrings = {"G", "F", "D", "X"};
foreach (string formatString in formatStrings)
Console.WriteLine(thisDay.ToString(formatString));
// The example displays the following output:
// Monday
// Monday
// 1
// 00000001
Dim thisDay As DayOfWeek = DayOfWeek.Monday
Dim formatStrings() As String = {"G", "F", "D", "X"}
For Each formatString As String In formatStrings
Console.WriteLine(thisDay.ToString(formatString))
Next
' The example displays the following output:
' Monday
' Monday
' 1
' 00000001
Az enumerálási formátum sztringjeiről további információt az Enumerálási formázási sztringek című témakörben talál.
A numerikus típusok szabványos formátumsztringjei általában olyan eredménysztringet határoznak meg, amelynek pontos megjelenését egy vagy több tulajdonságérték vezérli. A "C" formátumkijelölő például pénznemértékként formáz egy számot. Ha a ToString metódust a "C" formátumkijelölővel hívja meg egyetlen paraméterként, a rendszer az aktuális kultúra NumberFormatInfo objektumának következő tulajdonságértékeit használja a numerikus érték sztring-ábrázolásának meghatározásához:
A CurrencySymbol tulajdonság, amely az aktuális kultúra pénznemszimbólumát adja meg.
Az CurrencyNegativePattern a vagy CurrencyPositivePattern tulajdonság, amely egy egész számot ad vissza, amely a következőket határozza meg:
A pénznemszimbólum elhelyezése.
Azt, hogy a negatív értékeket vezető negatív jel, záró negatív jel vagy zárójel jelzi-e.
A számérték és a pénznemszimbólum között szóköz jelenik-e meg.
Az CurrencyDecimalDigits eredménysztring törtjegyeinek számát meghatározó tulajdonság.
Az CurrencyDecimalSeparator eredménysztringben a decimális elválasztó szimbólumot meghatározó tulajdonság.
A CurrencyGroupSeparator csoportelválasztó szimbólumot meghatározó tulajdonság.
A CurrencyGroupSizes tulajdonság, amely meghatározza az egyes csoportok számjegyeinek számát a tizedesvessző bal oldalán.
Az NegativeSign eredménysztringben használt negatív előjelet meghatározó tulajdonság, ha a zárójelek nem a negatív értékek jelzésére szolgálnak.
Emellett a numerikus formátumú sztringek tartalmazhatnak pontosság-meghatározót is. Ennek a kijelölőnek a jelentése attól függ, hogy milyen formátumsztringet használ, de általában a számjegyek teljes számát vagy az eredménysztringben megjelenítendő törtjegyek számát jelzi. Az alábbi példa például az "X4" standard numerikus sztringet és egy pontossági azonosítót használ egy négy hexadecimális számjegyet tartalmazó sztringérték létrehozásához.
byte[] byteValues = { 12, 163, 255 };
foreach (byte byteValue in byteValues)
Console.WriteLine(byteValue.ToString("X4"));
// The example displays the following output:
// 000C
// 00A3
// 00FF
Dim byteValues() As Byte = {12, 163, 255}
For Each byteValue As Byte In byteValues
Console.WriteLine(byteValue.ToString("X4"))
Next
' The example displays the following output:
' 000C
' 00A3
' 00FF
A standard numerikus formázási sztringekről további információt a Standard numerikus formázási sztringek című témakörben talál.
A dátum- és időértékek szabványos formátumsztringjei egy adott DateTimeFormatInfo tulajdonság által tárolt egyéni formázási sztringek aliasai. Egy dátum- és időérték metódusának "D" formátumjelölővel való meghívása ToString például az aktuális kultúra DateTimeFormatInfo.LongDatePattern tulajdonságában tárolt egyéni formátumsztring használatával jeleníti meg a dátumot és az időt. (Az egyéni formázási sztringekről további információt a következő szakaszban talál.) Az alábbi példa ezt a kapcsolatot szemlélteti.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
DateTime date1 = new DateTime(2009, 6, 30);
Console.WriteLine("D Format Specifier: {0:D}", date1);
string longPattern = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern;
Console.WriteLine("'{0}' custom format string: {1}",
longPattern, date1.ToString(longPattern));
}
}
// The example displays the following output when run on a system whose
// current culture is en-US:
// D Format Specifier: Tuesday, June 30, 2009
// 'dddd, MMMM dd, yyyy' custom format string: Tuesday, June 30, 2009
Imports System.Globalization
Module Example
Public Sub Main0()
Dim date1 As Date = #6/30/2009#
Console.WriteLine("D Format Specifier: {0:D}", date1)
Dim longPattern As String = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern
Console.WriteLine("'{0}' custom format string: {1}",
longPattern, date1.ToString(longPattern))
End Sub
End Module
' The example displays the following output when run on a system whose
' current culture is en-US:
' D Format Specifier: Tuesday, June 30, 2009
' 'dddd, MMMM dd, yyyy' custom format string: Tuesday, June 30, 2009
A szabványos dátum- és időformátum-sztringekről további információt a Standard dátum- és időformátum sztringjei című témakörben talál.
Szabványos formátumú sztringekkel definiálhatja az objektum metódusa által létrehozott alkalmazás által definiált objektumok sztringképét ToString(String) is. Megadhatja az objektum által támogatott szabványos formátumjelölőket, és meghatározhatja, hogy a kis- és nagybetűk megkülönböztetik-e a kis- és nagybetűket. A módszer implementálásának ToString(String) a következőket kell támogatnia:
"G" formátumkijelölő, amely az objektum szokásos vagy gyakori formátumát jelöli. Az objektum
ToStringmetódusának paraméter nélküli túlterhelésének meg kell hívnia annak túlterhelésétToString(String), és át kell adnia a "G" standard formátumú sztringet.Null hivatkozással egyenlő formátumkijelölő támogatása (
Nothinga Visual Basicben). A nullhivatkozással egyenlő formátumkijelölőt a "G" formátumkijelölővel egyenértékűnek kell tekinteni.
Egy osztály például belsőleg tárolhatja a hőmérsékletet Celsius-fokban, Temperature és formátumjelölőkkel az objektum értékét Temperature Celsius-fokban, Fahrenheit-fokban és kelvinben jelölheti. Az alábbi példa egy illusztrációt tartalmaz.
using System;
public class Temperature
{
private decimal m_Temp;
public Temperature(decimal temperature)
{
this.m_Temp = temperature;
}
public decimal Celsius
{
get { return this.m_Temp; }
}
public decimal Kelvin
{
get { return this.m_Temp + 273.15m; }
}
public decimal Fahrenheit
{
get { return Math.Round(((decimal) (this.m_Temp * 9 / 5 + 32)), 2); }
}
public override string ToString()
{
return this.ToString("C");
}
public string ToString(string format)
{
// Handle null or empty string.
if (String.IsNullOrEmpty(format)) format = "C";
// Remove spaces and convert to uppercase.
format = format.Trim().ToUpperInvariant();
// Convert temperature to Fahrenheit and return string.
switch (format)
{
// Convert temperature to Fahrenheit and return string.
case "F":
return this.Fahrenheit.ToString("N2") + " °F";
// Convert temperature to Kelvin and return string.
case "K":
return this.Kelvin.ToString("N2") + " K";
// return temperature in Celsius.
case "G":
case "C":
return this.Celsius.ToString("N2") + " °C";
default:
throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
}
}
}
public class Example1
{
public static void Main()
{
Temperature temp1 = new Temperature(0m);
Console.WriteLine(temp1.ToString());
Console.WriteLine(temp1.ToString("G"));
Console.WriteLine(temp1.ToString("C"));
Console.WriteLine(temp1.ToString("F"));
Console.WriteLine(temp1.ToString("K"));
Temperature temp2 = new Temperature(-40m);
Console.WriteLine(temp2.ToString());
Console.WriteLine(temp2.ToString("G"));
Console.WriteLine(temp2.ToString("C"));
Console.WriteLine(temp2.ToString("F"));
Console.WriteLine(temp2.ToString("K"));
Temperature temp3 = new Temperature(16m);
Console.WriteLine(temp3.ToString());
Console.WriteLine(temp3.ToString("G"));
Console.WriteLine(temp3.ToString("C"));
Console.WriteLine(temp3.ToString("F"));
Console.WriteLine(temp3.ToString("K"));
Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3));
}
}
// The example displays the following output:
// 0.00 °C
// 0.00 °C
// 0.00 °C
// 32.00 °F
// 273.15 K
// -40.00 °C
// -40.00 °C
// -40.00 °C
// -40.00 °F
// 233.15 K
// 16.00 °C
// 16.00 °C
// 16.00 °C
// 60.80 °F
// 289.15 K
// The temperature is now 16.00 °C.
Public Class Temperature
Private m_Temp As Decimal
Public Sub New(temperature As Decimal)
Me.m_Temp = temperature
End Sub
Public ReadOnly Property Celsius() As Decimal
Get
Return Me.m_Temp
End Get
End Property
Public ReadOnly Property Kelvin() As Decimal
Get
Return Me.m_Temp + 273.15D
End Get
End Property
Public ReadOnly Property Fahrenheit() As Decimal
Get
Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
End Get
End Property
Public Overrides Function ToString() As String
Return Me.ToString("C")
End Function
Public Overloads Function ToString(format As String) As String
' Handle null or empty string.
If String.IsNullOrEmpty(format) Then format = "C"
' Remove spaces and convert to uppercase.
format = format.Trim().ToUpperInvariant()
Select Case format
Case "F"
' Convert temperature to Fahrenheit and return string.
Return Me.Fahrenheit.ToString("N2") & " °F"
Case "K"
' Convert temperature to Kelvin and return string.
Return Me.Kelvin.ToString("N2") & " K"
Case "C", "G"
' Return temperature in Celsius.
Return Me.Celsius.ToString("N2") & " °C"
Case Else
Throw New FormatException(String.Format("The '{0}' format string is not supported.", format))
End Select
End Function
End Class
Public Module Example1
Public Sub Main1()
Dim temp1 As New Temperature(0D)
Console.WriteLine(temp1.ToString())
Console.WriteLine(temp1.ToString("G"))
Console.WriteLine(temp1.ToString("C"))
Console.WriteLine(temp1.ToString("F"))
Console.WriteLine(temp1.ToString("K"))
Dim temp2 As New Temperature(-40D)
Console.WriteLine(temp2.ToString())
Console.WriteLine(temp2.ToString("G"))
Console.WriteLine(temp2.ToString("C"))
Console.WriteLine(temp2.ToString("F"))
Console.WriteLine(temp2.ToString("K"))
Dim temp3 As New Temperature(16D)
Console.WriteLine(temp3.ToString())
Console.WriteLine(temp3.ToString("G"))
Console.WriteLine(temp3.ToString("C"))
Console.WriteLine(temp3.ToString("F"))
Console.WriteLine(temp3.ToString("K"))
Console.WriteLine(String.Format("The temperature is now {0:F}.", temp3))
End Sub
End Module
' The example displays the following output:
' 0.00 °C
' 0.00 °C
' 0.00 °C
' 32.00 °F
' 273.15 K
' -40.00 °C
' -40.00 °C
' -40.00 °C
' -40.00 °F
' 233.15 K
' 16.00 °C
' 16.00 °C
' 16.00 °C
' 60.80 °F
' 289.15 K
' The temperature is now 16.00 °C.
Egyéni formázási sztringek
A standard formátumsztringek mellett a .NET egyéni formázási sztringeket is definiál a numerikus értékekhez, valamint a dátum- és időértékekhez. Az egyéni formázási sztringek egy vagy több egyéni formátumjelölőből állnak, amelyek egy érték sztring-ábrázolását határozzák meg. Az "yyyy/mm/dd hh:mm:ss.ffff t zzz" egyéni dátum- és időformátum-sztring például "2008/11/15 07:45:00.0000 P -08:00" formában konvertálja a dátumot a sztringre az en-US kultúra esetében. Hasonlóképpen, a "0000" egyéni formátumsztring a 12 egész szám értékét "0012" értékké alakítja. Az egyéni formázási sztringek teljes listáját az Egyéni dátum- és időformátum sztringjei és az Egyéni numerikus formázási sztringek című témakörben találja.
Ha egy formázási sztring egyetlen egyéni formátumkijelölőből áll, a formátumjelölő előtt a százalék (%) szimbólumot kell megadni, hogy elkerülje a szabványos formátumkijelölővel való összetévesztést. Az alábbi példa az "M" egyéni formátumkijelölőt használja egy adott dátum hónapjának egyjegyű vagy kétjegyű számának megjelenítéséhez.
DateTime date1 = new DateTime(2009, 9, 8);
Console.WriteLine(date1.ToString("%M")); // Displays 9
Dim date1 As Date = #09/08/2009#
Console.WriteLine(date1.ToString("%M")) ' Displays 9
A dátum- és időértékek számos szabványos formátumsztringje az objektum tulajdonságai által definiált egyéni formázási sztringek aliasa DateTimeFormatInfo . Az egyéni formázási sztringek emellett jelentős rugalmasságot biztosítanak az alkalmazás által definiált formázáshoz numerikus értékekhez, illetve dátum- és időértékekhez. A numerikus értékekhez és a dátum- és időértékekhez saját egyéni eredménysztringeket is definiálhat, ha több egyéni formátumkijelölőt egyetlen egyéni formátumsztringbe egyesít. Az alábbi példa egy egyéni formátumsztringet határoz meg, amely zárójelben jeleníti meg a hét napját a hónap neve, napja és éve után.
string customFormat = "MMMM dd, yyyy (dddd)";
DateTime date1 = new DateTime(2009, 8, 28);
Console.WriteLine(date1.ToString(customFormat));
// The example displays the following output if run on a system
// whose language is English:
// August 28, 2009 (Friday)
Dim customFormat As String = "MMMM dd, yyyy (dddd)"
Dim date1 As Date = #8/28/2009#
Console.WriteLine(date1.ToString(customFormat))
' The example displays the following output if run on a system
' whose language is English:
' August 28, 2009 (Friday)
Az alábbi példa egy egyéni formátumsztringet határoz meg, amely egy Int64 értéket szabványos, hétjegyű amerikai telefonszámként jelenít meg a körzetszámmal együtt.
using System;
public class Example17
{
public static void Main()
{
long number = 8009999999;
string fmt = "000-000-0000";
Console.WriteLine(number.ToString(fmt));
}
}
// The example displays the following output:
// 800-999-9999
Module Example18
Public Sub Main18()
Dim number As Long = 8009999999
Dim fmt As String = "000-000-0000"
Console.WriteLine(number.ToString(fmt))
End Sub
End Module
' The example displays the following output:
' The example displays the following output:
' 800-999-9999
Bár a szabványos formázási sztringek általában képesek kezelni az alkalmazás által definiált típusok formázási igényeinek többségét, a típusok formázásához egyéni formátumjelölőket is definiálhat.
Sztringek és .NET-típusok formázása
Az összes numerikus típus (azaz a Byte, , Decimal, Double, Int16, Int32Int64, , SByteSingle, UInt16, UInt32UInt64és BigInteger típusok), valamint a DateTime, DateTimeOffset, , TimeSpanGuid, és az összes számbavételi típus támogatja a formázást formázási sztringekkel. Az egyes típusok által támogatott formázási sztringekről az alábbi témakörökben tájékozódhat:
| Cím | Definíció |
|---|---|
| Standard numerikus formázó sztringek | A numerikus értékek gyakran használt sztring-ábrázolását létrehozó szabványos formátumú sztringeket ismerteti. |
| Egyéni numerikus formázási sztringek | A numerikus értékek alkalmazásspecifikus formátumait létrehozó egyéni formázási sztringeket ismerteti. |
| Szabványos dátum- és időformátum-karakterláncok | A szabványos formátumú sztringeket ismerteti, amelyek gyakran használt sztring-ábrázolásokat DateTime és DateTimeOffset értékeket hoznak létre. |
| Egyéni dátum- és időformátum-karakterláncok | Az alkalmazásspecifikus formátumokat és DateTimeOffset értékeket DateTime létrehozó egyéni formázási sztringeket ismerteti. |
| Standard TimeSpan Formátum sztringek | Az időintervallumok gyakran használt sztring-ábrázolását létrehozó szabványos formátumú sztringeket ismerteti. |
| Egyéni TimeSpan formátumsztringek | Azokat az egyéni formátumsztringeket ismerteti, amelyek alkalmazásspecifikus formátumokat hoznak létre az időintervallumokhoz. |
| Sztringek számbavétele | Az enumerálási értékek sztring-reprezentációinak létrehozásához használt szabványos formátumú sztringeket ismerteti. |
| Guid.ToString(String) | Az értékek szabványos formátumsztringjeinek Guid ismertetése. |
Kultúraérzékeny formázás formátumszolgáltatókkal
Bár a formátumjelölők lehetővé teszik az objektumok formázásának testreszabását, az objektumok jelentéssel bíró sztring-ábrázolásának létrehozásához gyakran további formázási információkra van szükség. Egy szám pénznemértékként való formázásához például a "C" standard formátumú sztringet vagy egy egyéni formátumsztringet (például "$ #,#.00" ) legalább a megfelelő pénznemszimbólumra, a csoportelválasztóra és a decimális elválasztóra vonatkozó információknak kell rendelkezésre állniuk a formázott sztringbe való belefoglaláshoz. A .NET-ben ez a további formázási információ elérhetővé válik az IFormatProvider interfészen keresztül, amely paraméterként szolgál a numerikus típusok és dátum ToString - és időtípusok metódusának egy vagy több túlterheléséhez. IFormatProvider az implementációk a .NET-ben használhatók a kultúraspecifikus formázás támogatására. Az alábbi példa bemutatja, hogyan változik egy objektum sztring-ábrázolása, ha három IFormatProvider különböző kultúrát képviselő objektummal van formázva.
using System;
using System.Globalization;
public class Example18
{
public static void Main()
{
decimal value = 1603.42m;
Console.WriteLine(value.ToString("C3", new CultureInfo("en-US")));
Console.WriteLine(value.ToString("C3", new CultureInfo("fr-FR")));
Console.WriteLine(value.ToString("C3", new CultureInfo("de-DE")));
}
}
// The example displays the following output:
// $1,603.420
// 1 603,420 €
// 1.603,420 €
Imports System.Globalization
Public Module Example11
Public Sub Main11()
Dim value As Decimal = 1603.42D
Console.WriteLine(value.ToString("C3", New CultureInfo("en-US")))
Console.WriteLine(value.ToString("C3", New CultureInfo("fr-FR")))
Console.WriteLine(value.ToString("C3", New CultureInfo("de-DE")))
End Sub
End Module
' The example displays the following output:
' $1,603.420
' 1 603,420 €
' 1.603,420 €
Az IFormatProvider interfész egy metódust tartalmaz, amely egyetlen paraméterrel rendelkezik, GetFormat(Type)amely megadja a formázási információkat biztosító objektum típusát. Ha a metódus képes megadni egy ilyen típusú objektumot, visszaadja azt. Ellenkező esetben null hivatkozást ad vissza (Nothing a Visual Basicben).
IFormatProvider.GetFormat egy visszahívási módszer. Amikor egy paramétert ToString tartalmazó IFormatProvider metódust túlterhelésnek hív, az meghívja az GetFormat objektum metódusát IFormatProvider . A GetFormat metódus feladata, hogy visszaadjon egy objektumot, amely a paramétere által formatType megadott szükséges formázási információkat adja vissza a ToString metódusnak.
Számos formázási vagy sztringkonvertálási módszer tartalmaz egy típusú IFormatProviderparamétert, de a metódus meghívásakor a rendszer sok esetben figyelmen kívül hagyja a paraméter értékét. Az alábbi táblázat felsorol néhány formázási módszert, amelyek a paramétert és a Type metódusnak IFormatProvider.GetFormat átadott objektum típusát használják.
| Metódus | formatType Paraméter típusa |
|---|---|
ToString numerikus típusok metódusa |
System.Globalization.NumberFormatInfo |
ToString dátum- és időtípusok metódusa |
System.Globalization.DateTimeFormatInfo |
| String.Format | System.ICustomFormatter |
| StringBuilder.AppendFormat | System.ICustomFormatter |
Feljegyzés
A ToString numerikus típusok, a dátum- és időtípusok metódusai túlterheltek, és csak néhány túlterhelés tartalmaz paramétert IFormatProvider . Ha egy metódus nem rendelkezik típusparaméterrel IFormatProvider, a tulajdonság által CultureInfo.CurrentCulture visszaadott objektumot adja át a rendszer. Az alapértelmezett Int32.ToString() metódus hívása például végül egy metódushívást eredményez, például a következőket: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture).
A .NET három olyan osztályt biztosít, amelyek implementálják a következőt IFormatProvider:
DateTimeFormatInfoosztály, amely formázási információkat biztosít egy adott kultúrához tartozó dátum- és időértékekhez. A IFormatProvider.GetFormat megvalósítás egy példányt ad vissza.
NumberFormatInfoosztály, amely numerikus formázási információkat biztosít egy adott kultúrához. A IFormatProvider.GetFormat megvalósítás egy példányt ad vissza.
CultureInfo. Implementációja IFormatProvider.GetFormat visszaadhat egy NumberFormatInfo objektumot numerikus formázási információk megadásához, vagy egy DateTimeFormatInfo objektumot a dátum- és időértékek formázási információinak megadásához.
A saját formátumszolgáltatóját is implementálhatja ezen osztályok bármelyikének lecseréléséhez. Az implementáció metódusának GetFormat azonban az előző táblázatban felsorolt típusú objektumot kell visszaadnia, ha formázási információkat kell megadnia a ToString metódusnak.
A numerikus értékek kultúraérzékeny formázása
Alapértelmezés szerint a numerikus értékek formázása kulturális szempontból érzékeny. Ha nem ad meg egy kultúrát, amikor formázási módszert hív meg, a rendszer az aktuális kultúra formázási konvencióit használja. Ezt a következő példában szemlélteti, amely négyszer módosítja a jelenlegi kultúrát, majd meghívja a metódust Decimal.ToString(String) . Az eredménysztring minden esetben az aktuális kultúra formázási konvencióit tükrözi. Ennek az az oka, hogy a metódusok és ToString(String) a ToString metódusok az egyes numerikus típusok metódusaihoz tördelik a ToString(String, IFormatProvider) hívásokat.
using System.Globalization;
public class Example6
{
public static void Main()
{
string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
Decimal value = 1043.17m;
foreach (var cultureName in cultureNames) {
// Change the current culture.
CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}");
Console.WriteLine(value.ToString("C2"));
Console.WriteLine();
}
}
}
// The example displays the following output:
// The current culture is en-US
// $1,043.17
//
// The current culture is fr-FR
// 1 043,17 €
//
// The current culture is es-MX
// $1,043.17
//
// The current culture is de-DE
// 1.043,17 €
Imports System.Globalization
Module Example6
Public Sub Main6()
Dim cultureNames() As String = {"en-US", "fr-FR", "es-MX", "de-DE"}
Dim value As Decimal = 1043.17D
For Each cultureName In cultureNames
' Change the current culture.
CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}")
Console.WriteLine(value.ToString("C2"))
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' The current culture is en-US
' $1,043.17
'
' The current culture is fr-FR
' 1 043,17 €
'
' The current culture is es-MX
' $1,043.17
'
' The current culture is de-DE
' 1.043,17 €
Egy adott kultúra numerikus értékét úgy is formázhatja, hogy egy paramétert tartalmazó provider túlterhelést hív ToString meg, és az alábbiak valamelyikét adja át:
Olyan CultureInfo objektum, amely azt a kultúrát jelöli, amelynek formázási konvencióit használni kell. A CultureInfo.GetFormat metódus a tulajdonság értékét CultureInfo.NumberFormat adja vissza, amely az objektum NumberFormatInfo , amely kultúraspecifikus formázási információkat biztosít a numerikus értékekhez.
Egy NumberFormatInfo objektum, amely meghatározza a használandó kultúraspecifikus formázási konvenciókat. A GetFormat metódus egy saját példányt ad vissza.
Az alábbi példa az angol (Egyesült Államok) és az angol (Egyesült Királyság) kultúrákat, valamint a francia és orosz semleges kultúrákat ábrázoló objektumokat használja NumberFormatInfo a lebegőpontos szám formázásához.
using System.Globalization;
public class Example7
{
public static void Main()
{
double value = 1043.62957;
string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };
foreach (string? name in cultureNames)
{
NumberFormatInfo nfi = CultureInfo.CreateSpecificCulture(name).NumberFormat;
Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi));
}
}
}
// The example displays the following output:
// en-US: 1,043.630
// en-GB: 1,043.630
// ru: 1 043,630
// fr: 1 043,630
Imports System.Globalization
Module Example7
Public Sub Main7()
Dim value As Double = 1043.62957
Dim cultureNames() As String = {"en-US", "en-GB", "ru", "fr"}
For Each name In cultureNames
Dim nfi As NumberFormatInfo = CultureInfo.CreateSpecificCulture(name).NumberFormat
Console.WriteLine("{0,-6} {1}", name + ":", value.ToString("N3", nfi))
Next
End Sub
End Module
' The example displays the following output:
' en-US: 1,043.630
' en-GB: 1,043.630
' ru: 1 043,630
' fr: 1 043,630
A dátum- és időértékek kultúraérzékeny formázása
Alapértelmezés szerint a dátum- és időértékek formázása kulturális szempontból érzékeny. Ha nem ad meg egy kultúrát, amikor formázási módszert hív meg, a rendszer az aktuális kultúra formázási konvencióit használja. Ezt a következő példában szemlélteti, amely négyszer módosítja a jelenlegi kultúrát, majd meghívja a metódust DateTime.ToString(String) . Az eredménysztring minden esetben az aktuális kultúra formázási konvencióit tükrözi. Ennek az az oka, hogy a DateTime.ToString(), DateTime.ToString(String), DateTimeOffset.ToString()és DateTimeOffset.ToString(String) metódusok körbefuttatják a hívásokat és a DateTime.ToString(String, IFormatProvider)DateTimeOffset.ToString(String, IFormatProvider) metódusokat.
using System.Globalization;
public class Example4
{
public static void Main()
{
string[] cultureNames = { "en-US", "fr-FR", "es-MX", "de-DE" };
DateTime dateToFormat = new DateTime(2012, 5, 28, 11, 30, 0);
foreach (var cultureName in cultureNames) {
// Change the current culture.
CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}");
Console.WriteLine(dateToFormat.ToString("F"));
Console.WriteLine();
}
}
}
// The example displays the following output:
// The current culture is en-US
// Monday, May 28, 2012 11:30:00 AM
//
// The current culture is fr-FR
// lundi 28 mai 2012 11:30:00
//
// The current culture is es-MX
// lunes, 28 de mayo de 2012 11:30:00 a.m.
//
// The current culture is de-DE
// Montag, 28. Mai 2012 11:30:00
Imports System.Globalization
Imports System.Threading
Module Example4
Public Sub Main4()
Dim cultureNames() As String = {"en-US", "fr-FR", "es-MX", "de-DE"}
Dim dateToFormat As Date = #5/28/2012 11:30AM#
For Each cultureName In cultureNames
' Change the current culture.
CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
Console.WriteLine($"The current culture is {CultureInfo.CurrentCulture.Name}")
Console.WriteLine(dateToFormat.ToString("F"))
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' The current culture is en-US
' Monday, May 28, 2012 11:30:00 AM
'
' The current culture is fr-FR
' lundi 28 mai 2012 11:30:00
'
' The current culture is es-MX
' lunes, 28 de mayo de 2012 11:30:00 a.m.
'
' The current culture is de-DE
' Montag, 28. Mai 2012 11:30:00
Egy adott kultúra dátum- és időértékét úgy is formázhatja, hogy meghív egy DateTime.ToString paramétert DateTimeOffset.ToString vagy túlterhelést provider , és az alábbiak valamelyikét adja át:
Olyan CultureInfo objektum, amely azt a kultúrát jelöli, amelynek formázási konvencióit használni kell. A CultureInfo.GetFormat metódus a tulajdonság értékét CultureInfo.DateTimeFormat adja vissza, amely az az DateTimeFormatInfo objektum, amely kultúraspecifikus formázási információkat biztosít a dátum- és időértékekhez.
Egy DateTimeFormatInfo objektum, amely meghatározza a használandó kultúraspecifikus formázási konvenciókat. A GetFormat metódus egy saját példányt ad vissza.
Az alábbi példa az angol (Egyesült Államok) és az angol (Egyesült Királyság) kultúrákat, valamint a francia és orosz semleges kultúrákat ábrázoló objektumokat használja DateTimeFormatInfo a dátumok formázásához.
using System.Globalization;
public class Example5
{
public static void Main()
{
DateTime dat1 = new(2012, 5, 28, 11, 30, 0);
string[] cultureNames = { "en-US", "en-GB", "ru", "fr" };
foreach (var name in cultureNames) {
DateTimeFormatInfo dtfi = CultureInfo.CreateSpecificCulture(name).DateTimeFormat;
Console.WriteLine($"{name}: {dat1.ToString(dtfi)}");
}
}
}
// The example displays the following output:
// en-US: 5/28/2012 11:30:00 AM
// en-GB: 28/05/2012 11:30:00
// ru: 28.05.2012 11:30:00
// fr: 28/05/2012 11:30:00
Imports System.Globalization
Module Example5
Public Sub Main5()
Dim dat1 As Date = #5/28/2012 11:30AM#
Dim cultureNames() As String = {"en-US", "en-GB", "ru", "fr"}
For Each name In cultureNames
Dim dtfi As DateTimeFormatInfo = CultureInfo.CreateSpecificCulture(name).DateTimeFormat
Console.WriteLine($"{name}: {dat1.ToString(dtfi)}")
Next
End Sub
End Module
' The example displays the following output:
' en-US: 5/28/2012 11:30:00 AM
' en-GB: 28/05/2012 11:30:00
' ru: 28.05.2012 11:30:00
' fr: 28/05/2012 11:30:00
Az IFormattable felület
A metódust formátumsztringgel és paraméterrel túlterhelt ToStringIFormatProvider típusok általában az interfészt IFormattable is implementálják. Ennek az interfésznek egyetlen tagja van, IFormattable.ToString(String, IFormatProvider)amely paraméterként egy formátumsztringet és egy formátumszolgáltatót is tartalmaz.
Az alkalmazás által definiált osztály felületének IFormattable implementálása két előnyt kínál:
Sztringek osztály általi konvertálásának Convert támogatása. A hívások és Convert.ToString(Object, IFormatProvider) metódusok Convert.ToString(Object) automatikusan meghívják a megvalósítástIFormattable.
Az összetett formázás támogatása. Ha egy formázási sztringet tartalmazó formátumelemet használ az egyéni típus formázásához, a közös nyelvi futtatókörnyezet automatikusan meghívja az implementációt IFormattable , és átadja a formátumsztringet. További információ az összetett formázásról olyan metódusokkal, mint például String.Format az Összetett Console.WriteLineformázás szakasz.
Az alábbi példa egy olyan osztályt Temperature határoz meg, amely implementálja az interfészt IFormattable . Támogatja a "C" vagy a "G" formátumjelölőket a hőmérséklet Celsiusban való megjelenítéséhez, az "F" formátumjelölőt a fahrenheit hőmérsékletének megjelenítéséhez, a "K" formátumjelölőt pedig a hőmérséklet Kelvinben való megjelenítéséhez.
using System;
using System.Globalization;
namespace HotAndCold
{
public class Temperature : IFormattable
{
private decimal m_Temp;
public Temperature(decimal temperature)
{
this.m_Temp = temperature;
}
public decimal Celsius
{
get { return this.m_Temp; }
}
public decimal Kelvin
{
get { return this.m_Temp + 273.15m; }
}
public decimal Fahrenheit
{
get { return Math.Round((decimal)this.m_Temp * 9 / 5 + 32, 2); }
}
public override string ToString()
{
return this.ToString("G", null);
}
public string ToString(string format)
{
return this.ToString(format, null);
}
public string ToString(string format, IFormatProvider provider)
{
// Handle null or empty arguments.
if (String.IsNullOrEmpty(format))
format = "G";
// Remove any white space and covert to uppercase.
format = format.Trim().ToUpperInvariant();
if (provider == null)
provider = NumberFormatInfo.CurrentInfo;
switch (format)
{
// Convert temperature to Fahrenheit and return string.
case "F":
return this.Fahrenheit.ToString("N2", provider) + "°F";
// Convert temperature to Kelvin and return string.
case "K":
return this.Kelvin.ToString("N2", provider) + "K";
// Return temperature in Celsius.
case "C":
case "G":
return this.Celsius.ToString("N2", provider) + "°C";
default:
throw new FormatException(String.Format("The '{0}' format string is not supported.", format));
}
}
}
Public Class Temperature : Implements IFormattable
Private m_Temp As Decimal
Public Sub New(temperature As Decimal)
Me.m_Temp = temperature
End Sub
Public ReadOnly Property Celsius() As Decimal
Get
Return Me.m_Temp
End Get
End Property
Public ReadOnly Property Kelvin() As Decimal
Get
Return Me.m_Temp + 273.15D
End Get
End Property
Public ReadOnly Property Fahrenheit() As Decimal
Get
Return Math.Round(CDec(Me.m_Temp * 9 / 5 + 32), 2)
End Get
End Property
Public Overrides Function ToString() As String
Return Me.ToString("G", Nothing)
End Function
Public Overloads Function ToString(format As String) As String
Return Me.ToString(format, Nothing)
End Function
Public Overloads Function ToString(format As String, provider As IFormatProvider) As String _
Implements IFormattable.ToString
' Handle null or empty arguments.
If String.IsNullOrEmpty(format) Then format = "G"
' Remove any white space and convert to uppercase.
format = format.Trim().ToUpperInvariant()
If provider Is Nothing Then provider = NumberFormatInfo.CurrentInfo
Select Case format
' Convert temperature to Fahrenheit and return string.
Case "F"
Return Me.Fahrenheit.ToString("N2", provider) & "°F"
' Convert temperature to Kelvin and return string.
Case "K"
Return Me.Kelvin.ToString("N2", provider) & "K"
' Return temperature in Celsius.
Case "C", "G"
Return Me.Celsius.ToString("N2", provider) & "°C"
Case Else
Throw New FormatException(String.Format($"The '{format}' format string is not supported."))
End Select
End Function
End Class
Az alábbi példa létrehoz egy Temperature objektumot. Ezután meghívja a metódust ToString , és több összetett formátumú sztringet használ egy objektum különböző sztring-ábrázolásának Temperature lekéréséhez. Ezek a metódusok egymás után meghívják az IFormattable osztály implementálását Temperature .
public class Example11
{
public static void Main()
{
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
Temperature temp = new Temperature(22m);
Console.WriteLine(Convert.ToString(temp, new CultureInfo("ja-JP")));
Console.WriteLine("Temperature: {0:K}", temp);
Console.WriteLine("Temperature: {0:F}", temp);
Console.WriteLine(String.Format(new CultureInfo("fr-FR"), "Temperature: {0:F}", temp));
}
}
// The example displays the following output:
// 22.00°C
// Temperature: 295.15K
// Temperature: 71.60°F
// Temperature: 71,60°F
Public Module Example12
Public Sub Main12()
Dim temp As New Temperature(22D)
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("en-US")
Console.WriteLine(Convert.ToString(temp, New CultureInfo("ja-JP")))
Console.WriteLine($"Temperature: {temp:K}")
Console.WriteLine($"Temperature: {temp:F}")
Console.WriteLine(String.Format(New CultureInfo("fr-FR"), $"Temperature: {temp:F}"))
End Sub
End Module
' The example displays the following output:
' 22.00°C
' Temperature: 295.15K
' Temperature: 71.60°F
' Temperature: 71,60°F
Összetett formázás
Egyes metódusok, például String.Format az összetett StringBuilder.AppendFormatformázást támogatják. Az összetett formátumú sztring olyan sablon, amely egyetlen sztringet ad vissza, amely magában foglalja a nulla, egy vagy több objektum sztring-ábrázolását. Minden objektumot indexelt formázási elem jelöl az összetett formátumú sztringben. A formátumelem indexe megfelel annak az objektumnak a pozíciójának, amelyet a metódus paraméterlistájában jelöl. Az indexek nulla alapúak. A metódus következő hívásában String.Format például az első formátumelem {0:D}helyébe az ; a második formátumelem {1}sztringreprezentációjaitem1thatDate, a harmadik formátumelem {2:C2}pedig a karakterlánc-ábrázolás item1.Valuelép.
result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.",
thatDate, item1, item1.Value);
Console.WriteLine(result);
// The example displays output like the following if run on a system
// whose current culture is en-US:
// On 5/1/2009, the inventory of WidgetA was worth $107.44.
result = String.Format("On {0:d}, the inventory of {1} was worth {2:C2}.",
thatDate, item1, item1.Value)
Console.WriteLine(result)
' The example displays output like the following if run on a system
' whose current culture is en-US:
' On 5/1/2009, the inventory of WidgetA was worth $107.44.
A formázási elemeknek a megfelelő objektum sztringre való lecserélése mellett az elemek formázása a következőket is lehetővé teszi:
Az objektum sztringként való ábrázolásának konkrét módja, ha az objektum implementálja az interfészt, és támogatja a IFormattable sztringek formázását. Ezt úgy teheti meg, hogy a formátumelem indexét egy
:(kettőspont) és egy érvényes formátumsztring követi. Az előző példában egy dátumértéket formázott a "d" (rövid dátumminta) formátumsztringgel (pl.{0:d}) és formázott egy numerikus értéket a "C2" formátumsztringgel (például úgy,{2:C2}hogy a számot pénznemértékként, két tört tizedesjegykel ábrázolja).Az objektum sztringreprezentációját tartalmazó mező szélessége és a sztring-ábrázolás igazítása a mezőben. Ezt úgy teheti meg, hogy a formátumelem indexét vesszővel
,követi, majd a mező szélességét. A sztring jobbra van igazítva a mezőben, ha a mezőszélesség pozitív érték, és balra igazított, ha a mezőszélesség negatív érték. Az alábbi példa balról igazítja a dátumértékeket egy 20 karakterből álló mezőben, és jobbra igazítja a decimális értékeket egy törtjegyhez egy 11 karakterből álló mezőben.DateTime startDate = new DateTime(2015, 8, 28, 6, 0, 0); decimal[] temps = { 73.452m, 68.98m, 72.6m, 69.24563m, 74.1m, 72.156m, 72.228m }; Console.WriteLine("{0,-20} {1,11}\n", "Date", "Temperature"); for (int ctr = 0; ctr < temps.Length; ctr++) Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps[ctr]); // The example displays the following output: // Date Temperature // // 8/28/2015 6:00 AM 73.5 // 8/29/2015 6:00 AM 69.0 // 8/30/2015 6:00 AM 72.6 // 8/31/2015 6:00 AM 69.2 // 9/1/2015 6:00 AM 74.1 // 9/2/2015 6:00 AM 72.2 // 9/3/2015 6:00 AM 72.2Dim startDate As New Date(2015, 8, 28, 6, 0, 0) Dim temps() As Decimal = {73.452, 68.98, 72.6, 69.24563, 74.1, 72.156, 72.228} Console.WriteLine("{0,-20} {1,11}", "Date", "Temperature") Console.WriteLine() For ctr As Integer = 0 To temps.Length - 1 Console.WriteLine("{0,-20:g} {1,11:N1}", startDate.AddDays(ctr), temps(ctr)) Next ' The example displays the following output: ' Date Temperature ' ' 8/28/2015 6:00 AM 73.5 ' 8/29/2015 6:00 AM 69.0 ' 8/30/2015 6:00 AM 72.6 ' 8/31/2015 6:00 AM 69.2 ' 9/1/2015 6:00 AM 74.1 ' 9/2/2015 6:00 AM 72.2 ' 9/3/2015 6:00 AM 72.2Vegye figyelembe, hogy ha az igazítási sztring összetevő és a formázási sztring összetevő is jelen van, akkor az előbbi előzi meg az utóbbit (például
{0,-20:g}.
Az összetett formázásról további információt az Összetett formázás című témakörben talál.
Egyéni formázás az ICustomFormatterrel
Két összetett formázási módszer, String.Format(IFormatProvider, String, Object[]) és StringBuilder.AppendFormat(IFormatProvider, String, Object[])tartalmaz egy formátumszolgáltatói paramétert, amely támogatja az egyéni formázást. Ha valamelyik formázási metódust meghívja, az átad egy Type objektumot, amely egy ICustomFormatter felületet jelöl a formátumszolgáltató metódusához GetFormat . Ezután GetFormat a metódus feladata az egyéni formázást biztosító implementáció visszaadása ICustomFormatter .
A ICustomFormatter felület egyetlen metódussal rendelkezik, Format(String, Object, IFormatProvider)amelyet egy összetett formázási módszer automatikusan hív meg, egyszer egy összetett formátumú sztring minden egyes formázási eleméhez. A Format(String, Object, IFormatProvider) metódusnak három paramétere van: egy formátumsztring, amely egy formatString formázási elem argumentumát, egy formázandó objektumot és egy IFormatProvider formázási szolgáltatásokat biztosító objektumot jelöl. A megvalósító ICustomFormatter osztály általában implementál IFormatProvideris, így ez az utolsó paraméter maga az egyéni formázási osztályra mutató hivatkozás. A metódus a formázandó objektum egyéni formázott sztring-ábrázolását adja vissza. Ha a metódus nem tudja formázni az objektumot, null hivatkozást kell visszaadnia (Nothing a Visual Basicben).
Az alábbi példa egy ICustomFormatter olyan implementációt ByteByByteFormatter mutat be, amely egész számokat jelenít meg kétjegyű hexadecimális értékek sorozataként, majd szóközzel.
public class ByteByByteFormatter : 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 (! formatProvider.Equals(this)) return null;
// Handle only hexadecimal format string.
if (! format.StartsWith("X")) return null;
byte[] bytes;
string output = null;
// Handle only integral types.
if (arg is Byte)
bytes = BitConverter.GetBytes((Byte) arg);
else if (arg is Int16)
bytes = BitConverter.GetBytes((Int16) arg);
else if (arg is Int32)
bytes = BitConverter.GetBytes((Int32) arg);
else if (arg is Int64)
bytes = BitConverter.GetBytes((Int64) arg);
else if (arg is SByte)
bytes = BitConverter.GetBytes((SByte) arg);
else if (arg is UInt16)
bytes = BitConverter.GetBytes((UInt16) arg);
else if (arg is UInt32)
bytes = BitConverter.GetBytes((UInt32) arg);
else if (arg is UInt64)
bytes = BitConverter.GetBytes((UInt64) arg);
else
return null;
for (int ctr = bytes.Length - 1; ctr >= 0; ctr--)
output += String.Format("{0:X2} ", bytes[ctr]);
return output.Trim();
}
}
Public Class ByteByByteFormatter : 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, arg As Object,
formatProvider As IFormatProvider) As String _
Implements ICustomFormatter.Format
If Not formatProvider.Equals(Me) Then Return Nothing
' Handle only hexadecimal format string.
If Not fmt.StartsWith("X") Then
Return Nothing
End If
' Handle only integral types.
If Not typeof arg Is Byte AndAlso
Not typeof arg Is Int16 AndAlso
Not typeof arg Is Int32 AndAlso
Not typeof arg Is Int64 AndAlso
Not typeof arg Is SByte AndAlso
Not typeof arg Is UInt16 AndAlso
Not typeof arg Is UInt32 AndAlso
Not typeof arg Is UInt64 Then _
Return Nothing
Dim bytes() As Byte = BitConverter.GetBytes(arg)
Dim output As String = Nothing
For ctr As Integer = bytes.Length - 1 To 0 Step -1
output += String.Format("{0:X2} ", bytes(ctr))
Next
Return output.Trim()
End Function
End Class
Az alábbi példa az osztályt használja az ByteByByteFormatter egész számértékek formázására. Vegye figyelembe, hogy a ICustomFormatter.Format metódust a rendszer többször hívja meg a második String.Format(IFormatProvider, String, Object[]) metódushívásban, és hogy az alapértelmezett NumberFormatInfo szolgáltatót a harmadik metódushívásban használja a rendszer, mert a .ByteByByteFormatter.Format metódus nem ismeri fel az "N0" formátumú sztringet, és null hivatkozást ad vissza (Nothing a Visual Basicben).
public class Example10
{
public static void Main()
{
long value = 3210662321;
byte value1 = 214;
byte value2 = 19;
Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X}", value));
Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})",
value1, value2, value1 & value2));
Console.WriteLine(String.Format(new ByteByByteFormatter(), "{0,10:N0}", value));
}
}
// The example displays the following output:
// 00 00 00 00 BF 5E D1 B1
// 00 D6 And 00 13 = 00 12 (018)
// 3,210,662,321
Public Module Example10
Public Sub Main10()
Dim value As Long = 3210662321
Dim value1 As Byte = 214
Dim value2 As Byte = 19
Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X}", value)))
Console.WriteLine((String.Format(New ByteByByteFormatter(), "{0:X} And {1:X} = {2:X} ({2:000})",
value1, value2, value1 And value2)))
Console.WriteLine(String.Format(New ByteByByteFormatter(), "{0,10:N0}", value))
End Sub
End Module
' The example displays the following output:
' 00 00 00 00 BF 5E D1 B1
' 00 D6 And 00 13 = 00 12 (018)
' 3,210,662,321
Lásd még
| Cím | Definíció |
|---|---|
| Standard numerikus formázó sztringek | A numerikus értékek gyakran használt sztring-ábrázolását létrehozó szabványos formátumú sztringeket ismerteti. |
| Egyéni numerikus formázási sztringek | A numerikus értékek alkalmazásspecifikus formátumait létrehozó egyéni formázási sztringeket ismerteti. |
| Szabványos dátum- és időformátum-karakterláncok | Az értékek gyakran használt sztring-ábrázolását DateTime létrehozó szabványos formátumú sztringeket ismerteti. |
| Egyéni dátum- és időformátum-karakterláncok | Azokat az egyéni formázási sztringeket ismerteti, amelyek alkalmazásspecifikus formátumokat hoznak létre az értékekhez DateTime . |
| Standard TimeSpan Formátum sztringek | Az időintervallumok gyakran használt sztring-ábrázolását létrehozó szabványos formátumú sztringeket ismerteti. |
| Egyéni TimeSpan formátumsztringek | Azokat az egyéni formátumsztringeket ismerteti, amelyek alkalmazásspecifikus formátumokat hoznak létre az időintervallumokhoz. |
| Sztringek számbavétele | Az enumerálási értékek sztring-reprezentációinak létrehozásához használt szabványos formátumú sztringeket ismerteti. |
| Összetett formázás | Azt ismerteti, hogyan ágyazhat be egy vagy több formázott értéket egy sztringbe. A sztring később megjeleníthető a konzolon, vagy egy streambe írható. |
| Sztringek elemzése | Azt ismerteti, hogyan inicializálhat objektumokat az objektumok sztring-ábrázolásai által leírt értékekre. Az elemzés a formázás inverz művelete. |
Referencia
Visszajelzés
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ: https://aka.ms/ContentUserFeedback.
Visszajelzés küldése és megtekintése a következőhöz: