Á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 karaktersorozat megjelenjen a felhasználók számára, vagy később deszerializálják az eredeti adattípus visszaállítása érdekében. Ez a cikk bemutatja a .NET által biztosított formázási mechanizmusokat.

Megjegyzé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 alapszintű mechanizmusa a Object.ToString metódus alapértelmezett implementációja, amelyről a cikk későbbi, ToString metódust használó alapértelmezett formázási 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 közé tartoznak például az alábbiak:

• Az Object.ToString metódust felül kell bírálni, hogy meghatározzuk az objektum értékének egyéni szöveges ábrázolását. További információ: A ToString metódus felülbírálása szakasz a cikk későbbi részében.

• Azoknak a formátumjelölőknek a definiálása, amelyek lehetővé teszik egy objektum értékének szöveges megjelenítését, hogy több formátumot vegyen fel. 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.54
  

  Dim cost As Double = 1632.54
  Console.WriteLine(cost.ToString("C", New System.Globalization.CultureInfo("en-US")))
  ' The example displays the following output:
  '       $1,632.54
  

  A formátumszolgáltatókkal való formázással kapcsolatos további információkért lásd a Formátumszolgáltatók szakaszt.

• A IFormattable interfész implementálása a sztring konverzió és az Convert osztállyal való összetett formázás támogatására. További információért lásd az IFormattable Interface szakaszt.

• Ö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ó.

• Az ICustomFormatter és IFormatProvider implementálása a teljes egyéni formázási megoldás biztosítása érdekében. 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. Amikor az osztály példányosításra kerül, és meghívják a ToString metódusát, megjeleníti a típusnevét. A ToString metódust a példa nem kifejezetten hívja meg. 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. Azt 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 az IStringable Interface.

Mivel az interfészeken kívül minden típus a Object-ból származik, ez a funkcionalitás automatikusan biztosított az Ön egyéni osztályai vagy struktúrái 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. Az objektum sztring ábrázolásának megadásához, amely információt nyújt róla, felül kell írnia a ToString metódust.

Megjegyzés

A struktúrák öröklődnek a ValueType-ből, amely viszont a Object-ből származik. Habár ValueType felülírja Object.ToString, 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öztessék 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.

.NET-ben az egyes primitív értéktípusok ToString metódusát felülbírálták, hogy az objektum értékét jelenítse meg a neve helyett. Az alábbi táblázat az egyes primitív típusok felülbírálását mutatja be. 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	Vagy Boolean.TrueString, vagy Boolean.FalseString.
Byte	A Byte.ToString("G", NumberFormatInfo.CurrentInfo) hívása az Byte érték formázásához az aktuális kultúra szerint.
Char	Sztringként adja vissza a karaktert.
DateTime	Az aktuális kultúra szerint formázza a dátum- és időértéket a DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) hívásával.
Decimal	A Decimal.ToString("G", NumberFormatInfo.CurrentInfo) hívása az Decimal érték formázásához az aktuális kultúra szerint.
Double	A Double.ToString("G", NumberFormatInfo.CurrentInfo) hívása az Double érték formázásához az aktuális kultúra szerint.
Int16	A Int16.ToString("G", NumberFormatInfo.CurrentInfo) hívása az Int16 érték formázásához az aktuális kultúra szerint.
Int32	A Int32.ToString("G", NumberFormatInfo.CurrentInfo) hívása az Int32 érték formázásához az aktuális kultúra szerint.
Int64	A Int64.ToString("G", NumberFormatInfo.CurrentInfo) hívása az Int64 érték formázásához az aktuális kultúra szerint.
SByte	A SByte.ToString("G", NumberFormatInfo.CurrentInfo) hívása az SByte érték formázásához az aktuális kultúra szerint.
Single	A Single.ToString("G", NumberFormatInfo.CurrentInfo) hívása az Single érték formázásához az aktuális kultúra szerint.
UInt16	A UInt16.ToString("G", NumberFormatInfo.CurrentInfo) hívása az UInt16 érték formázásához az aktuális kultúra szerint.
UInt32	A UInt32.ToString("G", NumberFormatInfo.CurrentInfo) hívása az UInt32 érték formázásához az aktuális kultúra szerint.
UInt64	A UInt64.ToString("G", NumberFormatInfo.CurrentInfo) hívása az UInt64 érték formázásához az aktuális kultúra szerint.

A ToString metódus és a sztringek formázása

