Wat leer je in dit hoofdstuk?

Na dit hoofdstuk kan je:

uitleggen hoe het geheugen verdeeld is in stack en heap

het verschil tussen value types en reference types doorgronden

de rol van de Garbage Collector beschrijven

objecten meegeven aan en teruggeven uit methoden

werken met null en de NullReferenceException vermijden

namespace en using situeren

robuuste code schrijven met try, catch en finally

Geheugenbeheer in C#

Ook objecten zijn reference types

In hoofdstuk 8 zag je twee soorten variabelen:

Value types

de waarde staat rechtstreeks op de geheugenplek: int, bool, char, enums, …

Reference types

de variabele bevat een geheugenadres naar de echte data: tot nu toe enkel arrays

Belangrijk

Ook objecten zijn reference types. Zodra je met objecten en arrays werkt, en dat doe je voortdurend, heb je met reference types te maken.

Twee soorten geheugen

Een C#-programma krijgt twee geheugens:

de kleine, snelle stack

de grote, tragere heap

Value types Reference types
Inhoud de eigenlijke data een referentie naar de data
Locatie stack heap
Beginwaarde 0, 0.0, false, … null (ook bij string)
= kopieert de waarde het adres

Waarom twee geheugens?

Hoeveel stack je nodig hebt, berekent de compiler al bij het compileren (een int is altijd 32 bit)

De heap is voor data waarvan de grootte pas tijdens de uitvoer bekend is (tekst van de gebruiker, arrays, objecten)

Stack en heap.

De heap is een grote speelplaats; de stack het kleine bankje naast de zandbak.

Value types in de stack

De waarde zelf staat in de stack: int, double, bool, char, … en enums.

int getal = 3;
int anderGetal = getal;

= kopieert de waarde. Pas je daarna een van beide aan, dan merkt de andere daar niets van.

Een kopie als parameter

Een methode krijgt een kopie van een value type:

void VerhoogParameter(int a)
{
    a++;
    Console.WriteLine($"In methode {a}");
}

int getal = 5;
VerhoogParameter(getal);
Console.WriteLine($"Na methode {getal}");
In methode 6
Na methode 5

Reference types in de heap

De effectieve data staat in de heap

In de stack staat enkel een referentie: het geheugenadres, bv. 0xA3B3163

Dat geldt voor alles wat groot is of waarvan je op voorhand niet weet hoe groot het wordt: arrays en objecten.

Opmerking

= kopieert bij een reference type de referentie, niet de data zelf.

= bij objecten

Student stud = new Student();

1. new Student() maakt via de constructor een object in de heap en geeft het adres terug

2. de variabele stud komt in de stack

3. dat adres wordt in stud bewaard

Stap voor stap

Student stud;
stud = new Student();

Na lijn 1: stud wijst nog naar geen object.

new Student() maakt het object in de heap.

Het adres komt in stud.

= bij arrays

int[] nummers = {4, 5, 10};
int[] andereNummers = nummers;

andereNummers[0] = 999;
Console.WriteLine(andereNummers[0]);
Console.WriteLine(nummers[0]);
999
999

Beide variabelen wijzen naar dezelfde array.

Hetzelfde bij objecten

Student a = new Student("Abba");
Student b = new Student("Queen");
b = a;
Console.WriteLine(a.Naam); // Abba

b = a kopieert het adres, niet het object. Beide wijzen nu naar hetzelfde object; “Queen” ben je kwijt.

Beide variabelen wijzen naar hetzelfde object.

Belangrijk

Ook de value-type-properties en instantievariabelen van een object staan in de heap: het hele object wordt daar bewaard.

De Garbage Collector

De GC ruimt objecten in de heap op waar geen referentie meer naar wijst:

Held supermand = new Held();
Held batmand = new Held();
batmand = supermand;

Het tweede Held-object is nu onbereikbaar en verdwijnt.

De GC ruimt onbereikbare objecten op.

Een object bewaren

Wil je dat tweede object houden, zorg dan voor minstens één referentie:

Held supermand = new Held();
Held batmand = new Held();
Held bewaarEersteHeld = batmand;
batmand = supermand;

Waarschuwing

