Wat leer je in dit hoofdstuk?

Na dit hoofdstuk kan je:

uitleggen dat alles erft van System.Object

de ingebouwde methoden ToString, Equals en GetHashCode overriden

een abstracte klasse en abstracte methoden maken

het verschil tussen abstract en virtual/sealed uitleggen

een eigen exception ontwerpen en opwerpen

Staat er iets boven alle klassen?

C# houdt van objecten. Maak je een nieuw project, dan zie je meteen internal class Program. Alles is een klasse.

Ja: er is een oer-klasse, System.Object.

Alles en iedereen in C# erft ervan.

System.Object

De oer-klasse: System.Object

Alles in C# erft van System.Object: je eigen klassen, Random, Console, zelfs int en bool.

Schrijf je geen parent, dan erft je klasse impliciet van System.Object:

internal class Student : System.Object
{ }

Dat mag je ook zelf zo schrijven.

Tip

Om de klasse niet te verwarren met het begrip “object” spreken we steeds over System.Object.

Alles stamt af van System.Object

Alles stamt af van System.Object.

Vier ingebouwde methoden

Elke klasse heeft er meteen vier, van System.Object:

Equals()

zijn twee instanties gelijk?

GetHashCode()

een getal (hash); gelijke objecten hebben dezelfde hash, maar uniek is die niet

GetType()

het datatype (de klasse) van het object

ToString()

een string die het object voorstelt

Op zich redelijk nutteloos: pas als je ze zelf override, bewijzen ze hun nut.

GetType()

Student stud1 = new Student();
Console.WriteLine(stud1.GetType());      // StudentManager.Student
Console.WriteLine(stud1.GetType().Name); // Student

GetType() geeft de namespace plus het type. Eigenlijk krijg je een Type-object terug, met o.a. een Name-property.

StudentManager.Student
Student

ToString(): het werkpaardje

Console.WriteLine(stud1) roept stiekem stud1.ToString() aan. In System.Object staat ongeveer:

public virtual string ToString()
{
    return GetType().ToString();
}

Standaard krijg je dus het type: StudentManager.Student

De methode is virtual, dus je mag ze overriden

Drie van de vier zijn virtual

ToString, Equals en GetHashCode zijn virtual.

Die kan je dus overriden.

GetType() is bewust níet virtual: die moet altijd het echte type teruggeven

Heel wat .NET-bibliotheken rekenen erop dat je ze juist overschrijft. Console.WriteLine gebruikt bv. ToString

ToString() overriden

internal class Student
{
    public int Geboortejaar { get; set; }
    public string Voornaam { get; set; }

    public override string ToString()
    {
        return $"{Voornaam} ({Geboortejaar})";
    }
}

Nu toont Console.WriteLine(stud1) netjes:

Tim Dams (1981)

Tip

Ook tijdens het debuggen gebruikt Visual Studio ToString om je objecten samen te vatten in het watch-venster.

De afspraken van Equals()

if (stud1.Equals(stud2)) met als signatuur public virtual bool Equals(object o). Voor .NET moet Equals:

false geven als o null is

true geven als je een object met zichzelf vergelijkt

enkel true geven als stud1.Equals(stud2) én stud2.Equals(stud1) waar zijn

als 1 gelijk is aan 2, en 1 aan 3, dan ook 2 aan 3

Equals() overriden

Jij bepaalt wanneer twee objecten “gelijk” zijn.

public override bool Equals(object o)
{
    if (o is not Student temp) // null of geen Student? Niet gelijk.
        return false;
    return Geboortejaar == temp.Geboortejaar && Voornaam == temp.Voornaam;
}

Opmerking

o is not Student temp checkt het type én steekt o meteen als Student in temp. Een harde cast (Student)o zou crashen op null. Dat is-patroon zie je voluit in hoofdstuk 16.

Groene kronkel onder Equals?

Ook bij deze correcte Equals zet Visual Studio een groene kronkellijn:

CS8765: Nullability of type of parameter ‘o’ doesn’t match overridden member (possibly because of nullability attributes).

Tip

Dezelfde soort waarschuwing als CS8618 bij de properties in hoofdstuk 9. Visual Studio wil object? zien, met een vraagteken dat we nog niet gebruiken. Je code compileert en werkt gewoon: laat ze staan.

GetHashCode() overriden

Override je Equals, override dan ook GetHashCode.

gelijke objecten moeten dezelfde hash geven, belangrijk voor Dictionary en HashSet

public override int GetHashCode()
{
    return HashCode.Combine(Voornaam, Geboortejaar);
}

Tip

