Arrays, lijsten en woordenboeken in C#

Arrays: vaste collecties

Een array is een rij van waarden van hetzelfde type met een vaste grootte. Je geeft de grootte aan bij aanmaak:

string[] lagen = new string[4];
lagen[0] = "Muren";
lagen[1] = "Deuren";
lagen[2] = "Ramen";
lagen[3] = "Maatvoering";

// Kortere notatie:
string[] lagen2 = { "Muren", "Deuren", "Ramen", "Maatvoering" };

Elementen worden genummerd vanaf 0. lagen[0] is het eerste element, lagen[3] het laatste.

Console.WriteLine(lagen.Length);  // 4
Console.WriteLine(lagen[0]);      // Muren

List<T>: flexibele lijsten

Een array heeft een vaste grootte. Als je elementen wilt toevoegen of verwijderen, gebruik je een List<T>:

List<string> lagen = new List<string>();
lagen.Add("Muren");
lagen.Add("Deuren");
lagen.Add("Ramen");

lagen.Remove("Deuren");       // verwijder op waarde
lagen.RemoveAt(0);            // verwijder op index

Console.WriteLine(lagen.Count); // 1 (alleen "Ramen" nog over)

// Of direct initialiseren:
List<string> lagen2 = new List<string> { "Muren", "Deuren", "Ramen" };

List<T> met objecten

List<Laag> tekenLagen = new List<Laag>
{
    new Laag("Muren") { Kleur = "Wit" },
    new Laag("Deuren") { Kleur = "Rood" },
};

foreach (Laag laag in tekenLagen)
    Console.WriteLine($"{laag.Naam} — {laag.Kleur}");

Dictionary<TKey, TValue>: sleutel-waarde paren

Een Dictionary slaat waarden op bij een unieke sleutel, zoals een woordenboek. Opzoeken is razendsnel:

Dictionary<string, int> laagKleuren = new Dictionary<string, int>
{
    { "Muren", 7 },      // ACI kleurcode 7 = wit
    { "Deuren", 1 },     // ACI 1 = rood
    { "Ramen", 4 }       // ACI 4 = cyaan
};

// Waarde ophalen:
int kleurCode = laagKleuren["Muren"];  // 7

// Controleren of sleutel bestaat:
if (laagKleuren.ContainsKey("Deuren"))
    Console.WriteLine($"Deuren: ACI {laagKleuren["Deuren"]}");

Wanneer gebruik je wat?

In de volgende post leren we hoe je efficiënt door collecties loopt met LINQ.

Arrays: fixed collections

string[] layers = new string[4];
layers[0] = "Walls";
layers[1] = "Doors";
layers[2] = "Windows";
layers[3] = "Dimensions";

// Shorthand:
string[] layers2 = { "Walls", "Doors", "Windows", "Dimensions" };

Elements are indexed from 0. layers[0] is the first, layers[3] the last.

List<T>: flexible lists

List<string> layers = new List<string>();
layers.Add("Walls");
layers.Add("Doors");
layers.Remove("Doors");   // remove by value
layers.RemoveAt(0);       // remove by index
Console.WriteLine(layers.Count);

// Or initialise directly:
List<string> layers2 = new List<string> { "Walls", "Doors", "Windows" };

List<T> with objects

List<Layer> drawingLayers = new List<Layer>
{
    new Layer("Walls") { Color = "White" },
    new Layer("Doors") { Color = "Red" },
};

foreach (Layer layer in drawingLayers)
    Console.WriteLine($"{layer.Name} — {layer.Color}");

Dictionary<TKey, TValue>: key-value pairs

Dictionary<string, int> layerColors = new Dictionary<string, int>
{
    { "Walls", 7 },    // ACI 7 = white
    { "Doors", 1 },    // ACI 1 = red
    { "Windows", 4 }   // ACI 4 = cyan
};

int code = layerColors["Walls"];  // 7

if (layerColors.ContainsKey("Doors"))
    Console.WriteLine($"Doors: ACI {layerColors["Doors"]}");

When to use what

In the next post we learn how to work efficiently with collections using LINQ.