Dictionaries

Alle Dictionaries in C# implementeren de IDictiornary interface. Er zijn verschillende types Dictionaries, maar de meest gebruikte is de generische Dictionary, waar vaak naar verwezen wordt met Dictionary<TKey, Tvalue> - hij bevat dus een type-specifieke sleutel en een corresponderde type-specifieke waarde. Dit is wat een Dictionary onderscheidt van een List - in een lijst worden zaken in een specifieke volgorde opgeslagen en kan je ze aanroepen met een numerische waarde, items in een Dictionary worden opgeslagen met een unieke sleutel, die je dan kan gebruiken om het item aan te roepen.

We gaan dadelijk dieper in op onze Dictionaries, maar laat ons eerst even kijken naar een simple voorbeeld:

Dictionary<string, int> users = new Dictionary<string, int>();  
users.Add("John Doe", 42);  
users.Add("Jane Doe", 38);  
users.Add("Joe Doe", 12);  
users.Add("Jenna Doe", 12);

Console.WriteLine("John Doe is " + users["John Doe"] + " years old");

Maak opnieuw kennis met de familie Doe, die we opnieuw gebruiken om een voorbeeld te tonen in deze tutorial. Moeder, vader en de tweeling Joe en Jenna. Let er op hoe ik de Dictionary definieer, we gebruiken een string als sleutel (in dit voorbeeld de naam) en een integer als waarde (in dit voorbeeld de leeftijd). Dit laat ons toe een item op te roepen in de Dictionary door de sleutel (naam) te gebruiken in plaats van een numerieke index. Je kan dit in actie zien in de laatste regel van ons voorbeeld, tussen de vierkante haakjes [] geven we gewoon de sleutel mee om toegang te krijgen tot de waarde (de leeftijd).

Er is iets waar je rekening mee moet houden: De sleutel moet uniek zijn. In dit geval gebruiken we een string als sleutel, dat wil zeggen dat je geen twee gebruikers kan toevoegen die exact dezelfde naam hebben, je wilt dat de sleutel naar één specifieke waarde verwijst. Dit maakt ons huidige voorbeeld eigenlijk wat te simpel, in de realiteit kan je nooit een lijst met gebruikers hebben waar dubbele namen niet kunnen bestaan, maar volg voorlopig nog even mee.

Waar je ook rekening mee moet houden, als je de waarden in een Dictionary wilt benaderen, moet de sleutel bestaan binnen de verzameling. In de meeste gevallen is het dus geen slecht idee om eerst te controleren of de sleutel wel bestaat alvorens de waarde uit te lezen, dat doen we als volgt:

string key = "John Doe";
if(users.ContainsKey(key))
    Console.WriteLine("John Doe is " + users[key] + " years old");

Als je een sleutel probeert toe te voegen die reeds bestaat, of een sleutel probeert op te roepen die niet bestaat, krijg je een foutmelding. Dat mag dan wel logisch lijken, het is geen slecht idee om hier altijd wat extra aandacht aan te besteden.

Werken met de items

Een item uit een Dictionary aanspreken kan zeer nuttig zijn, maar wat als je met een lus door de verzameling wil lopen om iets te zoeken? Dan moet je je ervan bewust zijn dat items in een Dictionary geen simpele objecten zijn, een Dictionary bevat items van het type KeyValuePair<TKey, TValue>. De T's zijn de datatypes die je gebruikt hebt om de Dictionary te declareren, in ons voorbeeld dus een string en een integer. Om met een foreach lus door onze verzameling te lopen ziet dat er als volgt uit:

Dictionary<string, int> users = new Dictionary<string, int>()
{
    { "John Doe", 42 },
    { "Jane Doe", 38 },
    { "Joe Doe", 12 },
    { "Jenna Doe", 12 }
};
foreach (KeyValuePair<string, int> user in users)
{
    Console.WriteLine(user.Key + " is " + user.Value + " years old");
}

Het eerste dat je misschien opvalt is dat ik de manier waarop we de Dictionary initialiseren heb veranderd. In plaats van elk item apart toe te voegen aan de Dictionary na het initialiseren, gebruiken we de collection initializer syntax, zoals beschreven in het vorige artikel.

Na het initialiseren lopen we met een foreach lus door de items in de Dictionary. We gebruiken het type dat we verwachten namelijk KeyValuePair <string, int>, dezelfde types die we gebruikt hebben voor het declareren van de Dictionary. Op deze manier krijgen we toegang tot zowel de key als de value van elk item (naam en leeftijd), deze gebruiken we dan om een simpele string te generen met informatie over deze person en geven we deze weer in de console.

De volgorde van items

Bovenstaand voorbeeld toont een zeer belangrijk punt aan: in tegenstelling tot een List, waar de volgorde van items wordt bepaald daar een numerieke index, is de volgorde van items in een Dictionary niet-gedetermineerd. Je kan er niet op voortgaan dat een items in een bepaalde volgorde staan, zelfs niet wanneer je de items zelf toevoegt. Als je bovenstaand voorbeeld uitvoert zullen de items weliswaar in dezelfde volgorde weergegeven worden als waarin we ze hebben toegevoegd, maar dat is niet gegarandeerd. Van zodra we een Dictionary hebben met meerd items en we beginnen met het toevoegen en verwijderen van items, zal de volgorde wijzigen.

De Dictionary klasse heeft geen Sort() methode, want zodra je ermeer begint te werken kan de volgorde opnieuw veranderen. In de plaats daarvan kan je de OrderBy() of de OrderByDescending() methode uit LINQ (meer daarover in een ander hoofdstuk) gebruiken om een gestorteerde kopie van de Dictionary te verkrijgen. Dit laat je ook toe om ofwel op de key ofwel op de waarde te sorteren. Dit is handig in ons voorbeeld, om de gebruikers uit de Dictionary te halen in volgorde van hun leeftijd:

Dictionary<string, int> users = new Dictionary<string, int>()
{
    { "John Doe", 42 },
    { "Jane Doe", 38 },
    { "Joe Doe", 12 },
    { "Jenna Doe", 12 }
};
foreach (KeyValuePair<string, int> user in users.OrderBy(user => user.Value))
{
    Console.WriteLine(user.Key + " is " + user.Value + " years old");
}

Als je dit voorbeeld uitvoert zal je zien dat hoewel de items in de Dictionary in een bepaalde volgorde gedeclareerd worden, we ze makkelijk in een andere volgorde uit de Dictionary kunnen halen. Onthou gewoon dat het jouw verantwoordelijkheid is om te verzekeren dat je de items in de juiste volgorde ontvangt. Want het .NET framework slaat de items op zoals het zelf wil.