Cursus c#: Arrays en Collections

Arrays worden vaak ook gegevensvelden of tabellen genoemd.

Aan een variabele kan je altijd maar één waarde tegelijk toewijzen. Een Array daarentegen kan verschillende waarden bevatten. Men spreekt daarbij van verschillende elementen, waarbij elk element een waarde heeft. De afzonderlijke elementen gedragen zich bijgevolg als variabelen. In plaats van tien variabelen kan je dus ook een Array van tien elementen gebruiken.

De elementen van een Array behoren allen tot hetzelfde type:

een Array van ints
een Array van strings
een Array van Circles
een Array van MessageBoxen
...

Arrays hebben nog een groot voordeel : de verschillende elementen worden doorlopend genummerd. In een lus kan je de elementen van de Array doorlopen.

Een Array met n elementen: de elementen hebben een index 0 tot n-1

Een Array declareren

int[] leeftijden;

Hier werd een Array-variabele met de naam leeftijd gedeclareerd, de elementen zullen van het type int zijn.
De vierkante haken na het variabele-type geven dus aan dat de variabele een Array van dergelijke elementen zal zijn.

Een Array instantiëren

Een Array is een referentietype: een Arrayvariabele is dus een variabele die op de stack wordt bewaard en daar enkel het geheugenadres bevat naar het geheugenblok dat op de heap de eigenlijke elementen van de Array bevat.

Bij instantiëren van een Array wordt aangegeven hoeveel elementen de Array zal bevatten:
De elementen kunnen nu ook opgevuld worden, deze elementen moeten van het type zijn dat je hebt aangegeven bij declaratie.

Declareren, de elementen afzonderlijk instantiëren

int[] leeftijden = new int[4]; 
//De Array met de naam leeftijden zal 4 elementen bevatten van het type int.
//Deze elementen worden genummmerd 0 - 3

leeftijden[0] = 18;
leeftijden[1] = 63;
leeftijden[2] = 42;
leeftijden[3] = 7;

opmerking: het aantal elementen kan ook de waarde van een int-variablele zijn:

int aantalelementen = 4;
int[] leeftijden = new int[aantalelementen];

Verkorte schrijfwijze: direct instantiëren

Als je al onmiddellijk de elementen kan opvullen, kan je in C# een verkorte schrijfwijze gebruiken door de elementen tussen accolades te noteren:

int[] leeftijden = new int[4] {18,63,42,7};

Nog korter

Het is zelfs toegestaan om het sleutelwoord new gevolgd door het type en het aantal elementen gewoon weg te laten:

int[] leeftijden = {18,63,42,7};

Toepassing

Declareer in Window1 een variabele leeftijden, toon het derde element van de Array in een MessageBox:

public partial class Window1 : Window
{

    public Window1()
    {
        InitializeComponent();
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
		int[] leeftijden = { 18, 63, 42, 7 };
        MessageBox.Show(leeftijden[2].ToString());  
    }
}

De elementen van een Array overlopen

Eën van de grote voordelen van een Array is de mogelijkheid alle elementen ervan te overlopen.

for-lus

Wanneer je voor een for-lus kies, heb je een tellervariabele nodig die bijhoudt aan welk element je bent gekomen.
Je dient ook te weten wanneer de lus moet stoppen, in ons geval moeten we dus weten uit hoeveel elementen de Array leeftijden bestaat.

Array is in .Net een Klasse, deze klasse heeft tal van nuttige eigenschappen (zie later) en methoden.
De eigenschap Length van de Array leeftijden geeft ons een int die het aantal elementen van de Array bevat:

Voorzie in Window1 een Button BtnToonLeeftijden en een ListBox lstResultaat

Voorzie code voor het klikken op de knop:

public partial class Window1 : Window
{
    

    public Window1()
    {
        InitializeComponent();
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
       //MessageBox.Show(leeftijden[2].ToString());       
    }

    private void btnToonLeeftijden_Click(object sender, RoutedEventArgs e)
    {
		int[] leeftijden = { 18, 63, 42, 7 };
        lstResultaat.Items.Clear();
        for (int i = 0; i < leeftijden.Length; i++)
        {
            lstResultaat.Items.Add(leeftijden[i])
			
            /* i is de tellervariabele
             * en zal dus een keer 0, 1, 2 en 3 bevatten - leeftijden bevat 4 elementen
             * we voegen voor elke lusdoorgang het ie element toe aan de Listbox */

        }
    }
}

Het gebruik van een for-lus vereist een tellervariabele en het opgeven van een lusvoorwaarde (meestal aan de hand van de Length van de Array).

