Zie Scherp Scherper - Hoofdstuk 16
Na dit hoofdstuk kan je:
uitleggen wat polymorfisme is en hoe late binding werkt
child-objecten in een variabele van het parent-type bewaren (upcasting)
lijsten van een basistype vullen met allerlei child-objecten
polymorfisme inzetten om code eenvoudiger te maken
de is- en as-keywords en pattern matching gebruiken
Equals veilig overriden, samen met GetHashCode
Polymorfisme = poly (meerdere) + morfisme (vormen): meerdere vormen.
Het laat toe om child-objecten te behandelen als objecten van hun parent-klasse
Het zorgt dat virtual/override echt werkt
Opmerking
We bekijken het meest voorkomende soort: polymorfisme via overerving. Method overloading (hoofdstuk 7) heet ook een vorm van polymorfisme, maar daar trek je je nu niets van aan.
De variabelen zijn van het type Dier, maar elk object roept zijn eigen MaakGeluid op.
someAnimal is een Dier-variabele. Waarom draait toch de Varken-versie?
De variabele kan enkel wat in Dier beschreven staat
Welke override draait, kiest C# pas tijdens de uitvoer, op basis van het echte object in de heap
Dat heet late binding (dynamic dispatch)
Het werkt enkel omdat de methode virtual of abstract is
Belangrijk
Via een Dier-variabele kijkt C# nu enkel naar het type van de variabele. Krijg je CS0114, schrijf dan override (het keyword new uit de waarschuwing heb je niet nodig).
Een child toewijzen aan een parent-variabele heet upcasting. Dat gaat automatisch, tot zelfs:
Via mijnObject kan je enkel wat System.Object kent (ToString, Equals, …). Geluid maken lukt niet.
Belangrijk
De compiler kijkt naar het type van de variabele, niet naar het echte object. Terug naar Varken gaan heet downcasting: dat is expliciet, foutgevoeliger, en doe je veilig met is en as.
Een lijst van het basistype, gevuld met child-objecten:
Objecten als één geheel gebruiken, zonder dat ze allemaal van hetzelfde type hoeven te zijn.
Polymorfisme werkt enkel mooi als een child zich echt kan gedragen als zijn parent, zonder vreemde verrassingen: het Liskov substitution principle.
Het klassieke tegenvoorbeeld: een Vierkant die overerft van Rechthoek klopt taalkundig, maar geeft brokkelige code.
Kan elk child overal de plaats van zijn parent innemen?
Bewaar een referentie in een variabele van het basistype, en gebruik het object als “zichzelf” wanneer nodig: je code wordt een pak eenvoudiger.
Vaak weet je niet op voorhand wat er in je lijst komt. In een List<Person> mogen dankzij polymorfisme ook een Bakker of een Student terechtkomen.
Een nieuw soort balletje maak je door over te erven van Balletje en de juiste methode te override’n:
Twee gewone balletjes en elk van de drie nieuwe types. De lus die verderop Update en TekenOpScherm aanroept, moet niet aangepast worden.
internal class EersteMinister
{
public MinisterVanMilieu Jansens {get;set;}
= new MinisterVanMilieu();
public MinisterBZ Ganzeweel {get;set;}
= new MinisterBZ();
public MinisterVanEconomie VanCent {get;set;}
= new MinisterVanEconomie();
public void Regeer()
{
Jansens.VerhoogBosSubsidies();
Jansens.OpenOnderzoek();
Jansens.ContacteerGreenpeace();
Ganzeweel.VervangAmbassadeur();
Ganzeweel.RoepTroepenmachtTerug();
VanCent.InjecteerGeldInMarkt();
}
}Elke minister heeft totaal andere publieke methoden.
Belangrijk
De EersteMinister moet elk departement van binnen kennen. Dat vloekt tegen abstractie: verandert er iets in een ministerklasse, dan moet je ook de EersteMinister aanpassen.
internal abstract class Minister
{
abstract public void Adviseer();
}
internal class MinisterVanMilieu : Minister
{
public override void Adviseer()
{
VerhoogBosSubsidies();
OpenOnderzoek();
ContacteerGreenpeace();
}
private void VerhoogBosSubsidies() { ... }
private void OpenOnderzoek() { ... }
private void ContacteerGreenpeace() { ... }
}Het leven van de premier wordt plots véél makkelijker:
Hij moet niet meer weten wat elke minister binnenin doet.
List<Minister>Met een lijst hoeft hij zelfs de “namen” van zijn ministers niet meer te kennen:
internal class EersteMinister
{
public List<Minister> AlleMinisters {get;set;} = new List<Minister>();
public EersteMinister()
{
AlleMinisters.Add(new MinisterVanMilieu());
AlleMinisters.Add(new MinisterBZ());
AlleMinisters.Add(new MinisterVanEconomie());
}
public void Regeer()
{
foreach (Minister minister in AlleMinisters)
{
minister.Adviseer();
}
}
}En wie zei dat het regeren moeilijk was?! (Merk op: ook compositie.)
Polymorfisme vond Steven maar vaag. De A.I. gaf hem “iets dat zeker werkt” voor in Regeer:
De code werkt. Toch is dit precies wat je met polymorfisme wil vermijden. Waarom?
Opmerking
Steven bouwde met de hand na wat polymorfisme gratis doet. Elke Minister heeft Adviseer, dus volstaat één regel: minister.Adviseer();. C# kiest zelf de juiste versie op basis van het echte object.
Zijn type-checks zijn bovendien broos: voeg je morgen een MinisterVanDigitalisering toe, dan vergeet je gegarandeerd ergens een else if en valt die minister stilletjes weg.
is en as keywordsis heeft twee operanden en geeft een bool: links het object, rechts een datatype.
Opmerking
is kan ook testen of een object een bepaalde interface heeft: zie het volgende hoofdstuk.
In een lijst van voertuigen enkel iets doen met de auto’s:
Student is een child van Mens. Zit er in fritz echt een Student?
Zat er een gewone Mens in, dan crasht je programma:
Belangrijk
Een InvalidCastException. De compiler ziet die fout niet aankomen: in een Mens-variabele kan een Student zitten. Pas tijdens de uitvoer blijkt of dat zo is.
as zegt: “probeer dit object te converteren. Lukt het niet, geef dan null in plaats van een uitzondering.”
Belangrijk
as werkt enkel op reference types (objecten en interfaces). int getal = mijnObject as int; compileert niet.
Tip
Wil je enkel weten of iets van een type is: is. Wil je het object daarna gebruiken: as en dan op null testen. Of de kortere vorm met pattern matching, verderop.
Steven wil de naam tonen als het eerste object een Student is. De A.I. gaf hem dit:
“Eerst is, dan netjes as. Dat is toch veilig?” Toch crasht het soms met een NullReferenceException. Hoe kan dat?
Opmerking
Steven test met is de verkeerde variabele: hij test eersteObject, maar cast en gebruikt tweedeObject. Is het eerste een Student en het tweede niet, dan is de if wel true, maar wordt student via as gewoon null, en crasht student.Naam.
De controle en het gebruik moeten over dezelfde variabele gaan.
is geeft een bool terug; as geeft de referentie als het type klopt, anders null.Sinds C# 7 doe je de is-controle en het omzetten in één stap. In plaats van:
schrijf je korter en veiliger:
Tip
In dezelfde geest schrijf je null-controles vaak als jos is not null in plaats van jos != null. Beide werken.
is en as krijgen een plaats op lijn 4, bij de relationele operators:
Logische NIET: !
Delen en vermenigvuldigen: *, /, %
Optellen en aftrekken: +, -
<, <=, >, >= én is, as
Gelijkheid: ==, !=
Logische EN: &&
Logische OF: ||
De Equals uit hoofdstuk 14, maar zonder is:
Waarschuwing
Is o geen Student, dan krijg je een InvalidCastException. Is o gelijk aan null, dan crasht de tweede lijn met een NullReferenceException. Controleer dus eerst, en cast dan pas.
Met pattern matching kan het nóg korter. Dat zie je vandaag het vaakst:
Belangrijk
Wie Equals overridet, moet ook GetHashCode overriden. Twee objecten die gelijk zijn volgens jouw Equals, moeten dezelfde hashcode geven. Anders werken ze niet correct als key in een Dictionary of in een HashSet: elementen lijken dan te “verdwijnen”.
Geef aan HashCode.Combine dezelfde instantievariabelen mee als in Equals:
== vergelijkt bij objecten standaard de referenties: twee aparte objecten met dezelfde inhoud zijn dus niet gelijk
Equals Door Equals te overriden bepaal jij gelijkheid op basis van de inhoud
Tip
Sinds C# 9 regelen record-types dit automatisch: public record Student(string Voornaam, int Geboortejaar); genereert zelf Equals, GetHashCode én ToString. We doen het hier met de hand om te begrijpen wat eronder zit.
Tip
In een lijst vol allerhande types vraag je met is of een element van een bepaald type is, en zet je het met as tijdelijk om. Zo kan het meer dan toen het vermomd zat als zijn basistype.
Polymorfisme behandelt child-objecten als hun parent; late binding kiest de juiste override
Zonder virtual/abstract en override geen late binding (CS0114)
Upcasting gaat vanzelf; voor downcasting gebruik je is en as
Een List<Basistype> met child-objecten maakt code flexibel en kort (de premier!)
is toetst een type, as zet veilig om (null bij mislukking), pattern matching doet beide
Override Equals voor vergelijking op inhoud, en vergeet GetHashCode niet
Tip
Volgende halte: interfaces, contracten die klassen beloven na te komen.
Kennisclips
Een korte zoek-de-fout, om zo kritisch mogelijk naar code te leren kijken.
Onderstaande C#-code wil dat elk dier zijn eigen geluid maakt. Wat loopt er mis?
Opmerking
MaakGeluid in Dier is niet virtual (of abstract), en zonder virtual mag je niet override’n. Deze code compileert dus niet eens. Maak er in de parent public virtual string MaakGeluid() (of abstract) van, dan zorgt late binding ervoor dat de Varken-versie draait.
Alles uit dit hoofdstuk op één A4.