Delen via

Overzicht: Getallen, datums, opsommingen en andere typen opmaken in .NET

  • Artikel

Opmaak is het proces van het converteren van een exemplaar van een klasse of structuur of een opsommingswaarde naar een tekenreeksweergave. Het doel is om de resulterende tekenreeks weer te geven aan gebruikers of om deze later te deserialiseren om het oorspronkelijke gegevenstype te herstellen. In dit artikel worden de opmaakmechanismen geïntroduceerd die .NET biedt.

Notitie

Parseren is de inverse van opmaak. Met een parseerbewerking wordt een exemplaar van een gegevenstype gemaakt op basis van de tekenreeksweergave. Zie Tekenreeksen parseren voor meer informatie. Zie Serialisatie in .NET voor meer informatie over serialisatie en deserialisatie.

Het basismechanisme voor opmaak is de standaard implementatie van de Object.ToString methode, die verderop in dit onderwerp wordt besproken in de sectie Standaardopmaak met behulp van de methode ToString . .NET biedt echter verschillende manieren om de standaardopmaakondersteuning te wijzigen en uit te breiden. Deze omvatten de volgende:

  • De methode overschrijven Object.ToString om een aangepaste tekenreeksweergave van de waarde van een object te definiëren. Zie de sectie ToString Method later in dit onderwerp overschrijven voor meer informatie.

  • Opmaakaanduidingen definiëren waarmee de tekenreeksweergave van de waarde van een object meerdere vormen kan aannemen. De notatieaanduiding X in de volgende instructie converteert bijvoorbeeld een geheel getal naar de tekenreeksweergave van een hexadecimale waarde.

    int integerValue = 60312;
Console.WriteLine(integerValue.ToString("X"));   // Displays EB98.

    Dim integerValue As Integer = 60312
Console.WriteLine(integerValue.ToString("X"))   ' Displays EB98.

    Zie de sectie ToString Method and Format Strings (Tekenreeksen opmaken) voor meer informatie over opmaakaanduidingen .

  • Format providers gebruiken om de opmaakconventies van een specifieke cultuur te implementeren. In de volgende instructie wordt bijvoorbeeld een valutawaarde weergegeven met behulp van de opmaakconventies van de en-US-cultuur.

    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

    Zie de sectie Format Providers voor meer informatie over het opmaken van opmaakproviders .

  • IFormattable De interface implementeren ter ondersteuning van zowel tekenreeksconversie met de Convert klasse- als samengestelde opmaak. Zie de sectie IFormattable Interface voor meer informatie.

  • Samengestelde opmaak gebruiken om de tekenreeksweergave van een waarde in een grotere tekenreeks in te sluiten. Zie de sectie Samengestelde opmaak voor meer informatie.

  • Met behulp van tekenreeksinterpolatie wordt een beter leesbare syntaxis gebruikt om de tekenreeksweergave van een waarde in een grotere tekenreeks in te sluiten. Zie Tekenreeksinterpolatie voor meer informatie.

  • Implementeren ICustomFormatter en IFormatProvider bieden een volledige oplossing voor aangepaste opmaak. Zie de sectie Aangepaste opmaak met ICustomFormatter voor meer informatie.

In de volgende secties worden deze methoden onderzocht voor het converteren van een object naar de tekenreeksweergave.

Standaardopmaak met de methode ToString

Elk type dat is afgeleid van System.Object , neemt automatisch een methode zonder ToString parameters over, die standaard de naam van het type retourneert. In het volgende voorbeeld ziet u de standaardmethode ToString . Hiermee definieert u een klasse met de naam Automobile die geen implementatie heeft. Wanneer de klasse wordt geïnstantieerd en ToString de bijbehorende methode wordt aangeroepen, wordt de naam van het type weergegeven. Houd er rekening mee dat de ToString methode niet expliciet wordt aangeroepen in het voorbeeld. De Console.WriteLine(Object) methode roept impliciet de ToString methode aan van het object dat eraan is doorgegeven als argument.

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

Waarschuwing

Vanaf Windows 8.1 bevat de Windows Runtime een IStringable interface met één methode, IStringable.ToString, die standaardopmaakondersteuning biedt. We raden echter aan dat beheerde typen de IStringable interface niet implementeren. Zie De Windows Runtime en de IStringable Interface voor meer informatie.

