Methode System.String.Format

2025-06-17

In dit artikel vindt u aanvullende opmerkingen in de referentiedocumentatie voor deze API.

Belangrijk

In plaats van de methode String.Format aan te roepen of samengestelde notatietekenreeksenaan te roepen, kunt u geïnterpoleerde tekenreeksen gebruiken als uw taal deze ondersteunt. Een geïnterpoleerde tekenreeks is een tekenreeks die geïnterpoleerde expressiesbevat. Elke geïnterpoleerde expressie wordt opgelost met de waarde van de expressie en opgenomen in de resultaattekenreeks wanneer de tekenreeks wordt toegewezen. Zie Tekenreeksinterpolatie (C#-verwijzing) en geïnterpoleerde tekenreeksen (Visual Basic Reference) voor meer informatie.

Voorbeelden

In dit artikel worden talloze voorbeelden beschreven die de methode Format aanroepen. U kunt ook een volledige set String.Format voorbeelden downloaden, die een .NET Core-project voor C#bevatten.

Hier volgen enkele voorbeelden in het artikel:

Aan de slag met de methode String.Format

Gebruik String.Format als u de waarde van een object, variabele of expressie in een andere tekenreeks wilt invoegen. U kunt bijvoorbeeld de waarde van een Decimal-waarde invoegen in een tekenreeks om deze als één tekenreeks weer te geven aan de gebruiker:

Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result: The current price is 17.36 per ounce.

let pricePerOunce = 17.36m
String.Format("The current price is {0} per ounce.", pricePerOunce)
|> printfn "%s"
// Result: The current price is 17.36 per ounce.

Dim pricePerOunce As Decimal = 17.36D
Dim s As String = String.Format("The current price is {0} per ounce.",
                              pricePerOunce)
' Result: The current price is 17.36 per ounce.

En u kunt de opmaak van die waarde bepalen:

Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0:C2} per ounce.",
                         pricePerOunce);
Console.WriteLine(s);
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.

let pricePerOunce = 17.36m
String.Format("The current price is {0:C2} per ounce.", pricePerOunce)
|> printfn "%s"
// Result if current culture is en-US:
//      The current price is $17.36 per ounce.

Dim pricePerOunce As Decimal = 17.36D
Dim s As String = String.Format("The current price is {0:C2} per ounce.",
                              pricePerOunce)
' Result if current culture is en-US:
'      The current price is $17.36 per ounce.

Naast opmaak kunt u ook de uitlijning en afstand regelen.

Een tekenreeks invoegen

String.Format begint met een notatietekenreeks, gevolgd door een of meer objecten of expressies die worden geconverteerd naar tekenreeksen en worden ingevoegd op een opgegeven plaats in de notatietekenreeks. Voorbeeld:

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

let temp = 20.4m
String.Format("The temperature is {0}°C.", temp)
|> printfn "%s"
// Displays 'The temperature is 20.4°C.'

Dim temp As Decimal = 20.4D
Dim s As String = String.Format("The temperature is {0}°C.", temp)
Console.WriteLine(s)
' Displays 'The temperature is 20.4°C.'

De {0} in de notatietekenreeks is een formateringsitem. 0 is de index van het object waarvan de tekenreekswaarde op die positie wordt ingevoegd. (Indexen beginnen bij 0.) Als het object dat moet worden ingevoegd geen tekenreeks is, wordt de bijbehorende ToString methode aangeroepen om het te converteren naar een tekenreeks voordat u het invoegt in de resultaattekenreeks.

Hier volgt een ander voorbeeld waarin twee opmaakitems en twee objecten in de lijst met objecten worden gebruikt:

string s = String.Format("At {0}, the temperature is {1}°C.",
                         DateTime.Now, 20.4);
Console.WriteLine(s);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'

String.Format("At {0}, the temperature is {1}°C.", DateTime.Now, 20.4)
|> printfn "%s"
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'

Dim s As String = String.Format("At {0}, the temperature is {1}°C.",
                              Date.Now, 20.4)
' Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'

U kunt zoveel opmaakitems en zoveel objecten in de lijst met objecten hebben als u wilt, zolang de index van elk opmaakitem een overeenkomend object in de lijst met objecten heeft. U hoeft zich ook geen zorgen te maken over welke overloading u aanroept; de compiler selecteert de juiste voor u.

Beheer opmaak

U kunt de index volgen in een indelingsitem met een notatietekenreeks om te bepalen hoe een object is opgemaakt. {0:d} bijvoorbeeld de notatietekenreeks 'd' toepast op het eerste object in de lijst met objecten. Hier volgt een voorbeeld met één object en twee opmaakitems:

string s = String.Format("It is now {0:d} at {0:t}", DateTime.Now);
Console.WriteLine(s);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'

String.Format("It is now {0:d} at {0:t}", DateTime.Now)
|> printfn "%s"
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'

Dim s As String = String.Format("It is now {0:d} at {0:t}",
                              Date.Now)
' Output similar to: 'It is now 4/10/2015 at 10:04 AM'

Verschillende typen ondersteunen notatietekenreeksen, waaronder alle numerieke typen (zowel standaardtekenreeksen als aangepaste notatietekenreeksen), alle datums en tijden (zowel standaard - als aangepaste notatietekenreeksen) en tijdsintervallen (zowel standaard - als aangepaste notatietekenreeksen), alle opsommingstypen en GUID's. U kunt ook ondersteuning voor opmaaktekenreeksen toevoegen aan uw eigen typen.

Ruimte tussen bedieningsonderdelen

U kunt de breedte definiëren van de tekenreeks die in de resultaattekenreeks wordt ingevoegd met behulp van syntaxis zoals {0,12}, waarmee een tekenreeks van 12 tekens wordt ingevoegd. In dit geval wordt de tekenreeksweergave van het eerste object rechts uitgelijnd in het veld met 12 tekens. (Als de tekenreeksweergave van het eerste object echter langer is dan 12 tekens, wordt de voorkeursveldbreedte genegeerd en wordt de hele tekenreeks ingevoegd in de resultaattekenreeks.)

