Zie Scherp Scherper - Hoofdstuk 10
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
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.
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 |
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)
De heap is een grote speelplaats; de stack het kleine bankje naast de zandbak.
De waarde zelf staat in de stack: int, double, bool, char, … en enums.
= kopieert de waarde. Pas je daarna een van beide aan, dan merkt de andere daar niets van.
Een methode krijgt een kopie van een value type:
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.
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
stud wijst nog naar geen object.new Student() maakt het object in de heap.stud.b = a kopieert het adres, niet het object. Beide wijzen nu naar hetzelfde object; “Queen” ben je kwijt.
Belangrijk
Ook de value-type-properties en instantievariabelen van een object staan in de heap: het hele object wordt daar bewaard.
Wil je dat tweede object houden, zorg dan voor minstens één referentie:
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.
Steven wil elke verwerkte student bijhouden. De A.I. gaf hem een array:
“Na elke ronde is tijdelijk toch weg en ruimt de GC dat op”, denkt hij. Waarom loopt het geheugengebruik toch op?
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.
string is een reference type, maar gedraagt zich vaak als een value type omdat het immutable is:
Tip
ToUpper() wijzigt de originele tekst niet, maar maakt een nieuwe. Vergeet je de toewijzing (naam.ToUpper();), dan verandert er niets aan naam.
Een methode krijgt bij een object een kopie van de referentie, niet van het object.
De methode krijgt het adres, dus aanpassingen raken het origineel:
Een methode mag ook een object teruggeven:
m3 meet 52 graden en is opgemeten door Lieven Scheire Junior.
Baby’s zijn kleine mensjes, dus een Mens kan een nieuwe Mens teruggeven:
Tip
Een interessante oefening: teken deze code uit in de stack en de heap, met alle referenties.
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.
Je benadert een object dat er niet is.
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.
Een methode mag bewust null teruggeven, bv. als ze niets vond:
Opmerking
Deze loop zoekt verder, ook na een match. Dat kan sneller, maar we houden het hier bewust eenvoudig.
De baby wordt nooit groter dan de grootste ouder:
Lukt de voortplanting niet, dan geeft de methode null terug.
Een namespace voorkomt naamconflicten tussen klassen:
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 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.
Zo zeg je:
“Beste C#, vind je een klasse niet in dit project, kijk dan zeker in de System.Diagnostics-bibliotheek”
Schrijf de klassenaam en klik op het lampje in de rand. VS biedt aan om:
using bovenaan je bestand te zettenBestaat de klasse nog niet, dan maakt Generate type ze voor je aan.
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
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.
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.
Geef 0 of iets anders dan een getal in, en je programma toont een hoop tekst met het woord “Exception” en sluit af.
In het try-blok staat code waar een uitzondering kan optreden
Het catch-blok, meteen erna, verwerkt de uitzondering
Typt de gebruiker tekst of een kommagetal, dan treedt een FormatException op. Het programma toont de boodschap en gaat verder na het catch-blok.
Je kan zelf een uitzondering opwerpen:
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.
| Klasse | Omschrijving |
|---|---|
Exception |
basisklasse |
SystemException |
kan mogelijk verholpen worden |
IndexOutOfRangeException |
index te groot of te klein |
NullReferenceException |
object zonder new |
Elke specifieke exception is ook een Exception. Daarom vangt catch (Exception e) ze allemaal op.
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”.
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.
Steven wil foute invoer en andere fouten apart afhandelen. De A.I. gaf hem dit:
“Dubbel beveiligd”, denkt hij. Waarom compileert dit niet?
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.
De online .NET-documentatie vertelt het je. Bij Int32.Parse staat een sectie Exceptions: welke uitzondering, en wanneer.
| Element | Omschrijving |
|---|---|
Message |
foutmelding in eenvoudige taal |
StackTrace |
methoden die de exception doorgaven |
TargetSite |
methode die de exception gaf |
ToString() |
type, Message en StackTrace |
Belangrijk
Stuur deze info niet zomaar naar de gebruiker: ze kan gevoelige details bevatten die kwaadwillige gebruikers misbruiken om bugs te vinden.
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.
Een methode downloadt een lijst urls. De tweede url bevat een fout:
Bij de eerste fout stopt de hele methode. Enkel zinvol als je de info van alle urls nodig hebt.
Een foute url wordt overgeslagen, de rest gaat door.
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.
Kennisclips
Een korte zoek-de-fout, om zo kritisch mogelijk naar code te leren kijken.
Onderstaande C#-code wil de naam van een student tonen, maar crasht met een NullReferenceException. Wat loopt er mis?
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.
Alles uit dit hoofdstuk op één A4.