Omdat alle andere typen dan interfaces worden afgeleid Object, wordt deze functionaliteit automatisch geleverd aan uw aangepaste klassen of structuren. De functionaliteit die wordt aangeboden door de standaardmethode ToString , is echter beperkt: Hoewel het type wordt geïdentificeerd, kan er geen informatie worden opgegeven over een exemplaar van het type. Als u een tekenreeksweergave wilt opgeven van een object dat informatie over dat object biedt, moet u de ToString methode overschrijven.

Notitie

Structuren overnemen van ValueType, die op hun beurt worden afgeleid van Object. Hoewel ValueType onderdrukkingen Object.ToString, is de implementatie identiek.

De Methode ToString overschrijven

Het weergeven van de naam van een type is vaak van beperkt gebruik en staat consumenten van uw typen niet toe om onderscheid te maken tussen exemplaren van een ander exemplaar. U kunt de ToString methode echter overschrijven om een nuttigere weergave van de waarde van een object te bieden. In het volgende voorbeeld wordt een Temperature object gedefinieerd en wordt de methode overschreven ToString om de temperatuur in graden Celsius weer te geven.

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.

In .NET is de ToString methode van elk primitieve waardetype overschreven om de waarde van het object weer te geven in plaats van de naam. In de volgende tabel ziet u de onderdrukking voor elk primitief type. Houd er rekening mee dat de meeste overschreven methoden een andere overbelasting van de ToString methode aanroepen en deze doorgeven aan de indelingSaanduiding 'G', waarmee de algemene indeling voor het type wordt gedefinieerd en een IFormatProvider object dat de huidige cultuur vertegenwoordigt.

Type ToString-onderdrukking
Boolean Retourneert een Boolean.TrueString of Boolean.FalseString.
Byte Aanroepen Byte.ToString("G", NumberFormatInfo.CurrentInfo) om de Byte waarde voor de huidige cultuur op te maken.
Char Retourneert het teken als een tekenreeks.
DateTime Aanroepen DateTime.ToString("G", DatetimeFormatInfo.CurrentInfo) om de datum- en tijdwaarde voor de huidige cultuur op te maken.
Decimal Aanroepen Decimal.ToString("G", NumberFormatInfo.CurrentInfo) om de Decimal waarde voor de huidige cultuur op te maken.
Double Aanroepen Double.ToString("G", NumberFormatInfo.CurrentInfo) om de Double waarde voor de huidige cultuur op te maken.
Int16 Aanroepen Int16.ToString("G", NumberFormatInfo.CurrentInfo) om de Int16 waarde voor de huidige cultuur op te maken.
Int32 Aanroepen Int32.ToString("G", NumberFormatInfo.CurrentInfo) om de Int32 waarde voor de huidige cultuur op te maken.
Int64 Aanroepen Int64.ToString("G", NumberFormatInfo.CurrentInfo) om de Int64 waarde voor de huidige cultuur op te maken.
SByte Aanroepen SByte.ToString("G", NumberFormatInfo.CurrentInfo) om de SByte waarde voor de huidige cultuur op te maken.
Single Aanroepen Single.ToString("G", NumberFormatInfo.CurrentInfo) om de Single waarde voor de huidige cultuur op te maken.
UInt16 Aanroepen UInt16.ToString("G", NumberFormatInfo.CurrentInfo) om de UInt16 waarde voor de huidige cultuur op te maken.
UInt32 Aanroepen UInt32.ToString("G", NumberFormatInfo.CurrentInfo) om de UInt32 waarde voor de huidige cultuur op te maken.
UInt64 Aanroepen UInt64.ToString("G", NumberFormatInfo.CurrentInfo) om de UInt64 waarde voor de huidige cultuur op te maken.

De methode ToString en tekenreeksen opmaken

Afhankelijk van de standaardmethode ToString of onderdrukking ToString is geschikt wanneer een object één tekenreeksweergave heeft. De waarde van een object heeft echter vaak meerdere representaties. Een temperatuur kan bijvoorbeeld worden uitgedrukt in graden Fahrenheit, graden Celsius of kelvins. Op dezelfde manier kan de gehele waarde 10 op verschillende manieren worden weergegeven, waaronder 10, 10,0, 1,0e01 of $ 10,00.