Geef dezelfde instantievariabelen mee die je in Equals vergelijkt. Vroeger combineerde je zelf hashes met ^ (XOR); HashCode.Combine doet het rekenwerk nu voor je.

Stagiair Steven

Steven overschreef GetHashCode al correct. Voor Equals gaf de A.I. dit:

public override bool Equals(object o)
{
    if (o is not Student temp)
        return false;
    return this == temp;
}
Student tim1 = new Student { Voornaam = "Tim", Geboortejaar = 1981 };
Student tim2 = new Student { Voornaam = "Tim", Geboortejaar = 1981 };
Console.WriteLine(tim1.Equals(tim2));

“Zelfde voornaam en geboortejaar, dus True”, verwacht hij.

Stagiair Steven: wat liep er mis?

False

Opmerking

this == temp bekijkt de instantievariabelen nooit. Student is een reference type, dus == vergelijkt hier referenties: tim1 en tim2 zijn twee aparte objecten in de heap. Zijn Equals doet nog exact hetzelfde als de standaardversie die hij overschreef.

Het moest Geboortejaar == temp.Geboortejaar && Voornaam == temp.Voornaam zijn.

ReferenceEquals()

Wijzen twee variabelen naar hetzelfde object in de heap? Gebruik de static methode van System.Object:

if (ReferenceEquals(student1, student3))
{
    Console.WriteLine("Beide bevatten zelfde referentie!");
}

Belangrijk

Waarom niet gewoon ==? De werking van == kan overschreven worden (zie Operator overloading in de appendix). Met ReferenceEquals ben je zeker.

Even moed verzamelen

“Ik ben nog niet helemaal mee… Vier methoden en wat beloofde compatibiliteit? Call me unimpressed.”

Begrijpelijk. We leggen puzzelstukjes klaar die straks samenkomen. Polymorfisme wordt onze doelpuntenmaker, en System.Object geeft telkens de perfecte voorzet.

Abstracte klassen

Te abstract voor een object

Een klasse is een blauwdruk. Maar geef mij eens de blauwdruk van “een meubel”. Een tafel? Een kast? Een zetel? Een bed?

meubel

geometrische figuur: een cirkel? een kubus?

Het concept is belangrijk, dus de klasse heeft een bestaansreden. Maar objecten ervan maken is nutteloos.

Abstracte klassen in C#

internal abstract class Dier
{
    public string Naam { get; set; }
}

Dier hetDier = new Dier(); geeft een foutboodschap

Je kan er wel van overerven: Paard : Dier, Wolf : Dier. Dan werkt Wolf wolfje = new Wolf();

Tip

abstract en sealed zijn tegenpolen: bij abstract moet je overerven, bij sealed mag het net niet.

Abstracte klasse of interface?

abstract lijkt beperkend, maar je krijgt een parent met de gedeelde functionaliteit van je children, die je zelf niet kan gebruiken.

Tip

In hoofdstuk 17 komen interfaces: enkel afspraken, geen gedeelde code of state. Heb je gedeelde code of instantievariabelen nodig, dan kies je een abstracte klasse. Lig er nu nog niet wakker van.

Abstracte methoden

Welk geluid maakt “een dier”? Onbekend. Geef enkel de signatuur, zonder accolades:

internal abstract class Dier
{
    public abstract string MaakGeluid();
}

Child-klassen moeten dit overriden:

internal class Paard : Dier
{
    public override string MaakGeluid()
    {
        return "Hinnikhinnik";
    }
}

De child vult het gat in.

abstract of virtual?

virtual

override mag

abstract

override moet

Een abstracte klasse is een soort sjabloon met gaten die de child-klassen nog moeten inkleuren.

Belangrijk

Heeft een klasse een abstracte methode of property, dan moet de klasse zelf ook abstract zijn. Anders kon je objecten maken met letterlijk stukken ontbrekende code.

Abstracte properties

internal abstract class Dier
{
    abstract public int MaxLeeftijd { get; }
}
internal class Olifant : Dier
{
    public override int MaxLeeftijd
    {
        get { return 100; }
    }
}

Een abstracte { get; } is geen auto-property: er staat bewust geen implementatie.

Je kiest meteen of ze read-only, write-only of allebei is:

{ get; } · { set; } · { get; set; }

Pong met abstract

Een gemeenschappelijke parent voor alles op het scherm, zonder te weten hoe het getekend wordt:

internal abstract class SpelObject
{
    public int X { get; set; }
    public int Y { get; set; }
    public abstract void TekenOpScherm();
}

Balletje erft hiervan: X en Y verdwijnen uit Balletje, en zijn TekenOpScherm wordt van virtual een override. Zijn eigen children kunnen die nog steeds overriden.

