Strings

Een string is een stuk tekst. Deze bestaat meestal uit 2 of meer karakters, als je slechts één karakter wilt gebruiken overweeg je beter om char te gebruiken. Strings kunnen evengoed ook leeg of zelfs null zijn, aangezien strings een reference type zijn. Een string kan op dezelfde manier gedefinieerd worden zoals andere data types waar we reeds mee gewerkt hebben:

string s;

Of als je onmiddelijk een waarde wilt toekennen aan de string:

string name = "John Doe";

Alles dat omgeven wordt met een set dubbele aanhalingstekens wordt in C# aanzien als een string. Zoals je in bovenstaand voorbeeld kan zien - Een of meerdere karakters omgeven door dubbele aanhalingstekens maken de compiler duidelijk dat hij dit moet interpreteren als een string en niet als keywords of commando's.

Strings zijn onveranderlijk

In C# zijn strings onveranderlijk. Als ze eenmaal gemaakt zijn, kunnen ze niet veranderd worden. Dat is niet echt praktisch in dagelijks gebruik, maar het framework helpt ons hierbij. In plaats van telkens nieuwe strings te moeten declareren om wijzigingen aan te brengen, maakt het framework elke keer een nieuwe string als je de bestaande string wijzigt. Dit is een naadloos proces, maar het kan je code minder efficiënt maken zonder dat je er zelf op let. Hier een voorbeeld om dit aan te tonen:

string numbers = "";
for (int i = 0; i < 10000; i++)
    numbers += i.ToString();

In dit geval lopen we 10000 keer door onze lus, en elke keer voegen we de huidige index toe aan onze string. In plaats van de huidige string aan te passen en het laatste getal toe te voegen, wordt er dus een nieuwe string aangemaakt en toegekend aan de oude variabele. De oude variabele wordt dan opgeruimd door het framework, en dit 10000 keer! Als je weet dat je een string in meerdere operaties zal opbouwen is het beter om een zogenoemde StringBuilder te gebruiken:

StringBuilder numbers = new StringBuilder();
for (int i = 0; i < 10000; i++)
    numbers.Append(i);
Console.WriteLine(numbers.ToString());

Basis stringoperaties

Ondanks het feit dat string onveranderlijk zijn, zal je toch vaak strings manipuleren en bewerken. Dat zal (zolang je niet in gigantische lus gaat werken) ook geen problemen geven! Hier zijn een aantal zaken die je kan doen met een string:

Je kan twee of meerdere strings samenvoegen door de + operator te gebruiken:

string name = "John" + " " + "Doe";

Je kan hetzelfde doen met variabelen, waar je tekst tussen dubbele aanhalingstekens mengt met andere variabelen (die kunnen ook een string zijn, of een andere variabele die je omzet naar een string met de ToString() methode). Er is echter een betere manier om dit te doen, namelijk met de Format methode die terugvinden in de String klasse:

string name = "John Doe";
int age = 42;
string userString = String.Format("{0} is {1} years old and lives in {2}", name, age, "New York");

Merk op hoe ik genummerde plaatsvervangers ({0}, {1}, {2}, …) gebruik en dan de waarden als parameters meegeef aan de methode. Het is hierbij wel belangrijk om te onthouden dat de index en het aantal plaatsvervangers moet overeenstemmen met de parameters die je meegeeft.

De Length property laat je toe om de huidige lengte van een string te controleren. De Length propery is vaak handig in combinatie met andere properties en methode, zoals de Substring() en de IndexOf() methoden. De Substring methode gebruik je om een stukje uit een string te halen, met de IndexOf methode kan je de index (plaats) van een opgegeven char/string binnen de oorspronkelijke string weergeven. Even een voorbeeld:

string name = "John Doe";
int indexOfSpace = name.IndexOf(' ') + 1;
string lastName = name.Substring(indexOfSpace, name.Length - indexOfSpace);
Console.WriteLine(lastName);

Kort uitgelegd: we definiëren een naam, dan gebruiken we de IndexOf() methode om de positie te vinden van de eerste spatie in onze string en tellen daar 1 bij op. Dan gebruiken we de Substring() methode om alles na de spatie te selecteren.

