Na het artikel over de concatenatie, hebben we gezien dat het heel belangrijk is om de StringBuilder te gebruiken voor prestatie redenen. Hier zullen we zien hoe we een tekenreeks, een zin, kunnen formatteren; deze formattering wordt vaak gebruikt.

Waarom de String Format?

Ik ga je niet vertellen dat het beter presteert, integendeel, string.Format() kost enkele milliseconden meer volgens een eenvoudige test in vergelijking met een samengevoegde zin:

string naam = "Dupont";
string voornaam = "Julie";
string adres = "Rue de l'étoile";
string nummer = "10";
string postcode = "75000";
string stad = "Parijs";

//Ik gebruik Stopwatch om mijn code te timen
Stopwatch s = new Stopwatch();
//Ik start Stopwatch
s.Restart();
for(int i=0; i < 100000; i++)
{
string mijnBericht = string.Format("Hallo {0} {1}, ik schrijf je om je te vragen mijn pakket naar {2}, {3} - {4} {5} te sturen",
                                   naam, voornaam, adres, nummer, postcode, stad);
}
//Ik stop Stopwatch
s.Stop();
//Ik toon het resultaat
Console.WriteLine(String.Format("Tijd: {0}", s.Elapsed));
s.Restart();
for(int i=0; i < 100000; i++)
{
string mijnBericht = "Hallo " + naam + " " + voornaam + ", ik schrijf je om je te vragen mijn pakket naar " +
                     adres + ", " + nummer + " - " + postcode + " " + stad;
}
s.Stop();
Console.WriteLine(String.Format("Tijd: {0}", s.Elapsed));

//Resultaat:
//string.format -> Tijd: 00:00:00.0378547
//concatenatie -> Tijd: 00:00:00.0134245

Het tweede deel van de code is minder leesbaar dan het eerste deel van de code, heb je opgemerkt dat we string.Format() gebruiken in plaats van de variabelen (met +) te concatenateren?

De string.Format() is een goede gewoonte om aan te nemen, het is veel leesbaarder, maar je zult verderop zien dat we het uitvoerformaat van de tekenreeks kunnen beheren.

Zoals we kunnen zien, hoeft men alleen maar tussen accolades (of haken) {x} de index van de waarde die zal worden vervangen te plaatsen, let op dit:

int i = 0;
int x = 100;
string.Format("Mijn Waarde is {0}, maar x is gelijk aan {1}", i, x);

//Resultaat:
//Mijn Waarde is 0, maar x is gelijk aan 100

//Is niet hetzelfde als dit:

string.Format("Mijn Waarde is {1}, maar x is gelijk aan {0}", i, x);
//Resultaat:
//Mijn Waarde is 100, maar x is gelijk aan 0

In het bovenstaande voorbeeld, op de tweede regel, is de eerste index {1}, deze zal dus i niet nemen, omdat i op positie nul staat (ja, in de informatica beginnen we altijd bij nul en niet bij 1), de positie op {1} is x, terwijl de index {0} de waarde van positie nul is, dus i.

Heb je het begrepen?

Ik vat samen, je moet dit soort concatenaties vermijden:

string naam = "Dupont";
string voornaam = "Julie";
string adres = "Rue de l'étoile";
string nummer = "10";
string postcode = "75000";
string stad = "Parijs";
string mijnBericht = "Hallo " + naam + " " + voornaam + ", ik schrijf je om je te vragen mijn pakket naar " +
                                      adres + ", " + nummer + " - " + postcode + " " + stad;
Console.WriteLine(mijnBericht);

//Resultaat:
//Hallo Dupont Julie, ik schrijf je om je te vragen mijn pakket naar Rue de l'étoile, 10 - 75000 Parijs

Maar liever:

string naam = "Dupont";
string voornaam = "Julie";
string adres = "Rue de l'étoile";
string nummer = "10";
string postcode = "75000";
string stad = "Parijs";
string mijnBericht = string.Format("Hallo {0} {1}, ik schrijf je om je te vragen mijn pakket naar {2}, {3} - {4} {5}",
                                    naam, voornaam, adres, nummer, postcode, stad);
Console.WriteLine(mijnBericht);