In het volgende voorbeeld wordt een veld van 6 tekens gedefinieerd waarin de tekenreeks Year en een aantal jaartekenreeksen worden opgeslagen, evenals een veld van 15 tekens waarin de tekenreeks Bevolking en sommige populatiegegevens worden opgeslagen. Houd er rekening mee dat de tekens rechts zijn uitgelijnd in het veld.

int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
var sb = new System.Text.StringBuilder();
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
for (int index = 0; index < years.Length; index++)
    sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));

Console.WriteLine(sb);

// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203

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

printfn $"{sb}"

// Result:
//      Year      Population
//
//      2013       1,025,632
//      2014       1,105,967
//      2015       1,148,203

Dim years() As Integer = {2013, 2014, 2015}
Dim population() As Integer = {1025632, 1105967, 1148203}
Dim sb As New StringBuilder()
sb.Append(String.Format("{0,6} {1,15}{2}{2}",
                       "Year", "Population", vbCrLf))
For index As Integer = 0 To years.Length - 1
    sb.AppendFormat("{0,6} {1,15:N0}{2}",
                  years(index), population(index), vbCrLf)
Next
' Result:
'      Year      Population
'
'      2013       1,025,632
'      2014       1,105,967
'      2015       1,148,203

Uitlijning van besturingselementen

Tekenreeksen worden standaard rechts uitgelijnd binnen het veld als u een veldbreedte opgeeft. Als u tekenreeksen in een veld links wilt uitlijnen, begint u de veldbreedte met een negatief teken, zoals {0,-12} om een links uitgelijnd veld van 12 tekens te definiëren.

Het volgende voorbeeld is vergelijkbaar met de vorige, behalve dat deze zowel labels als gegevens links uitlijnt.

int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for (int index = 0; index < years.Length; index++)
    s += String.Format("{0,-10} {1,-10:N0}\n",
                       years[index], population[index]);
Console.WriteLine($"\n{s}");
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203

let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let mutable s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population")
for i = 0 to years.Length - 1 do
    s <- s + String.Format("{0,-10} {1,-10:N0}\n", years[i], population[i])
printfn $"\n{s}"
// Result:
//    Year       Population
//
//    2013       1,025,632
//    2014       1,105,967
//    2015       1,148,203

Dim years() As Integer = {2013, 2014, 2015}
Dim population() As Integer = {1025632, 1105967, 1148203}
Dim s As String = String.Format("{0,-10} {1,-10}{2}{2}",
                               "Year", "Population", vbCrLf)
For index As Integer = 0 To years.Length - 1
    s += String.Format("{0,-10} {1,-10:N0}{2}",
                     years(index), population(index), vbCrLf)
Next
' Result:
'    Year       Population
'
'    2013       1,025,632
'    2014       1,105,967
'    2015       1,148,203

String.Format maakt gebruik van de functie voor samengestelde opmaak. Zie Samengestelde opmaak voor meer informatie.

Welke methode roep ik aan?

Doelstelling	Methode om aan te roepen
Maak een of meer objecten op met behulp van de conventies van de huidige cultuur.	Behalve de overbelastingen die een `provider` parameter bevatten, bevatten de resterende Format overbelastingen een String parameter gevolgd door een of meer objectparameters. Daarom hoeft u niet te bepalen welke Format overload u wilt aanroepen. Uw taalcompilator selecteert de juiste overbelasting tussen de overbelastingen die geen `provider` parameter hebben, op basis van uw lijst met argumenten. Als de lijst met argumenten bijvoorbeeld vijf argumenten heeft, roept de compiler de methode Format(String, Object[]) aan.
Maak een of meer objecten op met behulp van de conventies van een specifieke cultuur.	Elke Format overbelasting die begint met een `provider` parameter wordt gevolgd door een String parameter en een of meer objectparameters. Daarom hoeft u niet te bepalen welke specifieke Format overload u wilt aanroepen. De taalcompilator selecteert de juiste overbelasting tussen de overbelastingen met een `provider` parameter, op basis van uw lijst met argumenten. Als de lijst met argumenten bijvoorbeeld vijf argumenten heeft, roept de compiler de methode Format(IFormatProvider, String, Object[]) aan.
Voer een aangepaste opmaakbewerking uit met een ICustomFormatter-implementatie of een IFormattable-implementatie.	Elk van de vier overbelastingen met een `provider` parameter. De compiler selecteert de juiste overbelasting tussen de overbelastingen met een `provider` parameter, op basis van de lijst met argumenten.

De Format-methode in het kort

Elke overbelasting van de methode Format maakt gebruik van de functie voor samengestelde opmaak om plaatsaanduidingen met nul-gebaseerde index, ook wel opmaakitemsgenoemd, op te nemen in een tekenreeks met samengestelde notatie. Tijdens runtime wordt elk opmaakitem vervangen door de tekenreeksweergave van het bijbehorende argument in een parameterlijst. Als de waarde van het argument nullis, wordt het opmaakitem vervangen door String.Empty. De volgende aanroep van de methode Format(String, Object, Object, Object) bevat bijvoorbeeld een notatietekenreeks met drie opmaakitems, {0}, {1}en {2}, en een lijst met argumenten met drie items.

DateTime dat = new DateTime(2012, 1, 17, 9, 30, 0); 
string city = "Chicago";
int temp = -16;
string output = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                              dat, city, temp);
Console.WriteLine(output);
// The example displays output like the following:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.

open System

let dat = DateTime(2012, 1, 17, 9, 30, 0) 
let city = "Chicago"
let temp = -16
String.Format("At {0} in {1}, the temperature was {2} degrees.", dat, city, temp)
|> printfn "%s"
// The example displays output like the following:
//    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.