Een andere handig helpmethode van de String klasse is de Replace() methode. Dit laat je toe om een string te nemen en er dan een zoek/vervang operatie op uit te voeren, zoals je hier ziet:

string name = "John Doe";
Console.WriteLine(name.Replace("John", "Jane"));

De Replace() methode is geen stricte methode, als de string die je zoekt (de eerste parameter) niet gevonden wordt, dan gebeurt er niets (en wordt er ook geen foutmelding gegeven). Als de string aanwezig is, dan wordt hij vervangen door de tweede parameter. Je kan dit indien gewenst altijd eerst controleren met de Contains() methode:

string name = "John Doe";
if (name.Contains("John"))
    Console.WriteLine(name.Replace("John", "Jane"));
else
    Console.WriteLine("John was not found!");

Soms wil je weten of een string begint of eindigt met een specifieke char of string. Daarvoor kan je de StartsWith() en EndsWith() methoden gebruiken:

string name = "John Doe";
if ((name.StartsWith("John")) && (name.EndsWith("Doe")))
    Console.WriteLine("Hello, Mr. Doe!");

Er zijn nog meer String methoden en verschillende manieren om ze te gebruiken dan wat we nu gezien hebben in deze voorbeelden. Als je hier meer over wilt weten kan de MSDN documentation for the String class bekijken.

Verbatim Strings en Escaping

Als je een string definieert zal je vlug merken dat bepaalde karakters een speciaal doel hebben. Het meeste duidelijke voorbeeld hiervan zijn de dubbel quotes zelf. Aangezien je deze gebruikt om het begin en einde van een string aan te geven, hoe kan je deze dan zelf gebruiken in je string? Het meest simpele antwoord hiervoor is escaping, waarmee je aan de compiler doorgeeft dat een speciaal karakter letterlijk met verwerkt worden, en niet met z'n gebruikelijke functie:

Console.WriteLine("What do you mean by \"Hello, world\" ??");

Als je dit uitvoert krijg je het volgende resultaat:

What do you mean by "Hello, world" ??

Met andere woorden, we gebruiken backslashes vóór een dubbel aanhalingsteken (") om aan te geven dat dit NIET het einde is van de string, maar dat we gewoon een dubbel aanhalingsteken willen gebruiken. Maar...wat als we nu echt een backslash willen gebruiken en niet als escape karakter?? Nou dan.... kun je dat escapen door er een backslash voor te zetten:

Console.WriteLine("Right here \\ Right now");

Heeft als resultaat:

Right here \ Right now

De reden is dat de backslash niet alleen maar gebruikt wordt voor het 'escapen'' van dubbele aanhalingstekens. Hij wordt ook gebruikt als prefix bij een hele reeks 'characters' om die een speciale betekenis te geven. Bijvoorbeeld, \n betekent een nieuwe regel, \t is een tab enzovoorts. Je kunt een hele lijst escape sequenties vinden hier.

Verbatim (letterlijke) strings

Als alternatief voor al dit escapen kun je een verbatim string gebruiken. Dat lijkt op een reguliere string declaratie, maar wordt voorafgegaan door het @ character, en alle characters daarbinnen worden letterlijk weergegeven:

Console.WriteLine(@"In a verbatim string \ everything is literal: \n & \t");

De output lijkt precies op de input:

In a verbatim string \ everything is literal: \n & \t

Er is slechts een uitzondering op deze regel: Een dubbel aanhalingsteken moet nog steeds 'ge-escaped' worden, maar dat lijkt nogal logisch, want hoe moet de compiler anders weten dat je een string probeert te beëindigen of juist niet? Maar, in een letterlijke string wordt een dubbel aanhalingsteken niet 'ge-escaped' met een backslash, maar in plaats daarvan met een ander dubbel aanhalingsteken, zoals hier:

Console.WriteLine(@"What do you mean by ""Hello, world"" ??");

Het resultaat is dan dit:

What do you mean by "Hello, world" ??

Samenvatting

Strings zijn voor alle programmeurs een ONTZETTEND belangrijk thema. Naar alle waarschijnlijkheid ga je heel veel tijd besteden aan het werken met strings als je code gaat schrijven. Gelukkig heeft C# alle 'tools' die je nodig hebt, zoals ik in dit artikel heb willen aangeven.