Az alapértelmezett ToString módszer vagy a ToString felülírása akkor megfelelő, ha egy objektum egyetlen szöveges á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 az objektum egy metódusának paramétereként kerül átadásra, és meghatározza, hogyan jelenjen meg az objektum értékének sztringkénti megjelenése.

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ú karakterláncok

A szabványos formátumsztring egyetlen formátumkijelölőt tartalmaz, amely ábécé karakter, és meghatározza az objektum sztringképét, amelyre alkalmazzák, valamint egy opcionális precíziós meghatározót, amely befolyásolja, hogy hány számjegy jelenik meg az eredménysztringben. Ha a pontosság-jelö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ékhez tartozó metódusnak átadott formátumsztringek határozzák meg, hogy az érték a szöveges nevét (a "G" és "F" formátum specifikátorok), a hozzá tartozó egész számértéket (a "D" formátum specifikátor), vagy a hexadecimális értéket (az "X" formátum specifikátor) használva 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ázási sztringekrő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 tulajdonság, amely meghatározza az eredménylánc törtjegyeinek számát.

• 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 azoknak az egyéni formázási sztringeknek az aliasai, amelyeket egy adott DateTimeFormatInfo tulajdonság tárol. Például, egy dátum- és időérték ToString metódusának "D" formátumjelölővel való meghívása a dátumot és az időt az aktuális kultúra DateTimeFormatInfo.LongDatePattern tulajdonságában tárolt egyéni formátumsztring használatával jeleníti meg. (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:     {date1:D}");
      string longPattern = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern;
      Console.WriteLine($"'{longPattern}' custom format string:     {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 határozhatja meg az alkalmazás által definiált objektumok sztringképét, amelyet az objektum ToString(String) metódusa hoz létre. Meghatározhatja az objektum által támogatott konkrét szabványos formátumjelölőket, és eldöntheti, hogy megkülönbözteti-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 ToString metódusának paraméter nélküli túlterhelése hívja meg a ToString(String) túlterhelést, és adja át neki a "G" standard formátumú karakterláncot.

• Null értékű hivatkozással egyenlő formátumkijelölő támogatása (Nothing a 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 karakterláncok

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átum sztringek egy vagy több egyéni formátumjelölőből állnak, amelyek egy érték szöveges á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 a "2008/11/15 07:45:00.0000 P -08:00" alakú szöveges formára konvertálja a dátumot 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átumjelzőből áll, a formátumjelző előtt a százalék (%) jelet kell megadni, hogy elkerüljük a szabványos formátumjelző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átumának neve egyéni formátumok aliasaként szolgál, amelyeket a DateTimeFormatInfo objektum tulajdonságai definiálnak. 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átum sztringekkel kapcsolatos információkért tekintse meg az alábbi cikkeket:

Cím	Definíció
Standard numerikus formázó karakterláncok	A numerikus értékek gyakran használt sztring-ábrázolását létrehozó szabványos formátumú sztringeket ismerteti.
Egyéni számformázási karakterláncok	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 egyéni formátum sztringek, amelyek az alkalmazásspecifikus formátumokat hozzák létre a DateTime és DateTimeOffset értékekhez, ismerteti.
Standard TimeSpan formátum karakterláncok	Az időintervallumok gyakran használt sztring-ábrázolását létrehozó szabványos formátumú sztringeket ismerteti.
Egyéni TimeSpan formátumstringek	Azokat az egyéni formátumsztringeket ismerteti, amelyek alkalmazásspecifikus formátumokat hoznak létre az időintervallumokhoz.
Felsorolási formátum karakterláncok	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 Guid értékek szabványos formátumsztringjeinek leírása.

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. Például, egy szám pénznemként való formázásához a "C" standard formátumsztring vagy egy egyéni formátumsztring, mint "$ #,#.00", használata szükséges. Minimális követelmény, hogy rendelkezésre álljanak a megfelelő pénznemszimbólumra, csoportelválasztóra és decimális elválasztóra vonatkozó információk, hogy ezek belefoglalhatók legyenek a formázott sztringbe. 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 három különböző kultúrát képviselő objektummal IFormatProvider 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 ToString metódustúlterhelést hív meg, amely tartalmaz egy IFormatProvider paramétert, az meghívja annak az GetFormat objektumnak a IFormatProvider metódusát. 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

Megjegyzé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 saját magából ad vissza egy példányt.

• NumberFormatInfoosztály, amely numerikus formázási információkat biztosít egy adott kultúrához. A IFormatProvider.GetFormat megvalósítás saját magából ad vissza egy példányt.

• 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 adja meg a kulturális beállításokat, amikor formázási metódust hív meg, az aktuális kultúra formázási konvenciói kerülnek alkalmazásra. 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 ToString és ToString(String) metódusok becsomagolják a hívásokat az egyes numerikus típusok ToString(String, IFormatProvider) metódusához.

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 numerikus értéket egy adott kultúra szerint is formázhat úgy, hogy hív egy olyan ToString túlterhelést, amely tartalmaz egy provider paramétert, és az alábbiak valamelyikét adja át neki:

• Olyan CultureInfo objektum, amely azt a kultúrát jelöli, amelynek formázási konvencióit használni kell. A CultureInfo.GetFormat metódusa visszaadja a CultureInfo.NumberFormat tulajdonság értékét, amely az a NumberFormatInfo objektum, 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 adja meg a kulturális beállításokat, amikor formázási metódust hív meg, az aktuális kultúra formázási konvenciói kerülnek alkalmazásra. 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 becsomagolják a hívásokat a DateTime.ToString(String, IFormatProvider) és DateTimeOffset.ToString(String, IFormatProvider) metódusokra.

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 vagy DateTimeOffset.ToString túlterhelést, amelynek van egy provider paramétere, és átadja neki az alábbiak egyiké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

Általában azok a típusok, amelyek túlterhelik a ToString metódust egy formátumsztringgel és egy IFormatProvider paraméterrel, az IFormattable interfészt 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 Convert.ToString(Object) és Convert.ToString(Object, IFormatProvider) metódusok hívásai automatikusan meghívják az ön IFormattable megvalósítását.

• 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 IFormattable implementációt, és átadja neki a formátumsztringet. További információ az összetett formázásról olyan metódusokkal, mint például String.Format vagy Console.WriteLine, lásd az Összetett formázás rész.

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ódushívások viszont meghívják a IFormattable osztály Temperature implementációját.

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: {temp:K}");
        Console.WriteLine($"Temperature: {temp:F}");
        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. Az összetett formátumú karakterláncban minden objektumot egy indexelt formázási elem képvisel. 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 következő példában a String.Format metódus hívásakor az első formátumelem, {0:D}, helyébe a thatDate karakterláncos változata lép; a második formátumelem, {1}, helyébe a item1 karakterláncos változata lép; a harmadik formátumelem, {2:C2}, pedig a item1.Value karakterláncos változatával kerül lecserélésre.

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átumelem megfelelő objektumának sztringre való lecserélésén túl a formátumok lehetővé teszik a következő kontrollálását is:

• 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 (például {0:d}), és formázott egy numerikus értéket a "C2" formátumú sztringgel (például {2:C2}) a szám pénznemértékként való megjelenítéséhez két tört tizedesjegykel.

• 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.2
  

  Dim 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.2
  

  Ha az igazítási sztring összetevő és a formázási sztring összetevő is jelen van, az előbbi megelőzi 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 a GetFormat metódus feladata, hogy visszaadja a ICustomFormatter implementációt, amely egyéni formázást biztosít.

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 nevű ByteByByteFormatter implementációt mutat be, amely egész számokat jelenít meg kétjegyű hexadecimális értékek sorozataként, szóközzel elválasztva.

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 is not null) && !formatProvider.Equals(this)) return "";

        // Handle only hexadecimal format string.
        if ((format is not null) && !format.StartsWith("X")) return "";

        byte[] bytes;

        // Handle only integral types.
        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 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 "";

        string output= "";
        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. 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 a 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ó karakterláncok	A numerikus értékek gyakran használt sztring-ábrázolását létrehozó szabványos formátumú sztringeket ismerteti.
Egyéni számformázási karakterláncok	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-karakterláncokat ismerteti, amelyek gyakran használt ábrázolásokat hoznak létre a(z) DateTime értékeihez.
Egyéni dátum- és időformátum-karakterláncok	Azokat az egyéni formázási sztringeket írja le, amelyek alkalmazásspecifikus formátumokat hoznak létre a DateTime értékekhez.
Standard TimeSpan formátum karakterláncok	Az időintervallumok gyakran használt sztring-ábrázolását létrehozó szabványos formátumú sztringeket ismerteti.
Egyéni TimeSpan formátumstringek	Azokat az egyéni formátumsztringeket ismerteti, amelyek alkalmazásspecifikus formátumokat hoznak létre az időintervallumokhoz.
Felsorolási formátum karakterláncok	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

• System.IFormattable
• System.IFormatProvider
• System.ICustomFormatter