Een for-lus geeft je natuurlijk de vrijheid om bijvoorbeeld slechts de eerste 3 elementen te overlopen, of om de elementen achterwaarts te doorlopen.

foreach

Het één voor één, in volgorde, overlopen van Arrayelementen kan een stuk eenvoudiger door gebruik te maken van een foreach-lus:

foreach (int leeftijd in leeftijden)
{
    lstResultaat.Items.Add(leeftijd);
}

Bij een foreach-lus wordt een reeks elementen één voor één overlopen, bij elke lusdoorgang wordt het respectievelijke element in een variabele gestopt die je zelf in de foreach-lus aangeeft.
In dit voorbeeld is dit de variabele leeftijd.
Deze variabele moet natuurlijk van hetzelfde type zijn als een element uit de Array.

Bij elke lusdoorgang bevat de variabele leeftijd dus de volgende waarde uit de Array leeftijden. Je hebt nu geen tellervariabele meer nodig, en hoeft je ook niet te bekommeren om een lusvoorwaarde.

De klasse Array

System.Array is een klasse binnen .Net.
Deze klasse bevat tal van methoden (Copy, Sort, ...) en eigenschappen (Length, ...).

Arrays hebben echter ook een belangrijk nadeel: ze zijn fixed-length: om elementen toe te voegen of te verwijderen ben je dus verplicht een nieuwe Array te maken!

Arrays zijn dus pas interessant als het aantal elementen in een reeks nooit of heel zelden verandert.

Parameter Arrays

Parameter Arrays kan je handig aanwenden wanneer je niet op voorhand weet hoeveel argumenten je bij een methode-aanroep zal meegeven.

Met het sleutelwoord params kan je in een methode waarden in een Array ontvangen, bij aanroep van deze methode kunnen de waarden 1 voor 1 worden opgegeven:

Voorzie volgende methode in Window1.xaml.cs:

private void toonBerichten(params string[] berichten)
{
    lstResultaat.Items.Clear();
    foreach (string bericht in berichten)
    {
        lstResultaat.Items.Add(bericht);
    }
}

Voorzie een Button btnToonBerichten met volgende klik-handler:
```
toonBerichten(  
               "C# is leuk",
               "Soep is lekker",
               "Sneeuw is koud",
               "Binair begint met de letter b");
```
Belangrijk bij het gebruik van params is dat enkel het laatste argument binnen een methode dit sleutelwoord kan bevatten.
Binnen vele .Net-methoden wordt van dit principe gebruik gemaakt: String.Fromat, Console.WriteLine, ...)

Wat zijn Collection klassen

.Net bevat naast Arrays nog andere klassen om reeksen elementen te hanteren, we noemen ze de Collection klassen, je vindt ze in de namespace System.Collections

Voorzie een using statement voor de namespace System.Collections

Specifiek aan deze Collection klassen is dat ze hun elementen stockeren als van het type object.

In deze namespace vinden we een aantal klassen terug, elk met hun specifieke troeven:

ArrayList
Queue
Hashtable
SortedList

ArrayList

Een ArrayList heeft als specifieke troef dat je de elementen vlot kan manipuleren:

Elementen toevoegen met de methode Add
Elementen verwijderen met de methode Remove
Elementen tussenvoegen met de methode Insert
Elementen zijn net zo aan te spreken als in een Array: naam van de ArrayList gevolgd door vierkante haken met een indexcijfer.
Net als Arrays gemakkelijk te doorlussen met een foreach-lus
Toepassing:

Voorzie een Button btnToonNamen, bij klikken voer je volgende code uit:

ArrayList namen = new ArrayList();
namen.Add("William");
namen.Add("Johan");
namen.Add("Marie");
namen.Add("Eddy");
namen.Add("Tinne");

namen.Insert(3, "Sofie");
namen.Remove("Marie");

lstResultaat.Items.Clear();
foreach (string naam in namen)
{
    lstResultaat.Items.Add(naam);
}

Een ArrayList kan net zoals een Array bestaan uit een serie volwaardige objecten, zoals objecten van onze eigen klasse Circle:

Voorzie nu ook een referentie naar de IVO.HBO.Geometry dll uit het hoofdstuk klassen

Voorzie een button btnCirkels, bij klikken:

ArrayList cirkels = new ArrayList();
cirkels.Add(new Circle(3));
cirkels.Add(new Circle(10));
cirkels.Add(new Circle(8));

lstResultaat.Items.Clear();
foreach (Circle circle in cirkels)
{
    lstResultaat.Items.Add(String.Format(
        "Cirkel met radius {0} en omtrek {1}",
        circle.radius.ToString(),
        Math.Round(circle.Circumference(),2)));
}

c# : Arrays en Collections

Voorbereiding

Wat is een Array