Als u één waarde wilt inschakelen voor meerdere tekenreeksweergaven, maakt .NET gebruik van notatietekenreeksen. Een notatietekenreeks is een tekenreeks die een of meer vooraf gedefinieerde notatieaanduidingen bevat. Dit zijn enkele tekens of groepen tekens die bepalen hoe de methode de ToString uitvoer moet opmaken. De notatietekenreeks wordt vervolgens doorgegeven als een parameter aan de methode van ToString het object en bepaalt hoe de tekenreeksweergave van de waarde van dat object moet worden weergegeven.

Alle numerieke typen, datum- en tijdtypen en opsommingstypen in .NET ondersteunen een vooraf gedefinieerde set opmaakaanduidingen. U kunt ook opmaaktekenreeksen gebruiken om meerdere tekenreeksweergaven van uw toepassingsgedefinieerde gegevenstypen te definiëren.

Tekenreeksen met standaardindeling

Een standaardnotatietekenreeks bevat één opmaakaanduiding, een alfabetisch teken dat de tekenreeksweergave definieert van het object waarop het wordt toegepast, samen met een optionele precisieaanduiding die van invloed is op het aantal cijfers in de resultaattekenreeks. Als de precisieaanduiding wordt weggelaten of niet wordt ondersteund, is een standaardnotatieaanduiding gelijk aan een standaardnotatietekenreeks.

.NET definieert een set standaardnotatieaanduidingen voor alle numerieke typen, alle datum- en tijdtypen en alle opsommingstypen. Elk van deze categorieën ondersteunt bijvoorbeeld een standaardnotatieaanduiding G, waarmee een algemene tekenreeksweergave van een waarde van dat type wordt gedefinieerd.

Tekenreeksen met standaardindeling voor opsommingstypen bepalen rechtstreeks de tekenreeksweergave van een waarde. De notatietekenreeksen die worden doorgegeven aan de methode van ToString een opsommingswaarde, bepalen of de waarde wordt weergegeven met de tekenreeksnaam (de notatieaanduiding 'G' en 'F'), de onderliggende integrale waarde (de notatieaanduiding D) of de hexadecimale waarde (de notatieaanduiding 'X'). In het volgende voorbeeld ziet u het gebruik van tekenreeksen met standaardindelingen om een DayOfWeek opsommingswaarde op te maken.

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

Zie Opsomming opmaaktekenreeksen voor meer informatie over opsommingstekenreeksen.

Standaardnotatietekenreeksen voor numerieke typen definiëren meestal een resultaattekenreeks waarvan het exacte uiterlijk wordt bepaald door een of meer eigenschapswaarden. Met de notatieaanduiding 'C' wordt bijvoorbeeld een getal opgemaakt als valutawaarde. Wanneer u de ToString methode aanroept met de notatieaanduiding 'C' als enige parameter, worden de volgende eigenschapswaarden van het object van de huidige cultuur NumberFormatInfo gebruikt om de tekenreeksweergave van de numerieke waarde te definiëren:

  • De CurrencySymbol eigenschap, waarmee het valutasymbool van de huidige cultuur wordt opgegeven.

  • De CurrencyNegativePattern of CurrencyPositivePattern eigenschap, die een geheel getal retourneert dat het volgende bepaalt:

    • De positie van het valutasymbool.

    • Of negatieve waarden worden aangegeven door een voorloop negatief teken, een volg negatief teken of haakjes.

    • Of er een spatie wordt weergegeven tussen de numerieke waarde en het valutasymbool.

  • De CurrencyDecimalDigits eigenschap, waarmee het aantal fractionele cijfers in de resultaattekenreeks wordt gedefinieerd.

  • De CurrencyDecimalSeparator eigenschap, waarmee het decimaalteken wordt gedefinieerd in de resultaattekenreeks.

  • De CurrencyGroupSeparator eigenschap, waarmee het groepsscheidingsteken wordt gedefinieerd.

  • De CurrencyGroupSizes eigenschap, waarmee het aantal cijfers in elke groep links van het decimaalteken wordt gedefinieerd.

  • De NegativeSign eigenschap, die bepaalt welk negatief teken wordt gebruikt in de resultaattekenreeks als haakjes niet worden gebruikt om negatieve waarden aan te geven.

