Arrays
    - int [,] rectangular = new int [2,3];
        - Maakt grid van 2 hoog bij 3 breed
        - = { { 2, 3, 5 }, { 5, 7, 8} }
        - .Length geeft lengte * breedte
        - .GetLength(dimensie)
        - Sneller dan ragged array. Het geheugen kan uitrekenen dat die een bepaalde geheugenplek moet hebben in een keer.
            - x * y = pointer (zoiets)
        - Makkelijker aan te maken. Er moet over ragged arrays heen geloopt worden om alle elementen te vullen met lege arrays
    - int [][] ragged
        - Array van arrays. Iedere array kan een andere lengte hebben
        - new int [3][]
            - Maakt een 3-lange array aan van null references
    - Fixed size. Nooit maar dan ook nooit kunnen ze van grootte veranderen

Indexers
    - public int this[int index] { get {..} set {..} }

Properties
    - public int Count => _count;
        - Get implementatie

Interfaces
    - Hoe?
        - public Foo() is de impliciete implementatie
        - IEnumerable.Foo() is de expliciete implementatie
        - Expliciete implementaties kunenn niet public zijn
    - Waarom een of ander
        - Twee interfaces met dezelfde naam
        - Om een expliciet geimplementeerde methode te laten verdwijnen uit het intellisense lijstje

Enumerator
    - yield return
        - IEnumerator of IEnumerable
    - Compiler maakt er iets anders van
        - T Current

IEnumerable
    - { 1,3,4 }
        - Mag als je IEnumerable implementeert en als er een Add methode is

Generics
    - List templates
        - List<int> -> de JIT compiler genereert een hele nieuwe klasse voor ints
        - List<bool> -> de JIT compiler genereert een hele nieuwe klasse voor bools
        - List<string> -> de JIT compiler genereert een hele nieuwe klasse voor ALLE REFERENCE TYPES
        - Als er een klasse wordt gebruikt van een al gegenereerde List type gebruikt wordt er GEEN nieuwe template gemaakt
    - Generic constraints
        - where T : IComparable<T> (ai-KOM-puh-rah-bul)
        - where T : struct
            - T moet een valuetype zijn
        - where T : class
            - T moet een reference type zijn
        - where T : new()
            - T moet een parameterless constructor hebben
            - T x = new T();
        
Covariance
    - Soorten
        - List <    T> List is Invariant
        - List <out T> List is Covariant
            - Als [P] <- [Q]
            - Dan List [<P>] <- [List <Q>]
        - List < in T> List is Contravariant
            - Als [P] <- [Q]
            - Dan [List <Q>] <- [List <P>]
    - Voorbeelden
        - Person p = new Student() MAG
        - List <Person> p = new List <Student>() MAG NIET
            - List is niet covariant, maar invariant
        - IEnumerable <Perosn> p
            - IEnumerable is Covariant, dus deze mag een IEnumerable <Student> bevatten
            - IEnumerable <Person> p = new List <Student>(); Mag dus ook omdat de List als Enumerable behandeld wordt