Dim dat As Date = #1/17/2012 9:30AM#
Dim city As String = "Chicago"
Dim temp As Integer = -16
Dim output As String = String.Format("At {0} in {1}, the temperature was {2} degrees.",
                                   dat, city, temp)
Console.WriteLine(output)
' The example displays the following output:
'    At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.

Het opmaakitem

Een opmaakitem heeft deze syntaxis:

{index[,width][:formatString]}

Vierkante haken geven optionele elementen aan. De accolades voor openen en sluiten zijn vereist. (Zie de sectie Escapeing Braces in het artikel Samengestelde opmaak als u een letterlijke accolade wilt opnemen in de notatietekenreeks.)

Een opmaakitem voor het opmaken van een valutawaarde kan er bijvoorbeeld als volgt uitzien:

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

open System

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

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

Een opmaakitem heeft de volgende elementen:

index
De op nul gebaseerde index van het argument waarvan de tekenreeksweergave op deze positie in de tekenreeks moet worden opgenomen. Als dit argument nullis, wordt op deze positie in de tekenreeks een lege tekenreeks opgenomen.

width
Facultatief. Een ondertekend geheel getal dat de totale lengte aangeeft van het veld waarin het argument wordt ingevoegd en of het rechts is uitgelijnd (een positief geheel getal) of links uitgelijnd (een negatief geheel getal). Als u weglaat width, wordt de tekenreeksweergave van het bijbehorende argument ingevoegd in een veld zonder voorloop- of volgspaties.

Als de waarde width kleiner is dan de lengte van het argument dat moet worden ingevoegd, width wordt genegeerd en wordt de lengte van de tekenreeksweergave van het argument gebruikt als veldbreedte.

formatString
Facultatief. Een tekenreeks die de notatie van de resultaattekenreeks van het bijbehorende argument aangeeft. Als u weglaat formatString, wordt de parameterloze ToString methode van het bijbehorende argument aangeroepen om de tekenreeksweergave te produceren. Als u opgeeft formatString, moet het argument waarnaar wordt verwezen door het opmaakitem de IFormattable interface implementeren. Typen die indelingstekenreeksen ondersteunen, zijn onder andere:

Alle integrale en drijvende kommatypen. (Zie standaard numerieke opmaakreeksen en aangepaste numerieke opmaakreeksen.)
DateTime en DateTimeOffset. (Zie standaardtekenreeksen voor datum- en tijdnotatie en aangepaste tekenreeksen voor datum- en tijdnotatie.)
Alle opsommingstypen. (Zie Opsomming opmaaktekenreeksen.)
TimeSpan waarden. (Zie Standaard TimeSpan Format Strings en Aangepaste TimeSpan Format Strings.)
GUID's. (Zie de methode Guid.ToString(String).)

Een aangepast type kan echter IFormattable implementeren of de implementatie van IFormattable van een bestaand type uitbreiden.

In het volgende voorbeeld worden de argumenten width en formatString gebruikt om opgemaakte uitvoer te produceren.

// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Tuple<string, DateTime, int, DateTime, int>[] cities = 
    { Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277, 
                   new DateTime(1950, 1, 1), 1970358),
      Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995, 
                   new DateTime(1950, 1, 1), 7891957),  
      Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808, 
                   new DateTime(1950, 1, 1), 3620962),  
      Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452, 
                   new DateTime(1950, 1, 1), 1849568) };

// Display header
var header = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
                              "City", "Year", "Population", "Change (%)");
Console.WriteLine(header);
foreach (var city in cities) {
   var output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                          city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                          (city.Item5 - city.Item3)/ (double)city.Item3);
   Console.WriteLine(output);
}
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//  
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %

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

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

for name, year1, pop1, year2, pop2 in cities do
    String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                  name, year1, pop1, year2, pop2,
                  double (pop2 - pop1) / double pop1)
    |> printfn "%s"
// The example displays the following output:
//    City            Year  Population    Year  Population    Change (%)
//  
//    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
//    New York        1940   7,454,995    1950   7,891,957         5.9 %
//    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
//    Detroit         1940   1,623,452    1950   1,849,568        13.9 %