Daarnaast kunnen tekenreeksen met numerieke notatie een precisieaanduiding bevatten. De betekenis van deze aanduiding is afhankelijk van de notatietekenreeks waarmee deze wordt gebruikt, maar geeft meestal het totale aantal cijfers of het aantal fractionele cijfers aan dat in de resultaattekenreeks moet worden weergegeven. In het volgende voorbeeld wordt bijvoorbeeld de standaard numerieke X4-tekenreeks en een precisieaanduiding gebruikt om een tekenreekswaarde met vier hexadecimale cijfers te maken.

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

Zie Standaardtekenreeksen voor numerieke opmaak voor meer informatie over standaardtekenreeksen voor numerieke notatie.

Standaardnotatietekenreeksen voor datum- en tijdwaarden zijn aliassen voor tekenreeksen met aangepaste notatie die zijn opgeslagen door een bepaalde DateTimeFormatInfo eigenschap. Als u bijvoorbeeld de ToString methode van een datum- en tijdwaarde aanroept met de notatieaanduiding D, wordt de datum en tijd weergegeven met behulp van de tekenreeks voor aangepaste notatie die is opgeslagen in de eigenschap van DateTimeFormatInfo.LongDatePattern de huidige cultuur. (Zie de volgende sectie voor meer informatie over tekenreeksen met aangepaste notatie.) In het volgende voorbeeld ziet u deze relatie.

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

Zie Standaardtekenreeksen voor datum- en tijdnotatie voor meer informatie over standaardtekenreeksen voor datum- en tijdnotatie.

U kunt ook tekenreeksen met standaardindeling gebruiken om de tekenreeksweergave te definiëren van een toepassingsgedefinieerd object dat wordt geproduceerd door de methode van ToString(String) het object. U kunt de specifieke standaardnotatieaanduidingen definiëren die door uw object worden ondersteund en u kunt bepalen of ze hoofdlettergevoelig of niet hoofdlettergevoelig zijn. Uw implementatie van de ToString(String) methode moet het volgende ondersteunen:

  • Een indelingsaanduiding 'G' die een aangepaste of gemeenschappelijke indeling van het object vertegenwoordigt. De parameterloze overbelasting van de methode van uw object ToString moet de ToString(String) overbelasting aanroepen en deze doorgeven aan de standaardnotatietekenreeks G.

  • Ondersteuning voor een indelingsaanduiding die gelijk is aan een null-verwijzing (Nothing in Visual Basic). Een notatieaanduiding die gelijk is aan een null-verwijzing, moet worden beschouwd als equivalent aan de notatieaanduiding G.

Een Temperature klasse kan bijvoorbeeld de temperatuur intern opslaan in graden Celsius en notatieaanduidingen gebruiken om de waarde van het Temperature object in graden Celsius, graden Fahrenheit en kelvins weer te geven. In het volgende voorbeeld ziet u een afbeelding.

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.

Tekenreeksen voor aangepaste notatie

Naast de standaardnotatietekenreeksen definieert .NET aangepaste notatietekenreeksen voor zowel numerieke waarden als datum- en tijdwaarden. Een tekenreeks met aangepaste notatie bestaat uit een of meer aangepaste notatieaanduidingen waarmee de tekenreeksweergave van een waarde wordt gedefinieerd. De tekenreeks 'jjjj/mm/dd hh:mm:mm:ss.ffff t zzz' converteert bijvoorbeeld een datum naar de tekenreeksweergave in de vorm '2008/11/15 07:45:00.000 P -08:00' voor de en-US-cultuur. Op dezelfde manier converteert de tekenreeks met de aangepaste notatie '0000' de gehele waarde 12 naar '0012'. Zie Aangepaste tekenreeksen voor datum- en tijdnotatie en tekenreeksen met aangepaste numerieke notatie voor een volledige lijst met tekenreeksen voor aangepaste notatie.

Als een notatietekenreeks bestaat uit één aangepaste notatieaanduiding, moet de opmaakaanduiding worden voorafgegaan door het symbool percentage (%) om verwarring met een standaardnotatieaanduiding te voorkomen. In het volgende voorbeeld wordt de aangepaste notatieaanduiding 'M' gebruikt om een of twee cijfers van de maand van een bepaalde datum weer te geven.

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