//Resultaat:
//Hallo Dupont Julie, ik schrijf je om je te vragen mijn pakket naar Rue de l'étoile, 10 - 75000 Parijs

Een ander voordeel

Daar begint het interessanter te worden, dankzij string.Format() kunnen we een waarde direct formatteren, zoals dit:

int salaris = 1000;
int werkuren = 16;
string mijnBericht = string.Format("Mijn baas betaalt me {0:0.00}€ per maand voor {1:0#} uur werk per dag.", salaris, werkuren);
Console.WriteLine(mijnBericht);
//Mijn baas betaalt me 1000,00€ per maand voor 16 uur werk per dag.

werkuren = 1;
mijnBericht = string.Format("Mijn baas betaalt me {0:0####.00}€ per maand voor {1:0#} uur werk per dag.", salaris, werkuren);
Console.WriteLine(mijnBericht);
//Mijn baas betaalt me 01000,00€ per maand voor 01 uur werk per dag.

mijnBericht = string.Format("Het is {0}", DateTime.Now);
Console.WriteLine(mijnBericht);
//Het is 23-04-19 16:53:54

mijnBericht = string.Format("Het is {0:dd-MM-yyyy}", DateTime.Now);
Console.WriteLine(mijnBericht);
//Het is 23-04-2019

Zoals we kunnen zien, kunnen we de waarde direct formatteren zoals we willen, wat langer zou duren bij concatenatie.

Een ander voordeel is wanneer je een zin uit een database of uit een resourcebestand haalt, maar deze zin moet elke keer verschillende waarden bevatten, dan hoef je het alleen maar zo te formatteren:

//Hier halen we een zin uit een resourcebestand of zelfs een database
//maakt niet uit waar de zin vandaan komt, het is gewoon een voorbeeld
string.Format(resource.GetString("MijnZinInMijnResourcebestand"), adres, postcode, stad);

//MijnZinInMijnResourcebestand = "Ik woon in {0}, postcode {1}, stad {2}"

Korte variant

Er is een nog kortere versie van string.Format() in C# 6 (Roslyn) vanaf Visual Studio 2015 (je moet het Microsoft.Net.Compilers-pakket toevoegen om de nieuwe C#-functionaliteiten te gebruiken):

string mijnBericht = string.Format("Vandaag is het {0:dd-MM-yyyy}", DateTime.Now);
Console.WriteLine(mijnBericht);
//Resultaat: Vandaag is het 23-04-2019

mijnBericht = $"Vandaag is het {DateTime.Now:dd-MM-yyyy}";
Console.WriteLine(mijnBericht);
//Resultaat: Vandaag is het 23-04-2019

De 2e regel presenteert een string.Format() die iets anders is, we beginnen met het $-teken en vervolgens wordt de index die nul was in de eerste regel direct vervangen en tussen de accolades geplaatst.

Formatteringsspecificatie	Beschrijving	Voorbeelden	Resultaat
C of c	Valuta	string s = $"{2.5:C}"; string s = $"{-2.5:C}";	$2.50 ($2.50)
D of d	Decimaal	string s = $"{25:D5}";	00025
E of e	Exponentieel	string s = $"{250000:E2}";	2.50E+005
F of f	Vastekomma	string s = $"{2.5:F2}"; string s = $"{2.5:F0}";	2.50 3
G of g	Algemeen	string s = $"{2.5:G}";	2.5
N of n	Numeriek	string s = $"{2500000:N}";	2.500.000,00
P of p	Percentage	string s = $"{0.25:P}";	25,00%
R of r	Heen en terug	string s = $"{2.5:R}";	2.5
X of x	Hexadecimaal	string s = $"{250:X}"; string s = $"{0xffff:X}";	FA FFFF

En nog veel meer!

Voor meer informatie over string.Format() is hier de documentatie op de Microsoft-website: https://docs.microsoft.com/fr-FR/dotnet/api/system.string.format?redirectedfrom=MSDN&view=netframework-4.8#System_String_Format_System_String_System_Object_

Bij de compilatie verandert er niets, het dollarteken wordt omgezet door een string.Format(), het is gewoon een kwestie van wennen, maar ik vind het nog leesbaarder!