TOC

This article is currently in the process of being translated into Dutch (~74% done).

Data types:

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 de char te gebruiken. String 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 string onveranderlijk, eenmaal ze gemaakt zijn, kunnen ze niet veranderd worden. Dat is niet echt praktisch om te gebruiken, maar het framework helpt ons hierbij. In plaats van telkens nieuwe string 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" ??

In other words, we simply use backslashes before a double quote, to indicate that this is NOT the end of the string, but instead, we actually want a double quote. So... what if we actually want a backslash and not just use it to escape another character? Well then you will have to escape that too - with another backslash:

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

Resulting in:

Right here \ Right now

The reason is that the backslash is not just used to escape double quotes - it's also used to prefix a range of characters to give them special meanings. For instance, \n is a new line, \t is a tab character and so on. You can find a nice list of escape sequences here.

Verbatim strings

As an alternative to all this escaping, you can use a verbatim string. It's like a regular string declaration, but prefixed with the @ character, and inside it, all characters are treated literally:

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

The output will look just like the input:

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

There's just one exception to this rule: A double quote still has to be escaped, but that makes pretty good sense, because otherwise, how would the compiler know if you're trying to end the string or not? In a verbatim string however, a double quote is not escaped with a backslash but instead with another double quote, like this:

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

The result looks like this:

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

Summary

Strings are SUCH an important topic for all programmers - you will likely be doing some sort of string processing for much of the time you spent writing code. Fortunately, C# has all the tools you will need to do it, as I have tried to illustrate in this article.

This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!