Veel standaardnotatietekenreeksen voor datum- en tijdwaarden zijn aliassen voor tekenreeksen met aangepaste notatie die zijn gedefinieerd door eigenschappen van het DateTimeFormatInfo object. Tekenreeksen met aangepaste notatie bieden ook aanzienlijke flexibiliteit bij het bieden van door de toepassing gedefinieerde opmaak voor numerieke waarden of datum- en tijdwaarden. U kunt uw eigen aangepaste resultaattekenreeksen definiëren voor zowel numerieke waarden als datum- en tijdwaarden door meerdere aangepaste notatieaanduidingen te combineren tot één aangepaste notatietekenreeks. In het volgende voorbeeld wordt een aangepaste notatietekenreeks gedefinieerd die de dag van de week weergeeft tussen haakjes na de maandnaam, dag en jaar.

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)

In het volgende voorbeeld wordt een tekenreeks met aangepaste notatie gedefinieerd waarmee een Int64 waarde wordt weergegeven als een standaard, zevencijferig Amerikaans telefoonnummer, samen met het netnummer.

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

Hoewel standaardopmaaktekenreeksen over het algemeen de meeste opmaakbehoeften voor door uw toepassing gedefinieerde typen kunnen verwerken, kunt u ook aangepaste opmaakaanduidingen definiëren om uw typen op te maken.

Tekenreeksen en .NET-typen opmaken

Alle numerieke typen (dat wil gezegd, de Byte, Decimal, Double, , Int16, , SByteSingleUInt32Int32Int64UInt64UInt16en BigInteger typen), evenals de DateTimetypen DateTimeOffset, , TimeSpan, , en Guidalle opsommingstypen, ondersteunen opmaak met opmaaktekenreeksen. Zie de volgende onderwerpen voor informatie over de specifieke indelingstekenreeksen die door elk type worden ondersteund:

Titel Definitie
Tekenreeksen met numerieke standaardopmaak Beschrijft standaardnotatietekenreeksen die veelgebruikte tekenreeksweergaven van numerieke waarden maken.
Tekenreeksen voor aangepaste numerieke notatie Beschrijft tekenreeksen voor aangepaste notaties die toepassingsspecifieke indelingen maken voor numerieke waarden.
Standaardnotatietekenreeksen voor datum en tijd Beschrijft standaardopmaaktekenreeksen waarmee veelgebruikte tekenreeksen en DateTime DateTimeOffset waarden worden gemaakt.
Aangepaste datum- en tijdnotatietekenreeksen Beschrijft tekenreeksen voor aangepaste indelingen die toepassingsspecifieke indelingen voor DateTime en DateTimeOffset waarden maken.
Tekenreeksen met standaardtijdspannenotatie Beschrijft standaardnotatietekenreeksen die veelgebruikte tekenreeksweergaven van tijdsintervallen maken.
Tekenreeksen voor aangepaste tijdspannenotatie Beschrijft tekenreeksen voor aangepaste indelingen die toepassingsspecifieke indelingen maken voor tijdsintervallen.
Opsommingstekenreeksen opmaken Beschrijft tekenreeksen met standaardindeling die worden gebruikt om tekenreeksweergaven van opsommingswaarden te maken.
Guid.ToString(String) Hierin worden tekenreeksen voor standaardindelingen voor Guid waarden beschreven.

Cultuurgevoelige opmaak met opmaakproviders

Hoewel u met opmaakaanduidingen de opmaak van objecten kunt aanpassen, is voor het produceren van een zinvolle tekenreeksweergave van objecten vaak aanvullende opmaakgegevens vereist. Als u bijvoorbeeld een getal opmaakt als valutawaarde met behulp van de tekenreeks voor de standaardnotatie C of een tekenreeks met aangepaste notatie, zoals '$ #,#.00', is minimaal informatie vereist over het juiste valutasymbool, het groepsscheidingsteken en het decimaalteken dat beschikbaar moet zijn om op te nemen in de opgemaakte tekenreeks. In .NET wordt deze aanvullende opmaakgegevens beschikbaar gesteld via de IFormatProvider interface, die wordt geleverd als parameter voor een of meer overbelastingen van de ToString methode van numerieke typen en datum- en tijdtypen. IFormatProvider implementaties worden gebruikt in .NET ter ondersteuning van cultuurspecifieke opmaak. In het volgende voorbeeld ziet u hoe de tekenreeksweergave van een object verandert wanneer het is opgemaakt met drie IFormatProvider objecten die verschillende culturen vertegenwoordigen.

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 €