Pong: een scorebord

internal class ScoreBoard : SpelObject
{
    public ScoreBoard()
    {
        X = 5;
        Y = 5;
    }

    public int ScoreSpeler1 { get; set; }
    public int ScoreSpeler2 { get; set; }
    public override void TekenOpScherm()
    {
        Console.BackgroundColor = ConsoleColor.Yellow;
        Console.ForegroundColor = ConsoleColor.Black;
        Console.SetCursorPosition(X, Y);
        Console.Write($"{ScoreSpeler1} - {ScoreSpeler2}");
        Console.ResetColor();
    }
}

ScoreBoard vliegt niet rond en is geen Balletje, maar wel een SpelObject.

In het hoofdprogramma komen balletjes en scorebord samen in één List<SpelObject>. Scoort een speler:

score.ScoreSpeler2++;

Zelf exceptions maken

Zelf een exception opwerpen

Exceptions zijn ook maar klassen die erven van Exception, zoals NullReferenceException.

static int ResultaatBerekening(int getal)
{
    if (getal != 0)
        return 100 / getal;
    else
        throw new DivideByZeroException("BOEM. ZWART GAT!");
}

static void Main(string[] args)
{
    try
    {
        Console.WriteLine(ResultaatBerekening(0));
    }
    catch (DivideByZeroException e)
    {
        Console.WriteLine(e.Message);
    }
}

Met throw gevolgd door een exception-object (new) werp je zelf een uitzondering op.

BOEM. ZWART GAT!

Een eigen exception ontwerpen

Maak een klasse die erft van Exception:

internal class Timception : Exception
{
    public override string ToString()
    {
        string extrainfo = "Exception Generated by Tim Dams:\n";
        return $"{extrainfo}{base.ToString()}";
    }
}

Met base.ToString() komt ook de foutboodschap van het parent-gedeelte mee.

De drie standaard-constructors

Een afspraak die alle .NET-exceptions volgen (VS stelt ze vaak voor als quickfix):

internal class Timception : Exception
{
    public Timception() { }
    public Timception(string message) : base(message) { }
    public Timception(string message, Exception inner)
        : base(message, inner) { }
}

leeg: de default constructor

een eigen Message, uit te lezen met e.Message

een onderliggende fout, bewaard in e.InnerException

Je eigen exception opwerpen

static void Main(string[] args)
{
    try
    {
        TimsMethode();
    }
    catch (Timception e)
    {
        Console.WriteLine(e.ToString());
    }
}
static public void TimsMethode()
{
    //doe dingen
    //"when suddenly: a wild exception appears"
    throw new Timception();
}

throw gevolgd door een object van het type uitzondering dat je wil opwerpen.

Waarschuwing

Zonder de constructor met een string kan je geen boodschap meegeven: new Timception("...") compileert dan niet.

throw versus throw e

Waarschuwing

Gooi je een opgevangen exception opnieuw door, gebruik dan throw; (zonder variabele):

catch (Exception e)
{
    //...iets doen, bv. loggen...
    throw;      // GOED: behoudt de stack trace
    //throw e;  // SLECHT: wist de stack trace
}

throw e; wist de stack trace: het lijkt alsof de fout op die plek ontstond, en de echte oorzaak is veel moeilijker te vinden.

Conclusie

Alles erft van System.Object; ToString, Equals en GetHashCode zijn virtual, GetType niet

Override ToString voor leesbare objecten; override Equals + GetHashCode samen

Een abstract klasse kan je niet instantiëren, maar dient als basis voor children

Een abstracte methode zonder body moet de child overriden

Eigen exceptions erven van Exception; gebruik throw; om de stack trace te bewaren

Tip

Volgende halte: compositie en aggregatie: de “heeft-een”-relatie.

Meer weten

Kennisclips

Oefeningen H14 · 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 twee studenten vergelijken op hun naam. De Equals-override doet z’n werk, maar bij het gebruik van Student-objecten als sleutel in een Dictionary of HashSet lopen dingen mis. Wat ontbreekt er?

internal class Student
{
    public string Voornaam { get; set; }
    public int Geboortejaar { get; set; }

    public override bool Equals(object o)
    {
        if (o is not Student temp)
            return false;
        return Geboortejaar == temp.Geboortejaar && Voornaam == temp.Voornaam;
    }
}

Wie Equals override, moet ook GetHashCode override. Twee gelijke objecten horen dezelfde hashcode terug te geven, en daar rekenen Dictionary en HashSet op.

Samenvattende poster

Alles uit dit hoofdstuk op één A4.

Download de poster als pdf