Module Example3
    Public Sub Main()
        ' Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
        Dim cities() =
          {Tuple.Create("Los Angeles", #1/1/1940#, 1504277, #1/1/1950#, 1970358),
            Tuple.Create("New York", #1/1/1940#, 7454995, #1/1/1950#, 7891957),
            Tuple.Create("Chicago", #1/1/1940#, 3396808, #1/1/1950#, 3620962),
            Tuple.Create("Detroit", #1/1/1940#, 1623452, #1/1/1950#, 1849568)}

        ' Display header
        Dim header As String = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}",
                                           "City", "Year", "Population", "Change (%)")
        Console.WriteLine(header)
        Console.WriteLine()
        For Each city In cities
            Dim output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                                city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
                                (city.Item5 - city.Item3) / city.Item3)
            Console.WriteLine(output)
        Next
    End Sub
End Module
' The example displays the following output:
'    City            Year  Population    Year  Population    Change (%)
'    
'    Los Angeles     1940   1,504,277    1950   1,970,358        31.0 %
'    New York        1940   7,454,995    1950   7,891,957         5.9 %
'    Chicago         1940   3,396,808    1950   3,620,962         6.6 %
'    Detroit         1940   1,623,452    1950   1,849,568        13.9 %

Hoe argumenten worden opgemaakt

Formaatitems worden opeenvolgend verwerkt vanaf het begin van de tekenreeks. Elk opmaakitem heeft een index die overeenkomt met een object in de lijst met argumenten van de methode. De methode Format haalt het argument op en leidt de tekenreeksweergave als volgt af:

Als nullhet argument is, voegt de methode String.Empty in de resultaattekenreeks in. U hoeft zich geen zorgen te maken over het afhandelen van een NullReferenceException bij null-argumenten.
Als u de Format(IFormatProvider, String, Object[]) overbelasting aanroept en de provider-implementatie van het IFormatProvider.GetFormat object een niet-null-ICustomFormatter-implementatie retourneert, wordt het argument doorgegeven aan de ICustomFormatter.Format(String, Object, IFormatProvider) methode. Als het opmaakitem een formatString argument bevat, wordt dit doorgegeven als het eerste argument aan de methode. Als de ICustomFormatter implementatie beschikbaar is en een niet-null-tekenreeks produceert, wordt die tekenreeks geretourneerd als de tekenreeksweergave van het argument; anders wordt de volgende stap uitgevoerd.
Als het argument de IFormattable-interface implementeert, wordt de IFormattable.ToString-implementatie aangeroepen.
De parameterloze ToString methode van het argument, die wordt overschreven of overgenomen van een basisklasse-implementatie, wordt aangeroepen.

Zie ICustomFormatter.Formatvoor een voorbeeld waarbij aanroepen naar de Format-methode worden onderschept en waarbij u kunt zien welke informatie de -methode doorgeeft aan een opmaakmethode voor elk formaatitem in een samengestelde formaatreeks.

Zie Orderverwerkingvoor meer informatie.

Items opmaken die dezelfde index hebben

De methode Format genereert een FormatException uitzondering als de index van een indexitem groter is dan of gelijk is aan het aantal argumenten in de lijst met argumenten. format kan echter meer opmaakitems bevatten dan er argumenten zijn, zolang meerdere opmaakitems dezelfde index hebben. In de aanroep van de methode Format(String, Object) in het volgende voorbeeld heeft de lijst met argumenten één argument, maar de notatietekenreeks bevat twee notatie-items: een geeft de decimale waarde van een getal weer en de andere geeft de hexadecimale waarde weer.

short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
Console.WriteLine("{0,10}  {1,10}\n", "Decimal", "Hex");
foreach (short value in values)
{
   string formatString = String.Format("{0,10:G}: {0,10:X}", value);
   Console.WriteLine(formatString);
}   
// The example displays the following output:
//       Decimal         Hex
//    
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF

open System

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

Module Example1
    Public Sub Main()
        Dim values() As Short = {Int16.MinValue, -27, 0, 1042, Int16.MaxValue}
        Console.WriteLine("{0,10}  {1,10}", "Decimal", "Hex")
        Console.WriteLine()
        For Each value As Short In values
            Dim formatString As String = String.Format("{0,10:G}: {0,10:X}", value)
            Console.WriteLine(formatString)
        Next
    End Sub
End Module
' The example displays the following output:
'       Decimal         Hex
'    
'        -32768:       8000
'           -27:       FFE5
'             0:          0
'          1042:        412
'         32767:       7FFF

Opmaak en cultuur

Over het algemeen worden objecten in de lijst met argumenten geconverteerd naar hun tekenreeksweergaven volgens de conventies van de huidige cultuur, zoals geretourneerd door de eigenschap CultureInfo.CurrentCulture. U kunt dit gedrag beheren door een van de overbelastingen van Format aan te roepen die een provider parameter bevat. De parameter provider is een IFormatProvider-implementatie die aangepaste en cultuurspecifieke opmaakinformatie levert die wordt gebruikt om het opmaakproces te beheren.

De IFormatProvider-interface heeft één lid, GetFormat, dat verantwoordelijk is voor het retourneren van het object dat opmaakinformatie biedt. .NET heeft drie IFormatProvider implementaties die cultuurspecifieke opmaak bieden:

CultureInfo. De methode GetFormat retourneert een cultuurspecifiek NumberFormatInfo object voor het opmaken van numerieke waarden en een cultuurspecifiek DateTimeFormatInfo-object voor het opmaken van datum- en tijdwaarden.
DateTimeFormatInfo, die wordt gebruikt voor cultuurspecifieke opmaak van datum- en tijdwaarden. De methode GetFormat retourneert zichzelf.
NumberFormatInfo, die wordt gebruikt voor cultuurspecifieke opmaak van numerieke waarden. De methode GetFormat(Type) retourneert zichzelf.

Aangepaste opmaakbewerkingen

U kunt ook de overbelastingen van de Format methode aanroepen die een provider parameter van het type IFormatProvider hebben om aangepaste opmaakbewerkingen uit te voeren. U kunt bijvoorbeeld een geheel getal opmaken als een identificatienummer of als een telefoonnummer. Als u aangepaste opmaak wilt uitvoeren, moet uw provider argument zowel de IFormatProvider- als ICustomFormatter-interfaces implementeren. Wanneer de methode Format wordt doorgegeven aan een ICustomFormatter-implementatie als het argument provider, roept de Format methode de IFormatProvider.GetFormat implementatie aan en vraagt een object van het type ICustomFormatteraan. Daarna roept het de ICustomFormatter-methode van het geretourneerde Format-object aan om elk opmaakitem in de meegegeven samengestelde tekenreeks op te maken.

Zie Hoe te: Aangepaste numerieke formaatproviders definiëren en gebruiken en ICustomFormattervoor meer informatie over het bieden van aangepaste opmaakoplossingen. Zie Voorbeeld: Een aangepaste opmaakbewerkingvoor een voorbeeld waarmee gehele getallen worden geconverteerd naar opgemaakte aangepaste getallen. Zie Voorbeeld: Een onderscheppingsprovider en Romeinse cijferformattervoor een voorbeeld dat ongetekende bytes naar Romeinse cijfers omzet.

Voorbeeld: Een aangepaste opmaakbewerking

In dit voorbeeld wordt een formaatprovider gedefinieerd waarmee een geheel getal wordt geformatteerd als een klantaccountnummer in het formaat x-xxxxx-xx.

using System;

public class TestFormatter
{
   public static void Main()
   {
      int acctNumber = 79203159;
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:G}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:S}", acctNumber));
      Console.WriteLine(String.Format(new CustomerFormatter(), "{0:P}", acctNumber));
      try {
         Console.WriteLine(String.Format(new CustomerFormatter(), "{0:X}", acctNumber));
      }
      catch (FormatException e) {
         Console.WriteLine(e.Message);
      }
   }
}