De IFormatProvider interface bevat één methode, GetFormat(Type)die één parameter bevat waarmee het type object wordt opgegeven dat opmaakinformatie biedt. Als de methode een object van dat type kan bieden, wordt het geretourneerd. Anders wordt een null-verwijzing geretourneerd (Nothing in Visual Basic).

IFormatProvider.GetFormat is een callback-methode. Wanneer u een overbelasting van een ToString methode aanroept die een IFormatProvider parameter bevat, wordt de GetFormat methode van dat IFormatProvider object aangeroepen. De GetFormat methode is verantwoordelijk voor het retourneren van een object dat de benodigde opmaakgegevens levert, zoals opgegeven door formatType de parameter, aan de ToString methode.

Een aantal opmaak- of tekenreeksconversiemethoden bevatten een parameter van het type IFormatProvider, maar in veel gevallen wordt de waarde van de parameter genegeerd wanneer de methode wordt aangeroepen. De volgende tabel bevat een aantal opmaakmethoden die gebruikmaken van de parameter en het Type type object dat ze doorgeven aan de IFormatProvider.GetFormat methode.

Wijze formatType Type parameter
ToString methode van numerieke typen System.Globalization.NumberFormatInfo
ToString methode van datum- en tijdtypen System.Globalization.DateTimeFormatInfo
String.Format System.ICustomFormatter
StringBuilder.AppendFormat System.ICustomFormatter

Notitie

De ToString methoden van de numerieke typen en datum- en tijdtypen zijn overbelast en slechts enkele van de overbelastingen bevatten een IFormatProvider parameter. Als een methode geen parameter van het type IFormatProviderheeft, wordt het object dat door de CultureInfo.CurrentCulture eigenschap wordt geretourneerd, doorgegeven. Een aanroep naar de standaardmethode Int32.ToString() resulteert bijvoorbeeld uiteindelijk in een methode-aanroep zoals: Int32.ToString("G", System.Globalization.CultureInfo.CurrentCulture)

.NET biedt drie klassen die het volgende implementeren IFormatProvider:

U kunt ook uw eigen indelingsprovider implementeren om een van deze klassen te vervangen. De methode van GetFormat uw implementatie moet echter een object retourneren van het type dat in de vorige tabel wordt vermeld als deze opmaakinformatie moet opgeven voor de ToString methode.

Cultuurgevoelige opmaak van numerieke waarden

Standaard is de opmaak van numerieke waarden cultuurgevoelig. Als u geen cultuur opgeeft wanneer u een opmaakmethode aanroept, worden de opmaakconventies van de huidige cultuur gebruikt. Dit wordt geïllustreerd in het volgende voorbeeld, waarmee de huidige cultuur vier keer wordt gewijzigd en vervolgens de Decimal.ToString(String) methode wordt aangeroepen. In elk geval weerspiegelt de resultaattekenreeks de opmaakconventies van de huidige cultuur. Dit komt doordat de ToString en ToString(String) methoden aanroepen naar elke methode van ToString(String, IFormatProvider) het numerieke type verpakken.

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 €

U kunt ook een numerieke waarde voor een specifieke cultuur opmaken door een overbelasting met een ToString provider parameter aan te roepen en deze op een van de volgende manieren door te geven:

In het volgende voorbeeld worden objecten gebruikt NumberFormatInfo die de Engelse culturen (Verenigde Staten) en Engels (Verenigd Koninkrijk) en de Franse en Russische neutrale culturen vertegenwoordigen om een drijvendekommagetal op te maken.

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

Cultuurgevoelige opmaak van datum- en tijdwaarden

Standaard is de opmaak van datum- en tijdwaarden cultuurgevoelig. Als u geen cultuur opgeeft wanneer u een opmaakmethode aanroept, worden de opmaakconventies van de huidige cultuur gebruikt. Dit wordt geïllustreerd in het volgende voorbeeld, waarmee de huidige cultuur vier keer wordt gewijzigd en vervolgens de DateTime.ToString(String) methode wordt aangeroepen. In elk geval weerspiegelt de resultaattekenreeks de opmaakconventies van de huidige cultuur. Dit komt doordat de DateTime.ToString(), DateTime.ToString(String)en DateTimeOffset.ToString()DateTimeOffset.ToString(String) methoden aanroepen naar de DateTime.ToString(String, IFormatProvider) en DateTimeOffset.ToString(String, IFormatProvider) methoden verpakken.

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