De GC draait niet continu, maar om de zoveel tijd. Roep nooit zelf GC.Collect() op: de GC kiest zelf het beste moment, en jij maakt je programma meestal net trager.

Stagiair Steven

Steven wil elke verwerkte student bijhouden. De A.I. gaf hem een array:

Student[] archief = new Student[100000];
for (int i = 0; i < archief.Length; i++)
{
    Student tijdelijk = new Student();
    archief[i] = tijdelijk;
    // ... student verwerken ...
}
// ... en het programma draait nog lang verder ...

“Na elke ronde is tijdelijk toch weg en ruimt de GC dat op”, denkt hij. Waarom loopt het geheugengebruik toch op?

Stagiair Steven: wat liep er mis?

tijdelijk verdwijnt inderdaad na elke ronde

maar archief blijft bestaan, en houdt een referentie naar elke Student

Opmerking

De GC ruimt een object pas op als het onbereikbaar is. “De lokale variabele is weg” is niet hetzelfde als “er is nergens anders nog een referentie naar”. Na de lus zit archief vol objecten die niemand gebruikt, maar die de GC niet mag weggooien.

Wat met string?

string is een reference type, maar gedraagt zich vaak als een value type omdat het immutable is:

string naam = "tim";
naam = naam.ToUpper();   // nieuwe tekst "TIM"

Tip

ToUpper() wijzigt de originele tekst niet, maar maakt een nieuwe. Vergeet je de toewijzing (naam.ToUpper();), dan verandert er niets aan naam.

Objecten en methoden

Objecten als parameter

Een methode krijgt bij een object een kopie van de referentie, niet van het object.

internal class Meting
{
    public int Temperatuur { get; set; }
    public string OpgemetenDoor { get; set; }

    public void ToonMetingInKleur(ConsoleColor kleur)
    {
        Console.ForegroundColor = kleur;
        Console.WriteLine($"{Temperatuur} graden C gemeten door: {OpgemetenDoor}");
        Console.ResetColor();
    }
}
m1.ToonMetingInKleur(ConsoleColor.Red);

Objecten in methoden aanpassen

De methode krijgt het adres, dus aanpassingen raken het origineel:

public void VoegMetingToeEnVerwijder(Meting inMeting)
{
    Temperatuur += inMeting.Temperatuur;
    inMeting.Temperatuur = 0;
    inMeting.OpgemetenDoor = "";
}
m1.Temperatuur = 26;
m2.Temperatuur = 5;
m1.VoegMetingToeEnVerwijder(m2);
Console.WriteLine($"{m1.Temperatuur} en {m2.Temperatuur}");
31 en 0

Objecten als resultaat

Een methode mag ook een object teruggeven:

public Meting GenereerDubbeleMeting()
{
    Meting result = new Meting();
    result.Temperatuur = Temperatuur * 2;
    result.OpgemetenDoor = $"{OpgemetenDoor} Junior";
    return result;
}
m1.Temperatuur = 26;
m1.OpgemetenDoor = "Lieven Scheire";
Meting m3 = m1.GenereerDubbeleMeting();

m3 meet 52 graden en is opgemeten door Lieven Scheire Junior.

Bevallen in code

Baby’s zijn kleine mensjes, dus een Mens kan een nieuwe Mens teruggeven:

class Mens
{
    public Mens PlantVoort()
    {
        return new Mens();
    }
}
Mens oermoeder = new Mens();
Mens dochter;
Mens kleindochter;
dochter = oermoeder.PlantVoort();
kleindochter = dochter.PlantVoort();

Tip

Een interessante oefening: teken deze code uit in de stack en de heap, met alle referenties.

Object referenties en null

null

Student stud1;
stud1.Naam = "Marc Jansens"; // fout

stud1 kreeg nog geen waarde: de compiler weigert (CS0165, use of unassigned local variable). Wil je zeggen “hier staat nog geen object”, dan gebruik je null: de standaardwaarde van instantievariabelen en array-elementen van een reference type.

null mag je aan elk reference type toekennen, en je kan erop testen

Zodra je er met = een referentie in stopt, is de null overschreven

Tip

De GC werkt enkel op de heap. Een variabele in de stack die null is, ruimt hij dus nooit op.