public class CustomerFormatter : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType) 
   {
      if (formatType == typeof(ICustomFormatter))        
         return this; 
      else
         return null;
   }
   
   public string Format(string format, 
                         object arg, 
                         IFormatProvider formatProvider) 
   {                       
      if (! this.Equals(formatProvider))
      {
         return null;
      }
      else
      {
         if (String.IsNullOrEmpty(format)) 
            format = "G";
         
         string customerString = arg.ToString();
         if (customerString.Length < 8)
            customerString = customerString.PadLeft(8, '0');
         
         format = format.ToUpper();
         switch (format)
         {
            case "G":
               return customerString.Substring(0, 1) + "-" +
                                     customerString.Substring(1, 5) + "-" +
                                     customerString.Substring(6);
            case "S":                          
               return customerString.Substring(0, 1) + "/" +
                                     customerString.Substring(1, 5) + "/" +
                                     customerString.Substring(6);
            case "P":                          
               return customerString.Substring(0, 1) + "." +
                                     customerString.Substring(1, 5) + "." +
                                     customerString.Substring(6);
            default:
               throw new FormatException( 
                         String.Format("The '{0}' format specifier is not supported.", format));
         }
      }   
   }
}
// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.

open System

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

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

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

// The example displays the following output:
//       7-92031-59
//       7-92031-59
//       7/92031/59
//       7.92031.59
//       The 'X' format specifier is not supported.

Module TestFormatter
   Public Sub Main()
      Dim acctNumber As Integer = 79203159
      Console.WriteLine(String.Format(New CustomerFormatter, "{0}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:G}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:S}", acctNumber))
      Console.WriteLine(String.Format(New CustomerFormatter, "{0:P}", acctNumber))
      Try
         Console.WriteLine(String.Format(New CustomerFormatter, "{0:X}", acctNumber))
      Catch e As FormatException
         Console.WriteLine(e.Message)
      End Try   
   End Sub
End Module

Public Class CustomerFormatter : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(type As Type) As Object  _
                   Implements IFormatProvider.GetFormat
      If type Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, _
                           arg As Object, _
                           formatProvider As IFormatProvider) As String _
                    Implements ICustomFormatter.Format
      If Not Me.Equals(formatProvider) Then
         Return Nothing
      Else
         If String.IsNullOrEmpty(fmt) Then fmt = "G"
         
         Dim customerString As String = arg.ToString()
         if customerString.Length < 8 Then _
            customerString = customerString.PadLeft(8, "0"c)
         
         Select Case fmt
            Case "G"
               Return customerString.Substring(0, 1) & "-" & _
                                     customerString.Substring(1, 5) & "-" & _
                                     customerString.Substring(6)
            Case "S"                         
               Return customerString.Substring(0, 1) & "/" & _
                                     customerString.Substring(1, 5) & "/" & _
                                     customerString.Substring(6)
            Case "P"
               Return customerString.Substring(0, 1) & "." & _
                                     customerString.Substring(1, 5) & "." & _
                                     customerString.Substring(6)
            Case Else
               Throw New FormatException( _
                         String.Format("The '{0}' format specifier is not supported.", fmt))
         End Select                                                     
      End If   
   End Function
End Class
' The example displays the following output:
'       7-92031-59
'       7-92031-59
'       7/92031/59
'       7.92031.59
'       The 'X' format specifier is not supported.

Voorbeeld: Een onderscheppingsprovider en Romeinse cijferformatter

In dit voorbeeld wordt een aangepaste formaatleverancier gedefinieerd die de ICustomFormatter- en IFormatProvider-interfaces implementeert om twee dingen te doen:

Hiermee worden de parameters weergegeven die zijn doorgegeven aan de ICustomFormatter.Format-implementatie. Hierdoor kunnen we zien welke parameters de Format(IFormatProvider, String, Object[])-methode doorgeeft aan de aangepaste opmaakimplementatie voor elk object dat hij probeert op te maken. Dit kan handig zijn wanneer u fouten in uw toepassing opspoort.
Als het object dat moet worden opgemaakt een niet-ondertekende bytewaarde is die moet worden opgemaakt met behulp van de standaardnotatietekenreeks R, wordt de numerieke waarde opgemaakt als een Romeins getal.

using System;
using System.Globalization;

public class InterceptProvider : IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }
   
   public string Format(String format, Object obj, IFormatProvider provider) 
   {
      // Display information about method call.
      string formatString = format ?? "<null>";
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider.GetType().Name, obj ?? "<null>", formatString);
                        
      if (obj == null) return String.Empty;
            
      // If this is a byte and the "R" format string, format it with Roman numerals.
      if (obj is Byte && formatString.ToUpper().Equals("R")) {
         Byte value = (Byte) obj;
         int remainder;
         int result;
         String returnString = String.Empty;

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

         return returnString; 
      }   

      // Use default for all other formatting.
      if (obj is IFormattable)
         return ((IFormattable) obj).ToString(format, CultureInfo.CurrentCulture);
      else
         return obj.ToString();
   }
}

public class Example
{
   public static void Main()
   {
      int n = 10;
      double value = 16.935;
      DateTime day = DateTime.Now;
      InterceptProvider provider = new InterceptProvider();
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
      Console.WriteLine(String.Format(provider, "{0}: {1:F}\n", "Today: ", 
                                      (DayOfWeek) DateTime.Now.DayOfWeek));
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 
                                      (Byte) 2, (Byte) 12, (Byte) 199));
   }
}
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX

open System
open System.Globalization

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

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

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

let n = 10
let value = 16.935
let day = DateTime.Now
let provider = InterceptProvider()
String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day)
|> printfn "%s"
String.Format(provider, "{0}: {1:F}\n", "Today: ", DateTime.Now.DayOfWeek)
|> printfn "%s"
String.Format(provider, "{0:X}, {1}, {2}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
// The example displays the following output:
//    Provider: InterceptProvider, Object: 10, Format String: N0
//    Provider: InterceptProvider, Object: 16.935, Format String: C2
//    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
//    10: $16.94 on 1/31/2013
//    
//    Provider: InterceptProvider, Object: Today: , Format String: <null>
//    Provider: InterceptProvider, Object: Thursday, Format String: F
//    Today: : Thursday
//    
//    Provider: InterceptProvider, Object: 2, Format String: X
//    Provider: InterceptProvider, Object: 12, Format String: <null>
//    Provider: InterceptProvider, Object: 199, Format String: <null>
//    2, 12, 199
//    
//    Provider: InterceptProvider, Object: 2, Format String: R
//    Provider: InterceptProvider, Object: 12, Format String: R
//    Provider: InterceptProvider, Object: 199, Format String: R
//    II, XII, CXCIX

Imports System.Globalization

Public Class InterceptProvider : Implements IFormatProvider, ICustomFormatter
   Public Function GetFormat(formatType As Type) As Object _
         Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, obj As Object, provider As IFormatProvider) As String _
         Implements ICustomFormatter.Format

      Dim formatString As String = If(fmt IsNot Nothing, fmt, "<null>")
      Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
                        provider, If(obj IsNot Nothing, obj, "<null>"), formatString)

      If obj Is Nothing Then Return String.Empty
            
      ' If this is a byte and the "R" format string, format it with Roman numerals.
      If TypeOf(obj) Is Byte AndAlso formatString.ToUpper.Equals("R") Then
         Dim value As Byte = CByte(obj)
         Dim remainder As Integer
         Dim result As Integer
         Dim returnString As String = String.Empty

         ' Get the hundreds digit(s)
         result = Math.DivRem(value, 100, remainder)
         If result > 0 Then returnString = New String("C"c, result)
         value = CByte(remainder)
         ' Get the 50s digit
         result = Math.DivRem(value, 50, remainder)
         If result = 1 Then returnString += "L"
         value = CByte(remainder)
         ' Get the tens digit.
         result = Math.DivRem(value, 10, remainder)
         If result > 0 Then returnString += New String("X"c, result)
         value = CByte(remainder) 
         ' Get the fives digit.
         result = Math.DivRem(value, 5, remainder)
         If result > 0 Then returnString += "V"
         value = CByte(remainder)
         ' Add the ones digit.
         If remainder > 0 Then returnString += New String("I"c, remainder)
         
         ' Check whether we have too many X characters.
         Dim pos As Integer = returnString.IndexOf("XXXX")
         If pos >= 0 Then
            Dim xPos As Integer = returnString.IndexOf("L") 
            If xPos >= 0 And xPos = pos - 1 Then
               returnString = returnString.Replace("LXXXX", "XC")
            Else
               returnString = returnString.Replace("XXXX", "XL")   
            End If         
         End If
         ' Check whether we have too many I characters
         pos = returnString.IndexOf("IIII")
         If pos >= 0 Then
            If returnString.IndexOf("V") >= 0 Then
               returnString = returnString.Replace("VIIII", "IX")
            Else
               returnString = returnString.Replace("IIII", "IV")    
            End If
         End If
         Return returnString 
      End If   

      ' Use default for all other formatting.
      If obj Is GetType(IFormattable)
         Return CType(obj, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
      Else
         Return obj.ToString()
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim n As Integer = 10
      Dim value As Double = 16.935
      Dim day As DateTime = Date.Now
      Dim provider As New InterceptProvider()
      Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}", n, value, day))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0}: {1:F}", "Today", 
                                      CType(Date.Now.DayOfWeek, DayOfWeek)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n", 
                                      CByte(2), CByte(12), CByte(199)))
      Console.WriteLine()
      Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}", 
                                      CByte(2), CByte(12), CByte(199)))
   End Sub
End Module
' The example displays the following output:
'    Provider: InterceptProvider, Object: 10, Format String: N0
'    Provider: InterceptProvider, Object: 16.935, Format String: C2
'    Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
'    10: $16.94 on 1/31/2013
'    
'    Provider: InterceptProvider, Object: Today: , Format String: <null>
'    Provider: InterceptProvider, Object: Thursday, Format String: F
'    Today: : Thursday
'    
'    Provider: InterceptProvider, Object: 2, Format String: X
'    Provider: InterceptProvider, Object: 12, Format String: <null>
'    Provider: InterceptProvider, Object: 199, Format String: <null>
'    2, 12, 199
'    
'    Provider: InterceptProvider, Object: 2, Format String: R
'    Provider: InterceptProvider, Object: 12, Format String: R
'    Provider: InterceptProvider, Object: 199, Format String: R
'    II, XII, CXCIX

Veelgestelde vragen

Waarom raadt u tekenreeksinterpolatie aan voor aanroepen naar de methode `String.Format`?

Tekenreeksinterpolatie is:

Flexibeler. Het kan in elke tekenreeks worden gebruikt zonder dat een aanroep naar een methode nodig is die samengestelde opmaak ondersteunt. Anders moet u de methode Format of een andere methode aanroepen die samengestelde opmaak ondersteunt, zoals Console.WriteLine of StringBuilder.AppendFormat.
Beter leesbaar. Omdat de expressie die moet worden ingevoegd in een tekenreeks wordt weergegeven in de geïnterpoleerde expressie in plaats van in een lijst met argumenten, zijn geïnterpoleerde tekenreeksen gemakkelijker te codeeren en te lezen. Geïnterpoleerde tekenreeksen kunnen ook worden gebruikt in tekenreekssamenvoegingsbewerkingen om beknoptere, duidelijkere code te produceren.