U kunt ook een datum- en tijdwaarde voor een specifieke cultuur opmaken door een DateTime.ToString of DateTimeOffset.ToString overbelasting aan te roepen die een provider parameter heeft en deze op een van de volgende manieren door te geven:

In het volgende voorbeeld worden objecten gebruikt DateTimeFormatInfo die de Engelse culturen (Verenigde Staten) en Engels (Verenigd Koninkrijk) en de Franse en Russische neutrale culturen vertegenwoordigen om een datum op te maken.

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

De IFormattable-interface

Normaal gesproken worden typen die de ToString methode overbelasten met een notatietekenreeks en een IFormatProvider parameter ook de IFormattable interface implementeren. Deze interface heeft één lid, IFormattable.ToString(String, IFormatProvider)dat zowel een notatietekenreeks als een indelingsprovider als parameters bevat.

Het implementeren van de IFormattable interface voor uw toepassingsgedefinieerde klasse biedt twee voordelen:

In het volgende voorbeeld wordt een Temperature klasse gedefinieerd waarmee de IFormattable interface wordt geïmplementeerd. Het ondersteunt de notatieaanduidingen 'C' of 'G' om de temperatuur in Celsius weer te geven, de notatieaanduiding 'F' om de temperatuur in Fahrenheit weer te geven en de notatieaanduiding K om de temperatuur in Kelvin weer te geven.

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

In het volgende voorbeeld wordt een Temperature object geïnstitueert. Vervolgens wordt de ToString methode aangeroepen en worden verschillende tekenreeksen met samengestelde indelingen gebruikt om verschillende tekenreeksweergaven van een Temperature object te verkrijgen. Elk van deze methode-aanroepen roept op zijn beurt de IFormattable implementatie van de Temperature klasse aan.

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

Samengestelde opmaak

Sommige methoden, zoals String.Format en StringBuilder.AppendFormat, ondersteunen samengestelde opmaak. Een tekenreeks met samengestelde opmaak is een soort sjabloon die één tekenreeks retourneert die de tekenreeksweergave van nul, een of meer objecten bevat. Elk object wordt weergegeven in de tekenreeks voor samengestelde indeling door een geïndexeerd opmaakitem. De index van het notatie-item komt overeen met de positie van het object dat wordt aangegeven in de parameterlijst van de methode. Indexen zijn gebaseerd op nul. In de volgende aanroep van de String.Format methode wordt bijvoorbeeld het eerste opmaakitem {0:D}vervangen door de tekenreeksweergave van thatDate; het tweede notatie-item, {1}wordt vervangen door de tekenreeksweergave van item1; en het derde opmaakitem , {2:C2}vervangen door de tekenreeksweergave van item1.Value.

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.