NullReferenceException

Student stud1 = null;
Console.WriteLine(stud1.Naam);
System.NullReferenceException: ‘Object reference not set to an instance of an object’. stud1 was null.

Je benadert een object dat er niet is.

Er staat geen object op de heap om te benaderen.

Opmerking

De = null staat er expliciet omdat VS je anders al waarschuwt. Groene kronkellijntjes rond null horen bij nullable reference types: die behandelen we nog niet, je mag ze voorlopig negeren.

NullReferenceException voorkomen

if (stud1 == null)
    Console.WriteLine("Oei. Object bestaat niet.");

if (stud1 != null)
{
    Console.WriteLine(stud1.Naam);
}

Korter, met het vraagteken:

Console.WriteLine(stud1?.Naam);

“Voer de code na het vraagteken enkel uit als het object ervoor niet null is.”

Is stud1 null, dan verschijnt er gewoon een lege lijn.

Return null

Een methode mag bewust null teruggeven, bv. als ze niets vond:

static Student ZoekStudent(Student[] array, string naam)
{
    Student gevonden = null;
    for (int i = 0; i < array.Length; i++)
    {
        if (array[i].Naam == naam)
            gevonden = array[i];
    }
    return gevonden;
}

Opmerking

Deze loop zoekt verder, ook na een match. Dat kan sneller, maar we houden het hier bewust eenvoudig.

Bevallen met ouders

De baby wordt nooit groter dan de grootste ouder:

internal class Mens
{
    public int MaxLengte { get; set; }

    public Mens PlantVoort(Mens dePapa)
    {
        Mens baby = new Mens();
        baby.MaxLengte = MaxLengte;
        if (dePapa.MaxLengte >= MaxLengte)
            baby.MaxLengte = dePapa.MaxLengte;
        return baby;
    }
}

Bevallen met ouders: enkel als het mag

public Mens PlantVoort(Mens dePapa)
{
    if (Geslacht == Geslachten.Vrouw
        && dePapa.Geslacht == Geslachten.Man)
    {
        Mens baby = new Mens();
        baby.MaxLengte = MaxLengte;
        if (dePapa.MaxLengte >= MaxLengte)
            baby.MaxLengte = dePapa.MaxLengte;
        return baby;
    }
    return null;
}
Mens mama = new Mens();
mama.Geslacht = Geslachten.Vrouw;
mama.MaxLengte = 180;
Mens papa = new Mens();
papa.Geslacht = Geslachten.Man;
papa.MaxLengte = 169;

Mens baby = mama.PlantVoort(papa);

Lukt de voortplanting niet, dan geeft de methode null terug.

Namespaces en using

Namespaces

Een namespace voorkomt naamconflicten tussen klassen:

namespace MyEpicGame
{
    internal class Monster

De volledige naam (Fully Qualified Type Name) is MyEpicGame.Monster. Een Monster uit een ander project heet NietZoEpicGame.Monster en botst er dus niet mee.

De namespace-politie

De politie, uw vriend! Vraag je “waar is de Kerkstraat?”, dan vragen wij eerst: in welke gemeente?

Een namespace is die gemeentenaam: ze laat toe een klasse (de straat) zonder verwarring te identificeren.

using

using System.Diagnostics;

Zo zeg je:

“Beste C#, vind je een klasse niet in dit project, kijk dan zeker in de System.Diagnostics-bibliotheek”

Ontbrekende namespaces terugvinden

Schrijf de klassenaam en klik op het lampje in de rand. VS biedt aan om:

  • een using bovenaan je bestand te zetten
  • of de volledige naam uit te schrijven

Bestaat de klasse nog niet, dan maakt Generate type ze voor je aan.

Handig toch!

Dependencies en NuGet

Dependencies

In de Solution Explorer zie je in welke bibliotheken VS mag zoeken, bv. alle System.-bibliotheken onder Microsoft.NETCore.App

NuGet

Rechterklik op Dependencies om extra bibliotheken toe te voegen. Zoek eens naar Colorful.Console

Exception handling

Een bekentenis

Ik heb al de hele tijd iets voor je achtergehouden: exception handling. Daarmee crasht je programma minder snel als er zich uitzonderingen voordoen.

Waarschuwing

Het is een tweesnijdend zwaard. Je kan er al je bugs mee verstoppen, zodat de gebruiker niet ziet hoe vaak je programma zou crashen. Maar dan blijf je met slechte code zitten.

Exception handling is de finale fase van goedgeschreven code.

Waarom exception handling?

Data die er niet is

een verplaatst bestand, wegvallende wifi

Foute invoer

een letter waar een getal verwacht wordt

Programmeerfouten

een object zonder new, een deling door nul

Dat zijn geen fouten, maar uitzonderingen (exceptions). Ze komen zelden voor, maar je programma moet ermee om kunnen.

Een joekel van een foutboodschap

Console.WriteLine("Geef een getal aub");
int noemer = Convert.ToInt32(Console.ReadLine());
int resultaat = 100/noemer;
Console.WriteLine($"100/{noemer} is gelijk aan {resultaat}");

Geef 0 of iets anders dan een getal in, en je programma toont een hoop tekst met het woord “Exception” en sluit af.

Een onafgehandelde exception.

try en catch

In het try-blok staat code waar een uitzondering kan optreden

Het catch-blok, meteen erna, verwerkt de uitzondering

try
{
    string input = Console.ReadLine();
    int converted = Convert.ToInt32(input);
}
catch
{
    Console.WriteLine("Verkeerde invoer!");
}

Typt de gebruiker tekst of een kommagetal, dan treedt een FormatException op. Het programma toont de boodschap en gaat verder na het catch-blok.

throw

Je kan zelf een uitzondering opwerpen:

throw new Exception("Wow, dit loopt fout");

Opmerking

Net als return verlaat throw de methode, maar dan tot de eerste plek waar een catch klaarstaat. Dat naar boven klimmen door de methode-aanroepen heet stack unwinding. Daarom telt de plaats van je try/catch.

Een familie van exceptions

Klasse Omschrijving
Exception basisklasse
SystemException kan mogelijk verholpen worden
IndexOutOfRangeException index te groot of te klein
NullReferenceException object zonder new
Exception
 └── SystemException
      ├── IndexOutOfRangeException
      ├── NullReferenceException
      └── FormatException

Elke specifieke exception is ook een Exception. Daarom vangt catch (Exception e) ze allemaal op.

Meerdere catch-blokken

try
{
    //...
}
catch (FormatException e)
{
    Console.WriteLine("Verkeerd invoerformaat");
}
catch (Exception e)
{
    Console.WriteLine("Exception opgetreden");
}

Enkel het eerste catch-blok dat past, wordt uitgevoerd.

Waarschuwing

Specifiek eerst, algemeen laatst. Anders compileert je code niet: “A previous catch clause already catches all exceptions of this or of a super type”.

Wat je niet moet doen

//SLECHT: fout wordt stil ingeslikt
try { /* ... */ }
catch { }

Belangrijk

Een leeg catch-blok verbergt bugs in plaats van ze op te lossen. Vang enkel exceptions op waar je echt iets mee doet: een nette boodschap tonen, loggen, een alternatief proberen.

Tip

Gebruik je e nergens, dan waarschuwt VS. Schrijf dan gewoon catch (Exception), zonder naam.

Stagiair Steven

Steven wil foute invoer en andere fouten apart afhandelen. De A.I. gaf hem dit:

try
{
    int noemer = Convert.ToInt32(Console.ReadLine());
    int resultaat = 100 / noemer;
    Console.WriteLine(resultaat);
}
catch (Exception e)
{
    Console.WriteLine("Er ging iets mis.");
}
catch (FormatException e)
{
    Console.WriteLine("Verkeerd invoerformaat.");
}

“Dubbel beveiligd”, denkt hij. Waarom compileert dit niet?

Stagiair Steven: wat liep er mis?

A previous catch clause already catches all exceptions of this or of a super type

Opmerking

Het algemene catch (Exception e) staat bovenaan. Een FormatException is ook een Exception, dus het onderste blok kan nooit bereikt worden: dode code, en C# laat dat niet compileren. Steven moest de twee blokken omwisselen: specifiek eerst, algemeen laatst.

Welke exceptions worden gegooid?

De online .NET-documentatie vertelt het je. Bij Int32.Parse staat een sectie Exceptions: welke uitzondering, en wanneer.

Een deel van de documentatie.

De exception-parameter

Element Omschrijving
Message foutmelding in eenvoudige taal
StackTrace methoden die de exception doorgaven
TargetSite methode die de exception gaf
ToString() type, Message en StackTrace
catch (Exception e)
{
    Console.WriteLine("Exception opgetreden");
    Console.WriteLine("Message:" + e.Message);
    Console.WriteLine($"Targetsite: {e.TargetSite}");
    Console.WriteLine($"StackTrace: {e.StackTrace}");
}

Belangrijk

Stuur deze info niet zomaar naar de gebruiker: ze kan gevoelige details bevatten die kwaadwillige gebruikers misbruiken om bugs te vinden.

finally: het derde lid

try
{
    //...code die kan mislukken
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}
finally
{
    //bv. een geopend bestand terug afsluiten
}

Het finally-blok loopt altijd: of er nu een exception was of niet.

Tip

Voor “iets openen en daarna gegarandeerd sluiten” bestaat een kortere schrijfwijze: het using-statement, bij bestandsverwerking.

Waar plaats je try/catch?

Een methode downloadt een lijst urls. De tweede url bevat een fout:

string[] urllist = new string[3];
urllist[0] = "http://www.ziescherp.be";
urllist[1] = "http:\\www.humo.be";
urllist[2] = "timdams.com";
DownloadAllUris(urllist);
static public void DownloadAllUris(string[] urls)
{
    System.Net.WebClient webClient = new System.Net.WebClient();
    for (int i = 0; i < urls.Length; i++)
    {
        Uri uri = new Uri(urls[i]);
        webClient.DownloadString(uri);
        Console.WriteLine($"{uri} gedownload!");
    }
}

Rond de hele methode-aanroep

try
{
    DownloadAllUris(urllist);
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}
http://www.ziescherp.be/ gedownload!
Ongeldige URI: kan de Authority/Host niet parsen.

Bij de eerste fout stopt de hele methode. Enkel zinvol als je de info van alle urls nodig hebt.

Rond elke stap in de loop

for (int i = 0; i < urls.Length; i++)
{
    try
    {
        Uri uri = new Uri(urls[i]);
        webClient.DownloadString(uri);
        Console.WriteLine($"{uri} gedownload!");
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
}
http://www.ziescherp.be/ gedownload!
Ongeldige URI: kan de Authority/Host niet parsen.
Ongeldige URI: de indeling van de URI kan niet worden bepaald.

Een foute url wordt overgeslagen, de rest gaat door.

Conclusie

Value types staan in de stack; reference types (objecten, arrays) hebben in de stack enkel een referentie naar de heap

= kopieert bij objecten het adres, niet het object; een methode die een object krijgt, werkt op het origineel

De Garbage Collector ruimt onbereikbare objecten op; een reference type zonder object is null

namespace en using ordenen je klassen en voorkomen naamconflicten

try/catch/finally vangt uitzonderingen op: specifiek eerst, algemeen laatst

Tip

Volgende halte: gevorderde klasseconcepten, met constructors en static.

Meer weten

Kennisclips

Oefeningen H10 · Quizlet flashcards

Zie verder

Een korte zoek-de-fout, om zo kritisch mogelijk naar code te leren kijken.

Zie verder: zoek de fout

Onderstaande C#-code wil de naam van een student tonen, maar crasht met een NullReferenceException. Wat loopt er mis?

Student[] studenten = new Student[3];
studenten[0].Naam = "Marc Jansens";
Console.WriteLine(studenten[0].Naam);

Opmerking

new Student[3] maakt wel een array aan, maar die bevat drie reference types die elk de defaultwaarde null hebben. Er staat dus nog geen Student-object op studenten[0]. Op de tweede regel probeer je .Naam te zetten op een object dat null is, en dat geeft een NullReferenceException. Maak eerst het object aan met studenten[0] = new Student(); voor je de instantievariabele invult.

Samenvattende poster

Alles uit dit hoofdstuk op één A4.

Download de poster als pdf