Een vergelijking van de volgende twee codevoorbeelden illustreert de superioriteit van geïnterpoleerde tekenreeksen ten opzichte van tekenreekssamenvoeging en aanroepen naar samengestelde opmaakmethoden. Het gebruik van meerdere tekenreekssamenvoegingsbewerkingen in het volgende voorbeeld produceert uitgebreide en moeilijk te lezen code.

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

output += "\n";
var date = DateTime.Now;
output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.",
                        date, date.DayOfWeek);
Console.WriteLine(output);
// The example displays the following output:
//     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
//     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

open System

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

let date = DateTime.Now
output + String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", date, date.DayOfWeek)
|> printfn "%s"
// The example displays the following output:
//     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
//     It is 10:29 AM on 1/8/2018. The day of the week is Monday.


Module Example12
    Public Sub Main()
        Dim names = {"Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma"}
        Dim output = names(0) + ", " + names(1) + ", " + names(2) + ", " +
                   names(3) + ", " + names(4) + ", " + names(5) + ", " +
                   names(6)

        output += vbCrLf
        Dim dat = DateTime.Now
        output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.",
                              dat, dat.DayOfWeek)
        Console.WriteLine(output)
    End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Het gebruik van geïnterpoleerde tekenreeksen in het volgende voorbeeld produceert daarentegen veel duidelijkere, beknoptere code dan de instructie tekenreekssamenvoeging en de aanroep van de methode Format in het vorige voorbeeld.

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

var date = DateTime.Now;
output += $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}.";
Console.WriteLine(output);
// The example displays the following output:
//     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
//     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

open System

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

let date = DateTime.Now
output + $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}."
|> printfn "%s" 
// The example displays the following output:
//     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
//     It is 10:29 AM on 1/8/2018. The day of the week is Monday.


Module Example13
    Public Sub Main()
        Dim names = {"Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma"}
        Dim output = $"{names(0)}, {names(1)}, {names(2)}, {names(3)}, {names(4)}, " +
                   $"{names(5)}, {names(6)}"

        Dim dat = DateTime.Now
        output += $"{vbCrLf}It is {dat:t} on {dat:d}. The day of the week is {dat.DayOfWeek}."
        Console.WriteLine(output)
    End Sub
End Module
' The example displays the following output:
'     Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
'     It is 10:29 AM on 1/8/2018. The day of the week is Monday.

Waar vind ik de vooraf gedefinieerde notatietekenreeksen?

Zie Standaardtekenreeksen voor numerieke notatie en Aangepaste tekenreeksen voor numerieke notatievoor alle integrale en zwevende kommatypen.
Zie voor datum- en tijdwaarden de standaardsjablonen voor datum- en tijdnotaties en de aangepaste sjablonen voor datum- en tijdnotaties .
Zie Opsomming opmaaktekenreeksenvoor opsommingswaarden.
Zie TimeSpan en Custom TimeSpan Format Stringsvoor waarden.
Zie de sectie Opmerkingen van de Guid referentiepagina voor Guid.ToString(String) waarden.

Hoe beheer ik de uitlijning van de resultaattekenreeksen die opmaakitems vervangen?

De algemene syntaxis van een opmaakitem is:

{index[,width][: formatString]}

width is een ondertekend geheel getal dat de veldbreedte definieert. Als deze waarde negatief is, wordt tekst in het veld links uitgelijnd. Als het positief is, wordt tekst rechts uitgelijnd.

Hoe bepaal ik het aantal cijfers achter het decimaalteken?

Alle standaardtekenreeksen voor numerieke notatie behalve 'D' (die alleen wordt gebruikt met gehele getallen), 'G', 'R' en 'X' staan een precisieaanduiding toe waarmee het aantal decimale cijfers in de resultaattekenreeks wordt gedefinieerd. In het volgende voorbeeld worden standaardtekenreeksen voor numerieke notatie gebruikt om het aantal decimale cijfers in de resultaattekenreeks te bepalen.

object[] values = { 1603, 1794.68235, 15436.14 };
string result;
foreach (var value in values)
{
    result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}\n",
                           Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
    Console.WriteLine(result);
}
// The example displays output like the following:
//       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
//    
//       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
//    
//      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

open System

let values: obj list = [ 1603, 1794.68235, 15436.14 ]
for value in values do
   String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}\n", Convert.ToDouble(value), Convert.ToDouble(value) / 10000.)
   |> printfn "%s"
// The example displays output like the following:
//       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
//    
//       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
//    
//      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

Module Example7
    Public Sub Main()
        Dim values() As Object = {1603, 1794.68235, 15436.14}
        Dim result As String
        For Each value In values
            result = String.Format("{0,12:C2}   {0,12:E3}   {0,12:F4}   {0,12:N3}  {1,12:P2}",
                                value, CDbl(value) / 10000)
            Console.WriteLine(result)
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       $1,603.00     1.603E+003      1603.0000      1,603.000       16.03 %
'    
'       $1,794.68     1.795E+003      1794.6824      1,794.682       17.95 %
'    
'      $15,436.14     1.544E+004     15436.1400     15,436.140      154.36 %

Als u een aangepaste tekenreeks voor numerieke notatie gebruikt, gebruikt u de notatieaanduiding '0' om het aantal decimale cijfers in de resultaattekenreeks te bepalen, zoals in het volgende voorbeeld wordt weergegeven.

decimal value = 16309.5436m;
string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
                              value);
Console.WriteLine(result);
// The example displays the following output:
//        16309.54360    16,309.54    16309.544

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

Module Example8
    Public Sub Main()
        Dim value As Decimal = 16309.5436D
        Dim result As String = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
                                           value)
        Console.WriteLine(result)
    End Sub