Naast het vervangen van een opmaakitem door de tekenreeksweergave van het bijbehorende object, kunt u ook het volgende bepalen door items op te maken:

  • De specifieke manier waarop een object wordt weergegeven als een tekenreeks, als het object de IFormattable interface implementeert en opmaaktekenreeksen ondersteunt. U doet dit door de index van het notatie-item te volgen met een : (dubbele punt) gevolgd door een geldige notatietekenreeks. In het vorige voorbeeld is dit gedaan door een datumwaarde op te maken met de notatietekenreeks 'd' (korte datumpatroon) en {0:d}door een numerieke waarde op te maken met de tekenreeks 'C2'-notatie (bijvoorbeeld {2:C2} om het getal weer te geven als een valutawaarde met twee decimale decimalen).

  • De breedte van het veld dat de tekenreeksweergave van het object bevat en de uitlijning van de tekenreeksweergave in dat veld. U doet dit door de index van het opmaakitem te volgen met een , (komma) gevolgde veldbreedte. De tekenreeks wordt rechts uitgelijnd in het veld als de veldbreedte een positieve waarde is en deze links is uitgelijnd als de veldbreedte een negatieve waarde is. In het volgende voorbeeld worden datumwaarden in een veld van 20 tekens links uitgelijnd en worden decimale waarden rechts uitgelijnd met één breukcijfer in een veld van 11 tekens.

    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

    Houd er rekening mee dat als zowel het uitlijningstekenreeksonderdeel als het opmaaktekenreeksonderdeel aanwezig zijn, de vorige voorafgaat aan de laatste (bijvoorbeeld {0,-20:g}.

Zie Samengestelde opmaak voor meer informatie over samengestelde opmaak.

Aangepaste opmaak met ICustomFormatter

Twee samengestelde opmaakmethoden String.Format(IFormatProvider, String, Object[]) en StringBuilder.AppendFormat(IFormatProvider, String, Object[])bevatten een parameter voor de indelingsprovider die aangepaste opmaak ondersteunt. Wanneer een van deze opmaakmethoden wordt aangeroepen, wordt een Type object doorgegeven dat een ICustomFormatter interface aangeeft voor de methode van GetFormat de indelingsprovider. De GetFormat methode is vervolgens verantwoordelijk voor het retourneren van de ICustomFormatter implementatie die aangepaste opmaak biedt.

De ICustomFormatter interface heeft één methode, Format(String, Object, IFormatProvider)die automatisch wordt aangeroepen door een samengestelde opmaakmethode, één keer voor elk opmaakitem in een tekenreeks met samengestelde opmaak. De Format(String, Object, IFormatProvider) methode heeft drie parameters: een notatietekenreeks, die het formatString argument in een notatie-item vertegenwoordigt, een object dat moet worden opgemaakt en een IFormatProvider object dat opmaakservices biedt. Normaal gesproken implementeert de klasse die ook implementeert ICustomFormatter IFormatProvider, dus deze laatste parameter is een verwijzing naar de aangepaste opmaakklasse zelf. De methode retourneert een aangepaste, opgemaakte tekenreeksweergave van het object dat moet worden opgemaakt. Als de methode het object niet kan opmaken, moet het een null-verwijzing (Nothing in Visual Basic) retourneren.

In het volgende voorbeeld ziet u een ICustomFormatter implementatie die ByteByByteFormatter gehele getallen weergeeft als een reeks hexadecimale waarden van twee cijfers, gevolgd door een spatie.

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

In het volgende voorbeeld wordt de ByteByByteFormatter klasse gebruikt om gehele getallen op te maken. Houd er rekening mee dat de ICustomFormatter.Format methode meer dan één keer wordt aangeroepen in de tweede String.Format(IFormatProvider, String, Object[]) methode-aanroep en dat de standaardprovider NumberFormatInfo wordt gebruikt in de derde methode-aanroep omdat de .ByteByByteFormatter.Format de notatietekenreeks N0 wordt niet herkend en retourneert een null-verwijzing (Nothing in Visual Basic).

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

Zie ook

Titel Definitie
Tekenreeksen met numerieke standaardopmaak Beschrijft standaardnotatietekenreeksen die veelgebruikte tekenreeksweergaven van numerieke waarden maken.
Tekenreeksen voor aangepaste numerieke notatie Beschrijft tekenreeksen voor aangepaste notaties die toepassingsspecifieke indelingen maken voor numerieke waarden.
Standaardnotatietekenreeksen voor datum en tijd Beschrijft standaardnotatietekenreeksen die veelgebruikte tekenreeksweergaven van DateTime waarden maken.
Aangepaste datum- en tijdnotatietekenreeksen Beschrijft tekenreeksen voor aangepaste indelingen die toepassingsspecifieke indelingen voor DateTime waarden maken.
Tekenreeksen met standaardtijdspannenotatie Beschrijft standaardnotatietekenreeksen die veelgebruikte tekenreeksweergaven van tijdsintervallen maken.
Tekenreeksen voor aangepaste tijdspannenotatie Beschrijft tekenreeksen voor aangepaste indelingen die toepassingsspecifieke indelingen maken voor tijdsintervallen.
Opsommingstekenreeksen opmaken Beschrijft tekenreeksen met standaardindeling die worden gebruikt om tekenreeksweergaven van opsommingswaarden te maken.
Samengestelde opmaak Beschrijft hoe u een of meer opgemaakte waarden insluit in een tekenreeks. De tekenreeks kan vervolgens worden weergegeven op de console of naar een stream worden geschreven.
Tekenreeksen parseren Beschrijft hoe u objecten initialiseert naar de waarden die worden beschreven door tekenreeksweergaven van deze objecten. Parseren is de inverse bewerking van opmaak.

Verwijzing