Collecties in C#
- Inleiding
- HashTable
- Dictionary<TKey,TValue>
- SortedDictionary<TKey, TValue>
- SortedList
- Linked List<T>
- Queue<T>
- Stack<T>
- Een private collectie in een klasse
- Slot
- Voorbeeldprogramma
Inleiding
Voor het opslaan van meerdere, min of meer bij elkaar horende gegevens kunnen we collecties gebruiken. Je zou een collectie kunnen maken voor het doen registreren van bijvoorbeeld de bolletjes breiwol van oma. In de post over Generics zijn een aantal collecties al ter sprake gekomen en we hadden het gehad over de Array, de ArrayList en de generieke List<T>.
De drie eerder genoemde collecties zijn niet de enige collecties die door C# worden ondersteund en een aantal van die andere collecties zullen we in deze post ter sprake brengen. We zullen het één en ander weer toelichten aan de hand van de automobielen van fictieve autofabrikant GHB GuanggongHunnenburgBetrieb.
HashTable
De HashTable is één van de Key Value pair collecties die door C# worden ondersteund. Met een Key Value pair collectie kun je elementen in de collectie met een key terugvinden. Op die manier hoef je niet meer alle elementen van de collectie af te gaan om iets te kunnen vinden. De Key moet wel een unieke waarde hebben.
De HashTable is niet generiek. Het niet generiek wezen van een collectie houdt in dat de collectie voor haar elementen alles goed vindt voor wat betreft gegevenstype of soort object. En dat doen we dan ook in onderstaand voorbeeld. We stoppen van alles en nog wat in de HashTable.
De key is in dit geval òf een int òf een string òf een DateTime en ook stoppen we van alles en nog wat in de values wat varieert van een int tot een GHB automobiel object. Het is de HashTable om het even zolang de key maar uniek is.
// Hashtable
Hashtable hashTable = new Hashtable();
// Key - Value Pairs:
int sleutel1 = 1;
int waarde1 = 123;
string sleutel2 = "TEKST";
string waarde2 = "ABC";
DateTime sleutel3 =
new DateTime(1973, 4, 26, 10, 30, 45);
GHB waarde3 =
new GHB("Dit is de GHB automobiel van Jan");
// Voeg elementen toe
hashTable.Add(sleutel1, waarde1);
hashTable.Add(sleutel2, waarde2);
hashTable.Add(sleutel3, waarde3);
We zien dat we met de meest uiteenlopende key types het desbetreffende element boven water krijgen, maar we zien ook de keerzijde van een niet generieke collectie. We moeten boxen om dingen uit de HashTable te krijgen.
// Wat hebben we weggestopt onder sleutel3?
switch(Convert.ToString(
hashTable[sleutel3].GetType()))
{
case "System.Int32":
// boxen naar int...
int getal_ = (int)hashTable[sleutel3];
Console.WriteLine(getal_);
break;
case "System.String":
// boxen naar string...
string tekst_ = (string)hashTable[sleutel3];
Console.WriteLine(tekst_);
break;
case "DezeNameSpace.GHB":
// boxen naar GHB-object
GHB ghb_ = (GHB)hashTable[sleutel3];
Console.WriteLine(ghb_.Omschrijving);
break;
}
Dictionary<TKey, TValue>
De Dictionary is de generieke variant van de HashTable. Je hebt een Key Value pair waarbij je van te voren voor de Dictionary definieert wat het gegevenstype en / of het soort object is van de Key en de Value. Verder moet de waarde van de Key bij een Key Value pair collectie uniek zijn en dat geldt dus ook voor de Dictionary want de Dictionary is ook een Key Value pair collectie.
In dit voorbeeld definiëren we een Dictionary waarbij de key een int object is en de value een GHB object. Het gebruik van een string object voor de key zal in dit geval dan ook niet lukken want een string is geen int. Je hebt ook aangegeven dat de collectie alleen maar gebruikt kan worden voor het doen opslaan van GHB objecten en zo zal een string object niet geaccepteerd worden daar een string object geen GHB object is. Het strongly typed wezen van de collectie wordt zo afgedwongen.
// Dictionary
Dictionary<int, GHB> dictionary =
new Dictionary<int, GHB>();
// Key - Value Pairs
dictionary.Add
(1, new GHB("Dit is de GHB automobiel
van Jan"));
dictionary.Add
(2, new GHB("Dit is de GHB automobiel
van Sandra"));
dictionary.Add
(3, new GHB("Dit is de GHB automobiel
van Piet"));
// Wat hebben we weggeschreven
// onder sleutelwaarde 2?
Console.WriteLine(
"Key:{0} Value:{1}",
2, dictionary[2].Omschrijving);
We zien dat we met de key het desbetreffende element boven water krijgen en we hoeven niet te boxen om het object uit de Dictionary te krijgen. We vinden in dit voorbeeld met sleutelwaarde 2 de GHB automobiel van Sandra.
SortedDictionary<TKey, TValue>
De SortedDictionary is een sorted variant van de Dictionary waarbij automatisch gesorteerd wordt op sleutelwaarde. We voegen als volgt elementen toe aan de collectie:
// SortedDictionary
SortedDictionary<int, GHB> sortedDictionary =
new SortedDictionary<int, GHB>();
// Key - Value Pairs
sortedDictionary.Add(
3, new GHB("Dit is de GHB automobiel van Piet"));
sortedDictionary.Add(
2, new GHB("Dit is de GHB automobiel van Sandra"));
sortedDictionary.Add(
1, new GHB("Dit is de GHB automobiel van Jan"));
// Toon de inhoud van de collectie
foreach (KeyValuePair<int, GHB> element
in sortedDictionary)
{
Console.WriteLine("{0}. {1}",
element.Key, element.Value.Omschrijving);
}
En we zien dat alle elementen gesorteerd op sleutelwaarde uit de Sorted collectie komen. We hoeven voor de sortering geen extra dingen te doen.
1. Dit is de GHB automobiel van Jan
2. Dit is de GHB automobiel van Sandra
3. Dit is de GHB automobiel van Piet
SortedList
Je kunt de SortedList gebruiken als je een sorted collectie nodig hebt die Non-Generic is. De Key moet wel altijd van hetzelfde gegevenstype of soort object zijn omdat anders niet gesorteerd kan worden.
// De waarden, van alles en nog wat
int waarde1 = 123;
string waarde2 = "ABC";
GHB waarde3 =
new GHB(
"Dit is de GHB automobiel van Jan");
// Sorted List
SortedList sortedList =
new SortedList();
// Voeg elementen toe
sortedList.Add("C", waarde3);
sortedList.Add("B", waarde2);
sortedList.Add("A", waarde1);
// Toon de inhoud van de collectie
foreach
(DictionaryEntry element in sortedList)
{
switch (
Convert.ToString
(element.Value.GetType()))
{
case "System.Int32":
// boxen naar int...
int getal_ = (int)element.Value;
Console.WriteLine(
"{0}. {1}", element.Key, getal_);
break;
case "System.String":
// boxen naar string...
string tekst_ = (string)element.Value;
Console.WriteLine(
"{0}. {1}", element.Key,tekst_);
break;
case "DezeNameSpace.GHB":
// boxen naar GBH-object
GHB ghb_ = (GHB)element.Value;
Console.WriteLine(
"{0}. {1}",
element.Key, ghb_.Omschrijving);
break;
}
}
En alles is gesorteerd waarbij we geen extra dingen hoeven te doen. De key is in dit geval een string:
A. 123
B. ABC
C. Dit is de GHB automobiel van Jan
De SortedList heeft ook een generic variant dat hetzelfde doet als de SortedDictionary. De verschillen tussen de generieke versie van de SortedList en de SortedDictionary hebben voornamelijk te maken met de manier waarop het geheugen gebruikt wordt.
Linked List <T>
Een Linked List is een lineaire generieke data structuur waarbij als een soort treintje allerlei elementen aan elkaar gekoppeld kunnen worden alsof het wagons zijn. In dit voorbeeld is elk knooppunt een GHB automobiel en we beginnen met de auto van Jan en aan de auto van Jan koppelen we de auto van Piet. We kunnen in de lineaire lijst naar believen knooppunten tussenvoegen en we plaatsen met een AddBefore() de auto van Sandra tussen de auto’ s van Jan en Piet:
// Linked List
LinkedList<GHB> keten = new LinkedList<GHB>();
// De GHB automobielen
GHB GHB1 = new GHB("Dit is de GHB automobiel
van Jan");
GHB GHB2 = new GHB("Dit is de GHB automobiel
van Sandra");
GHB GHB3 = new GHB("Dit is de GHB automobiel
van Piet");
// Toevoegen knooppunten
keten.AddLast(GHB1);
keten.AddLast(GHB3);
// Tussenvoegen
keten.AddBefore(keten.Find(GHB3),GHB2);
// Toon de Linked List
foreach(GHB knooppunt in keten)
{
Console.WriteLine(knooppunt.Omschrijving);
}
En we doorlopen de linked list en we zien dat de lijst met de auto van Jan begint en met de auto van Piet eindigt:
Dit is de GHB automobiel van Jan
Dit is de GHB automobiel van Sandra
Dit is de GHB automobiel van Piet
Queue<T>
De Queue is een speciale collectie dat je naar behoefte kan vullen. Kenmerk van de Queue is dat alles wat wordt toegevoegd FIFO (First In First Out) uit de collectie wordt gehaald. Analoog aan het echte leven: als we in de supermarkt in de rij staan voor de kassa dan worden de mensen die als eerste in die rij staan als eerste geholpen.
// De GHB automobielen
GHB GHB1 = new GHB("Dit is de GHB automobiel
van Jan");
GHB GHB2 = new GHB("Dit is de GHB automobiel
van Sandra");
GHB GHB3 = new GHB("Dit is de GHB automobiel
van Piet");
// Queue
Queue<GHB> queue = new Queue<GHB>();
queue.Enqueue(GHB1);
queue.Enqueue(GHB2);
queue.Enqueue(GHB3);
// Alles uit de queue halen
for (int i = queue.Count; i > 0; i--)
{
Console.WriteLine(
"- {0} en die is uit de wachtrij gehaald.",
queue.Dequeue().Omschrijving);
Console.WriteLine(
"- De wachtrij bestaat nu uit {0} elementen.\r\n",
queue.Count);
}
In dit voorbeeld staan Jan, Sandra en Piet in de rij voor de wasstraat waarbij de auto van Jan het eerste wordt gewassen en de auto van Piet het laatst.
Queue
- Dit is de GHB automobiel van Jan en
die is uit de wachtrij gehaald.
- De wachtrij bestaat nu uit 2 elementen.
- Dit is de GHB automobiel van Sandra en
die is uit de wachtrij gehaald.
- De wachtrij bestaat nu uit 1 elementen.
- Dit is de GHB automobiel van Piet en
die is uit de wachtrij gehaald.
- De wachtrij bestaat nu uit 0 elementen.
Stack<T>
De Stack is een speciale collectie dat je net als de Queue naar behoefte kan vullen. Kenmerk van de Stack is dat alles wat wordt toegevoegd LIFO (Last In First Out) uit de collectie wordt gehaald. Analoog aan het echte leven: als we in een kaartspel een stapel kaarten hebben dan trekken we als eerste kaart de kaart die bovenop de stapel ligt. De laatst toegevoegde kaart (die bovenop de stapel ligt) wordt als eerste getrokken.
// De GHB automobielen
GHB GHB1 = new GHB("Dit is de GHB automobiel
van Jan");
GHB GHB2 = new GHB("Dit is de GHB automobiel
van Sandra");
GHB GHB3 = new GHB("Dit is de GHB automobiel
van Piet");
//Stack
Stack<GHB> stack = new Stack<GHB>();
stack.Push(GHB1);
stack.Push(GHB2);
stack.Push(GHB3);
// Alles uit de stack halen
for (int i = stack.Count; i > 0; i--)
{
Console.WriteLine(
"- {0} en die is uit de wachtrij gehaald.",
stack.Pop().Omschrijving);
Console.WriteLine(
"- De stack bestaat nu uit {0} elementen.\r\n",
stack.Count);
}
Jan is altijd haantje de voorste, maar daar heeft Jan nu niks aan want de Stack hanteert het LIFO principe waardoor laatkomer Piet deze keer als eerste geholpen wordt.
Stack
- Dit is de GHB automobiel van Piet en
die is uit de wachtrij gehaald.
- De stack bestaat nu uit 2 elementen.
- Dit is de GHB automobiel van Sandra en
die is uit de wachtrij gehaald.
- De stack bestaat nu uit 1 elementen.
- Dit is de GHB automobiel van Jan en
die is uit de wachtrij gehaald.
- De stack bestaat nu uit 0 elementen.
Een private collectie in een klasse
Wat we als laatste bespreken in deze post is een constructie waarbij een klasse een private collectie heeft. De collectie kan daarbij van “buitenaf” gevuld worden en van “buitenaf” kan ook de inhoud van de collectie opgevraagd worden.
Het vullen van de private collectie en het opvragen van gegevens uit de private collectie kan via methoden en properties die public zijn. De buitenwereld hoeft van de collectie zelf het fijne niet te weten en de collectie wordt om die reden private gemaakt. We zullen de automobielen van autofabrikant GHB er weer bij halen om het één en ander toe te lichten.
Een terugroepactie is de schrik van elke autofabrikant. Elke autofabrikant krijgt er wel eens mee te maken en deze keer is autofabrikant GHB de klos want GHB moet een terugroepactie doen.
Het blijkt dat door een productiefout in remhevelpomp x1500 de GHB automobiel bij hoge snelheden onvoldoende remkracht heeft. De autofabrikant kan de productiefout niet negeren en de auto’s moeten dan ook teruggeroepen worden zodat de remhevelpomp vervangen kan worden. We definiëren klasse Terugroepactie:
class Terugroepactie
{
public string Omschrijving { get; set; }
/*
* De interne collectie
* met GHB automobielen
* die teruggeroepen worden
*/
private Dictionary<int, GHB> automobielen =
new Dictionary<int, GHB>();
/*
* Neem de automobiel op in de lijst
* met een inschrijfnummer
*/
public void VoegToe(int inschrijfNummer, GHB ghb)
{
automobielen.Add(inschrijfNummer, ghb);
}
/*
* Aan de hand van een inschrijfnummer
* bepalen om wiens auto het gaat
*/
public GHB this[int inschrijfNummer]
{
get
{
return automobielen[inschrijfNummer];
}
}
}
Publieke methode VoegToe zorgt ervoor dat GHB automobielen toegevoegd worden aan de private collectie. We geven bij het toevoegen een inschrijfnummer mee zodat we aan de hand van het inschrijfnummer kunnen zien om wiens auto het gaat. Het inschrijfnummer wordt een public property van klasse Terugroepactie waarbij aan de hand van een inschrijfnummer een GHB object uit de private collectie wordt geretourneerd. De buitenwereld kan verder niet zien dat collectie automobielen een generieke dictionary is omdat de collectie private is gemaakt.
// De GHB automobielen
GHB GHB1 = new GHB("Dit is de GHB automobiel
van Jan");
GHB GHB2 = new GHB("Dit is de GHB automobiel
van Sandra");
GHB GHB3 = new GHB("Dit is de GHB automobiel
van Piet");
// De terugroepactie
Terugroepactie terugroepActie =
new Terugroepactie();
terugroepActie.Omschrijving =
"Vervanging Remhevelpomp x1500";
Console.WriteLine(
"Terugroepactie '{0}'.",
terugroepActie.Omschrijving);
// De auto's die teruggeroepen worden
terugroepActie.VoegToe(660, GHB1);
terugroepActie.VoegToe(661, GHB2);
terugroepActie.VoegToe(662, GHB3);
// Inschrijfnummer
// Wie is de eigenaar?
Console.WriteLine(
"- Inschrijfnummer 660: {0}",
terugroepActie[660].Omschrijving);
Console.WriteLine(
"- Inschrijfnummer 661: {0}",
terugroepActie[661].Omschrijving);
Console.WriteLine(
"- Inschrijfnummer 662: {0}",
terugroepActie[662].Omschrijving);
En we zien dat we de auto’s met een inschrijfnummer kunnen toevoegen en we krijgen een auto weer terug door het inschrijfnummer op te geven:
Terugroepactie 'Vervanging Remhevelpomp x1500'.
- Inschrijfnummer 660:
Dit is de GHB automobiel van Jan
- Inschrijfnummer 661:
Dit is de GHB automobiel van Sandra
- Inschrijfnummer 662:
Dit is de GHB automobiel van Piet
Slot
In deze post heb ik een aantal collecties de revue laten doen passeren en toegelicht aan de hand van de GHB automobiel objecten.
De HashTable en de Dictionary zijn Key Value pair collecties. Met een key kun je een element uit de collectie terugvinden zodat je de collectie niet vanaf het begin tot het eind hoeft te doorlopen om het gewenste element te kunnen vinden.
De SortedDictionary en de SortedList zijn sorted collecties. Elementen komen netjes gesorteerd op sleutelwaarde uit de Sorted collectie en je hoeft geen extra dingen te doen voor die sortering.
Een Linked List is een lineaire generieke data structuur waarbij elementen via pointers aan elkaar zijn gekoppeld. De Queue en de Stack zijn collecties waarbij elementen in FIFO òf LIFO volgorde uit de collectie gehaald kunnen worden.
Ten slotte heb ik een constructie laten zien waarbij een klasse een private collectie heeft. De collectie zelf is afgeschermd (private) en de “buitenwereld” kan met publieke methoden en properties bij de gegevens van de collectie komen.
Hopelijk ben je met deze posting weer wat wijzer geworden en ik hoop je weer terug te zien in één van mijn volgende blog posts. Wil je weten wat ik nog meer over C# heb geschreven? Hit the C# button…
Voorbeeldprogramma
using System;
using System.Collections;
using System.Collections.Generic;
namespace DezeNameSpace
{
class GHB
{
// -- Backing variables - fields --
private string _omschrijving;
public GHB(): this("Nog niet op naam") { }
public GHB(string omschrijving)
{
_omschrijving = omschrijving;
}
public string Omschrijving
{
get { return _omschrijving; }
set { _omschrijving = value; }
}
public string MissionStatement()
{
return
"Wij van GHB streven naar " +
"naar wereldwijde samenwerkingsverbanden.";
}
}
class Terugroepactie
{
public string Omschrijving { get; set; }
/*
* De interne collectie
* met GHB automobielen
* die teruggeroepen worden
*/
private Dictionary<int, GHB> automobielen =
new Dictionary<int, GHB>();
// Neem de automobiel op in de lijst
public void VoegToe(int inschrijfNummer, GHB ghb)
{
automobielen.Add(inschrijfNummer, ghb);
}
/*
* Aan de hand van een inschrijfnummer
* bepalen om wiens auto het gaat
*/
public GHB this[int inschrijfNummer]
{
get
{
return automobielen[inschrijfNummer];
}
}
}
class MainClass
{
public static void Main(string[] args)
{
/*
* ---------
* Hashtable
* ---------
*/
Hashtable hashTable = new Hashtable();
// Key - Value Pairs:
int sleutel1 = 1;
int waarde1 = 123;
string sleutel2 = "TEKST";
string waarde2 = "ABC";
DateTime sleutel3 =
new DateTime(1973, 4, 26, 10, 30, 45);
GHB waarde3 =
new GHB("Dit is de GHB automobiel van Jan");
// Voeg elementen toe
hashTable.Add(sleutel1, waarde1);
hashTable.Add(sleutel2, waarde2);
hashTable.Add(sleutel3, waarde3);
// Wat hebben we weggestopt onder sleutel3?
Console.WriteLine("De hashTable");
switch(
Convert.ToString
(hashTable[sleutel3].GetType()))
{
case "System.Int32":
// boxen naar int...
int getal_ =
(int)hashTable[sleutel3];
Console.WriteLine(getal_);
break;
case "System.String":
// boxen naar string...
string tekst_ =
(string)hashTable[sleutel3];
Console.WriteLine(tekst_);
break;
case "DezeNameSpace.GHB":
// boxen naar GBH-object
GHB ghb_ =
(GHB)hashTable[sleutel3];
Console.WriteLine(
ghb_.Omschrijving);
break;
}
/*
* ----------
* Dictionary
* ----------
*/
Dictionary<int, GHB>
dictionary =
new Dictionary<int, GHB>();
// Key - Value Pairs
dictionary.Add(1, new GHB(
"Dit is de GHB automobiel van Jan"));
dictionary.Add(2, new GHB(
"Dit is de GHB automobiel van Sandra"));
dictionary.Add(3, new GHB(
"Dit is de GHB automobiel van Piet"));
// Wat hebben we weggeschreven
// onder sleutelwaarde 2?
Console.WriteLine(
"\r\nDe Dictionary");
Console.WriteLine(
"Key:{0} Value:{1}",
2, dictionary[2].Omschrijving);
/*
* ------------------
* Sorted Dictionary
* ------------------
*/
SortedDictionary<int, GHB>
sortedDictionary =
new SortedDictionary<int, GHB>();
// Key - Value Pairs
sortedDictionary.Add(
3,
new GHB("Dit is
de GHB automobiel
van Piet"));
sortedDictionary.Add(
2,
new GHB("Dit is
de GHB automobiel
van Sandra"));
sortedDictionary.Add(
1,
new GHB("Dit is de
GHB automobiel
van Jan"));
Console.WriteLine(
"\r\nDe Sorted Dictionary");
foreach (KeyValuePair<int, GHB>
element in sortedDictionary)
{
Console.WriteLine("{0}. {1}",
element.Key,
element.Value.Omschrijving);
}
/*
* -----------
* Sorted List
* -----------
*/
SortedList sortedList =
new SortedList();
// Voeg elementen toe
sortedList.Add("C", waarde3);
sortedList.Add("B", waarde2);
sortedList.Add("A", waarde1);
Console.WriteLine(
"\r\nDe Sorted List");
foreach (DictionaryEntry
element in sortedList)
{
switch (
Convert.ToString(
element.Value.GetType()))
{
case "System.Int32":
// boxen naar int...
int getal_ =
(int)element.Value;
Console.WriteLine(
"{0}. {1}", element.Key, getal_);
break;
case "System.String":
// boxen naar string...
string tekst_ =
(string)element.Value;
Console.WriteLine("{0}. {1}",
element.Key,tekst_);
break;
case "DezeNameSpace.GHB":
// boxen naar GBH-object
GHB ghb_ = (GHB)element.Value;
Console.WriteLine("{0}. {1}",
element.Key,
ghb_.Omschrijving);
break;
}
}
/*
* -----------
* Linked List
* -----------
*/
Console.WriteLine("\r\nDe Linked List");
LinkedList<GHB>
keten = new LinkedList<GHB>();
GHB GHB1 =
new GHB(
"Dit is de GHB automobiel van Jan");
GHB GHB3 =
new GHB(
"Dit is de GHB automobiel van Piet");
GHB GHB2 =
new GHB(
"Dit is de GHB automobiel van Sandra");
keten.AddLast(GHB1);
keten.AddLast(GHB3);
keten.AddBefore(keten.Find(GHB3),GHB2);
foreach(GHB knooppunt in keten)
{
Console.WriteLine(
knooppunt.Omschrijving);
}
/*
* ---------------------------
* Alles stoppen we in een wachtrij
* FIFO
* ---------------------------
*/
Console.WriteLine("\r\nQueue");
Queue<GHB> queue =
new Queue<GHB>();
queue.Enqueue(GHB1);
queue.Enqueue(GHB2);
queue.Enqueue(GHB3);
// Alles uit de wachtrij halen
for (int i = queue.Count; i > 0; i--)
{
Console.WriteLine(
"- {0} en die is
uit de wachtrij gehaald.",
queue.Dequeue().Omschrijving);
Console.WriteLine(
"- De wachtrij bestaat
nu uit {0} elementen.\r\n",
queue.Count);
}
/*
* ---------------------------
* Alles stoppen we in een wachtrij
* LIFO
* ---------------------------
*/
Console.WriteLine("\r\nStack");
Stack<GHB> stack =
new Stack<GHB>();
stack.Push(GHB1);
stack.Push(GHB2);
stack.Push(GHB3);
// Alles uit de wachtrij halen
for (int i = stack.Count; i > 0; i--)
{
Console.WriteLine(
"- {0} en die is uit de wachtrij gehaald.",
stack.Pop().Omschrijving);
Console.WriteLine(
"- De stack bestaat nu uit
{0} elementen.\r\n",
stack.Count);
}
/*
* --------------
* Terugroepactie
* --------------
*/
Terugroepactie terugroepActie =
new Terugroepactie();
terugroepActie.Omschrijving =
"Vervanging Remhevelpomp 1500x";
Console.WriteLine(
"\r\nTerugroepactie '{0}'.",
terugroepActie.Omschrijving);
// De auto's die teruggeroepen worden
terugroepActie.VoegToe(660, GHB1);
terugroepActie.VoegToe(661, GHB2);
terugroepActie.VoegToe(662, GHB3);
// Inschrijfnummer - wie is de eigenaar?
Console.WriteLine(
"- Inschrijfnummer 660: {0}",
terugroepActie[660].Omschrijving);
Console.WriteLine(
"- Inschrijfnummer 661: {0}",
terugroepActie[661].Omschrijving);
Console.WriteLine(
"- Inschrijfnummer 662: {0}",
terugroepActie[662].Omschrijving);
}
}
}
Resultaat
De hashTable
Dit is de GHB automobiel van Jan
De Dictionary
Key:2 Value:Dit is de GHB automobiel van Sandra
De Sorted Dictionary
1. Dit is de GHB automobiel van Jan
2. Dit is de GHB automobiel van Sandra
3. Dit is de GHB automobiel van Piet
De Sorted List
A. 123
B. ABC
C. Dit is de GHB automobiel van Jan
De Linked List
Dit is de GHB automobiel van Jan
Dit is de GHB automobiel van Sandra
Dit is de GHB automobiel van Piet
Queue
- Dit is de GHB automobiel van Jan
en die is uit de wachtrij gehaald.
- De wachtrij bestaat nu uit 2 elementen.
- Dit is de GHB automobiel van Sandra
en die is uit de wachtrij gehaald.
- De wachtrij bestaat nu uit 1 elementen.
- Dit is de GHB automobiel van Piet
en die is uit de wachtrij gehaald.
- De wachtrij bestaat nu uit 0 elementen.
Stack
- Dit is de GHB automobiel van Piet
en die is uit de wachtrij gehaald.
- De stack bestaat nu uit 2 elementen.
- Dit is de GHB automobiel van Sandra
en die is uit de wachtrij gehaald.
- De stack bestaat nu uit 1 elementen.
- Dit is de GHB automobiel van Jan
en die is uit de wachtrij gehaald.
- De stack bestaat nu uit 0 elementen.
Terugroepactie 'Vervanging Remhevelpomp 1500x'.
- Inschrijfnummer 660:
Dit is de GHB automobiel van Jan
- Inschrijfnummer 661:
Dit is de GHB automobiel van Sandra
- Inschrijfnummer 662:
Dit is de GHB automobiel van Piet