End Module
' The example displays the following output:
'    16309.54360    16,309.54    16309.544

Hoe beheer ik het aantal integrale cijfers?

Standaard worden bij opmaakbewerkingen alleen niet-nul integrale cijfers weergegeven. Als u gehele getallen opmaakt, kunt u een precisieaanduiding gebruiken met de standaardtekenreeksen D en X om het aantal cijfers te bepalen.

int value = 1326;
string result = String.Format("{0,10:D6} {0,10:X8}", value);
Console.WriteLine(result);
// The example displays the following output:
//     001326   0000052E

open System

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

Module Example10
    Public Sub Main()
        Dim value As Integer = 1326
        Dim result As String = String.Format("{0,10:D6} {0,10:X8}", value)
        Console.WriteLine(result)
    End Sub
End Module
' The example displays the following output:
'       001326   0000052E

U kunt een geheel getal of een kommagetal opvullen met voorloopnullen om een resultaatreeks met een opgegeven aantal integrale cijfers te krijgen met behulp van de aangepaste numerieke notatie , zoals het volgende voorbeeld laat zien.

int value = 16342;
string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}",
                              value);
Console.WriteLine(result);
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0

open System

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

Module Example9
    Public Sub Main()
        Dim value As Integer = 16342
        Dim result As String = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}",
                                           value)
        Console.WriteLine(result)
    End Sub
End Module
' The example displays the following output:
'           00016342       00016342.000    0,000,016,342.0

Hoeveel items kan ik opnemen in de lijst met formaten?

Er is geen praktische limiet. De tweede parameter van de methode Format(IFormatProvider, String, Object[]) is gelabeld met het kenmerk ParamArrayAttribute, waarmee u een lijst met scheidingstekens of een objectmatrix kunt opnemen als de notatielijst.

Hoe neem ik letterlijke accolades ({' en '}' op in de resultaattekenreeks?

Hoe voorkomt u bijvoorbeeld dat de volgende methode-aanroep een FormatException uitzondering genereert?

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

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

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

Eén accolade voor openen of sluiten wordt altijd geïnterpreteerd als het begin of einde van een opmaakitem. Om letterlijk te worden geïnterpreteerd, moet het worden geëscaped. U kunt aan een accolade ontsnappen door een andere accolade toe te voegen ("{{" en "}}" in plaats van "{" en "}"), zoals in de volgende methode-aanroep:

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

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

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

Zelfs escape-accolades zijn echter eenvoudig verkeerd geïnterpreteerd. We raden u aan accolades op te nemen in de opmaaklijst en opmaakitems te gebruiken om ze in de resultaatstring in te voegen, zoals het volgende voorbeeld laat zien.

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

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

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

Waarom genereert mijn aanroep naar de methode String.Format een FormatException?

De meest voorkomende oorzaak van de uitzondering is dat de index van een opmaakitem niet overeenkomt met een object in de lijst met opmaak. Dit geeft meestal aan dat u de indexen van opmaakitems verkeerd hebt genummerd of dat u bent vergeten een object op te nemen in de lijst met opmaak. Als u een niet-gesescapeerde accolade probeert op te nemen, resulteert dat ook in een FormatException-fout. Af en toe is de uitzondering het resultaat van een typefout; Een typische fout is bijvoorbeeld om '[' (het linkerhaakje) verkeerd te typen in plaats van '{' (de linkeraccolade).

Als de methode Format(System.IFormatProvider,System.String,System.Object[]) parametermatrices ondersteunt, waarom genereert mijn code een uitzondering wanneer ik een matrix gebruik?

Met de volgende code wordt bijvoorbeeld een FormatException uitzondering gegenereerd:

Random rnd = new Random();
int[] numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++)
{
    int number = rnd.Next(1001);
    numbers[ctr] = number;
    total += number;
}
numbers[3] = total;
Console.WriteLine($"{numbers} + {1} + {2} = {3}");

open System

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

Imports System.Collections.Generic

Module Example5
    Public Sub Main()
        Dim rnd As New Random()
        Dim numbers(3) As Integer
        Dim total As Integer = 0
        For ctr = 0 To 2
            Dim number As Integer = rnd.Next(1001)
            numbers(ctr) = number
            total += number
        Next
        numbers(3) = total
        Console.WriteLine("{0} + {1} + {2} = {3}", numbers)
    End Sub
End Module

Dit is een probleem met overbelastingsoplossing voor compilers. Omdat de compiler een matrix met gehele getallen niet kan converteren naar een objectmatrix, wordt de matrix met gehele getallen als één argument behandeld, dus wordt de methode Format(String, Object) aangeroepen. De uitzondering wordt geworpen omdat er vier opmaakitems zijn, maar slechts één item in de opmaaklijst.

Omdat Visual Basic en C# geen geheel getalmatrix kunnen converteren naar een objectmatrix, moet u de conversie zelf uitvoeren voordat u de methode Format(String, Object[]) aanroept. In het volgende voorbeeld ziet u één implementatie.

Random rnd = new Random();
int[] numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++)
{
    int number = rnd.Next(1001);
    numbers[ctr] = number;
    total += number;
}
numbers[3] = total;
object[] values = new object[numbers.Length];
numbers.CopyTo(values, 0);
Console.WriteLine($"{values} + {1} + {2} = {3}");

open System

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

Imports System.Collections.Generic

Module Example6
    Public Sub Main()
        Dim rnd As New Random()
        Dim numbers(3) As Integer
        Dim total As Integer = 0
        For ctr = 0 To 2
            Dim number As Integer = rnd.Next(1001)
            numbers(ctr) = number
            total += number
        Next
        numbers(3) = total
        Dim values(numbers.Length - 1) As Object
        numbers.CopyTo(values, 0)
        Console.WriteLine("{0} + {1} + {2} = {3}", values)
    End Sub
End Module

Delen via