Wat leer je in dit hoofdstuk?

Na dit hoofdstuk kan je:

uitleggen waarom methoden code herbruikbaar en leesbaar maken

zelf een methode schrijven met een returntype en return

parameters doorgeven en het verschil met by value begrijpen

methoden nesten en oneindige methode-lussen herkennen

inschatten hoe groot een methode mag zijn

named en optionele parameters en overloading gebruiken

met ///-commentaar en IntelliSense efficiënter werken

Luiheid als deugd

“I will always choose a lazy person to do a difficult job, because he will find an easy way to do it.”

Bill Gates

We jagen op zo weinig mogelijk code met zoveel mogelijk rendement. Loops waren een eerste stap, methoden de volgende.

Tip

Bestond Console.WriteLine niet, dan moest je telkens tientallen lijnen interne code overtypen. Wees blij dat methoden bestaan.

Foto: Jennifer Jacquemart, Europese Commissie, CC BY 4.0, via Wikimedia Commons

Wat is een methode?

Een blok code dat een specifieke taak uitvoert

( ) Herkenbaar aan de ronde haakjes achteraan, al dan niet met parameters

Je gebruikt ze al sinds les 1: elke Console.WriteLine() is een methode-aanroep

Nieuw: we gaan nu zelf methoden definiëren, niet enkel bestaande gebruiken.

Methode-syntax

static returntype MethodeNaam(parameters)
{
    //code van de methode
}

De eerste lijn is de methode-signatuur. Die vertelt alles wat je moet weten om met de methode te werken: returntype, naam en eventuele parameters.

De onderdelen van een methode-signatuur.

Tip

Vergeet static voorlopig: beschouw het als een verplicht toverwoord. Waarom het er staat, zie je in hoofdstuk 11.

Een eenvoudige methode

static void ToonTitel()
{
    Console.WriteLine("Timsoft XP");
}

Aanroepen, eender waar:

ToonTitel();
Timsoft XP

Verandert de titel ooit? Eén plek aanpassen volstaat.

Een eenvoudige methode: de flow

De flow van de aanroep.

Main is ook een methode

Een console-applicatie heeft een startpunt nodig, en dat is Main. Verder is het een methode zoals alle andere. Wat doet dit?

static void Main(string[] args)
{
    Console.WriteLine("Ik zit vast!");
    Main(args);
}

Main roept zichzelf op, en die aanroep doet exact hetzelfde. Eindeloos “Ik zit vast!” tot het programma crasht. Waarom precies zie je straks bij de oneindige methode-lussen.

Tip

Via string[] args geef je opstartparameters mee aan je programma (denk aan explorer.exe google.com). Meer daarover in hoofdstuk 8.

Returntype en return

void betekent dat een methode niets teruggeeft. Wil je wel iets terug, dan zet je het type vooraan:

static string VerkrijgAuteurNaam()
{
    return "Tim Dams";
}

Het returntype (string) belooft wat eruit komt, return levert het.

Het resultaat opvangen

Vang het resultaat op in een variabele van hetzelfde type:

string auteur = VerkrijgAuteurNaam();

Of gebruik het meteen:

Console.WriteLine($"Auteur: {VerkrijgAuteurNaam()}");
Auteur: Tim Dams

Vang je het niet op, dan is het weg.

Een uitgewerkte methode

static int FaculteitVan5()
{
    int resultaat = 1;
    for (int i = 1; i <= 5; i++)
    {
        resultaat *= i;
    }
    return resultaat;
}

Aanroepen:

Console.WriteLine($"Faculteit van 5 is {FaculteitVan5()}");
Faculteit van 5 is 120

void: niets opvangen

static void ToonVersie()
{
    Console.WriteLine("Dit is versie 8.31");
}

Een void-methode geeft niets terug. Deze twee mogen dus niet:

string result = ToonVersie();      // FOUT
Console.WriteLine(ToonVersie());   // FOUT

return mag overal staan

return sluit de methode meteen af, ook midden in een switch (dan heb je geen break meer nodig):

static string WindRichting()
{
    Random r = new Random();
    switch (r.Next(0, 4))
    {
        case 0: return "noord";
        case 1: return "oost";
        case 2: return "zuid";
        case 3: return "west";
    }
    return "onbekend";
}

Die laatste lijn wordt nooit bereikt, en toch vereist C# ze.

Not all code paths return a value

Laat je die laatste lijn weg:

static string WindRichting()
{
    Random r = new Random();
    switch (r.Next(0, 4))
    {
        case 0: return "noord";
        case 1: return "oost";
        case 2: return "zuid";
        case 3: return "west";
    }
}

‘WindRichting()’: not all code paths return a value

Er is een weg door je methode waarop het einde bereikt wordt zonder return. De compiler weet niet dat r.Next(0, 4) enkel 0 tot en met 3 kan geven. Zonder return eindigen mag enkel bij void.

Parameters doorgeven

Parameters: iets meegeven

Je kent het al: bij Console.WriteLine("Hallo") geef je één parameter mee.

Zelf maken: per parameter een type en een naam, tussen de haakjes van de signatuur:

static returntype MethodeNaam(type parameter1, type parameter2)

Formele parameter: in de definitie. Een type plus een naam die je zelf kiest. Binnen de methode werk je ermee als met een gewone variabele.

Actuele parameter: in de aanroep. De waarde die je echt meegeeft.

Methoden met formele parameters

FaculteitVan5 kan enkel 5. Veralgemeen ze:

static int BerekenFaculteit(int grens)
{
    int resultaat = 1;
    for (int i = 1; i <= grens; i++)
        resultaat *= i;
    return resultaat;
}

Aanroepen:

int resultaat = BerekenFaculteit(5);  // 120

Tip

De parameternaam (grens) hoeft niet gelijk te zijn aan de meegegeven variabele. Enkel de waarde reist mee.

Wat zit er in grens?

static int BerekenFaculteit(int grens)

BerekenFaculteit(4);

int getal = 3;
BerekenFaculteit(getal);

for (int i = 1; i <= 5; i++)
{
    Console.WriteLine(BerekenFaculteit(i));
}
aanroep grens resultaat
BerekenFaculteit(4) 4 24
BerekenFaculteit(getal) 3 6
BerekenFaculteit(i) in de lus, als i 5 is 5 120

Volgorde van parameters

De eerste waarde gaat naar de eerste parameter, de tweede naar de tweede.

static void ToonDeling(double teller, double noemer)
{
    Console.WriteLine(teller / noemer);
}

Aanroepen:

ToonDeling(3.5, 2.1);   // 1,6666666666666665
ToonDeling(2.1, 3.5);   // 0,6

Bij verschillende types helpt VS je wel: ToonInfo(37, "Tim") compileert gewoon niet.

By value

Parameters gaan standaard by value: de methode krijgt een kopie.

static void JaartjeOuder(int leeftijd)
{
    leeftijd++;
    Console.WriteLine($"Hoera. Je bent {leeftijd} jaar geworden.");
}
static void Main(string[] args)
{
    int mijnLeeftijd = 40;
    Console.WriteLine($"Je bent {mijnLeeftijd} jaar.");
    JaartjeOuder(mijnLeeftijd);
    Console.WriteLine($"Je bent {mijnLeeftijd} jaar.");
}
Je bent 40 jaar.
Hoera. Je bent 41 jaar geworden.
Je bent 40 jaar.

By value: een kopie

De methode werkt op een kopie, dus mijnLeeftijd blijft 40.

By reference geeft het origineel mee. In C# vraag je dat expliciet, met ref of out. Je zag out al bij int.TryParse(Console.ReadLine(), out int leeftijd).

Stagiair Steven

Steven laat de A.I. een methode schrijven die een getal verdubbelt:

static int Verdubbel(int getal)
{
    return getal * 2;
}

Gebruik:

int punten = 5;
Verdubbel(punten);
Console.WriteLine($"Punten: {punten}");

“Ik roep Verdubbel op, dus punten is nu 10”, zegt hij zelfzeker. Wat verschijnt er op het scherm?

Stagiair Steven: wat liep er mis?

static int Verdubbel(int getal)
{
    return getal * 2;
}

Gebruik:

int punten = 5;
Verdubbel(punten);
Console.WriteLine($"Punten: {punten}");
Punten: 5

Er verschijnt Punten: 5.

De methode werkt op een kopie, maar de echte fout is dat Steven het resultaat nergens opvangt. Verdubbel(punten); berekent wel 10, maar dat getal gaat verloren.

De code compileert zonder klacht, dus kreeg hij geen enkele waarschuwing.

punten = Verdubbel(punten);

Methoden combineren

Methoden nesten

Een methode mag andere methoden aanroepen:

static void SchrijfNaam()
{
    SchrijfT();
    SchrijfI();
    SchrijfM();
}
Tim

Aanroepen van methoden uit methoden.

Tip

De volgorde waarin je je methoden in je bestand schrijft, maakt niets uit. Bij variabelen is dat wél anders: die declareer je voor je ze gebruikt.

Hoe groot mag een methode zijn?

Er bestaat geen regel over het aantal lijnen, wel een goede vuistregel:

Een methode doet één ding.

Kan je in één zin uitleggen wat ze doet? Goed bezig.

Krijg je de naam niet bedacht zonder er “En” in te stoppen (LeesInEnBerekenEnToon), dan zitten er eigenlijk drie methoden in.

Tip

Lukt die ene zin niet, dan splits je best op. In de kennisclip “Goede methoden schrijven” ga ik hier dieper op in.

Oneindige methode-lussen

static void SchrijfNaam()
{
    SchrijfNaam();
    Console.WriteLine("Klaar?");
}

Je krijgt een leeg scherm (“Klaar?” wordt nooit bereikt) en daarna een crash met een StackOverflowException.

Elke aanroep legt er een frame bij op de stack, en er komt er nooit een af.

Opmerking

Iedere aanroep neemt een stukje geheugen in op de zogenaamde stack, en die raakt vol. Wat die stack precies is, lees je in hoofdstuk 10.

Lokale functies: niet doen

Sinds C# 7 mag een methode in een andere methode staan, maar als beginner doe je dat niet:

static void Main(string[] args)
{
    TimVindtDitNietLeuk();

    static void TimVindtDitNietLeuk() // NIET DOEN
    {
        Console.WriteLine("Doe dit niet!");
    }
}

Zo’n lokale functie kan je nergens anders aanroepen. Zet je methoden gewoon naast Main.

Belangrijk

Niet enkel een kwestie van smaak: op een vaardigheidsproef kost een methode in een methode je 3 punten.

Documentatie met ///

/// <summary>
/// Berekent de macht van een getal.
/// </summary>
/// <param name="grondtal">Het getal dat je verheft</param>
/// <param name="exponent">De exponent</param>
static int Macht(int grondtal, int exponent)
{
    //...
}

Typ /// boven een methode en VS maakt het skelet. Jij vult enkel de uitleg per parameter in.

Schrijf je documentatie best in het Engels, niet zoals in dit voorbeeld dus.

Bestaande bibliotheken verkennen

Wat kan een bibliotheek eigenlijk?

Typ Console. en wacht even: IntelliSense toont alles wat die bibliotheek kan.

kubus = methode

Engelse sleutel = eigenschap

bliksem = event

Lijst weg? Ctrl+Spatie. Verschijnt er niets, dan heb je waarschijnlijk een schrijffout gemaakt.

De parameters van een methode zien

Dit soort popups bevat een schat aan informatie.

Stop met typen na het eerste ronde haakje: IntelliSense toont alle manieren om de methode aan te roepen (de overloads), doorbladeren doe je met de pijltjes

Popup weg? Ctrl+Shift+Spatie

Cursor op de methode en F1 opent de online documentatie

Tip

Dit werkt ook voor je eigen methoden. Schreef je er ///-commentaar boven, dan staat jouw uitleg mee in die popup.

Herbruikbare input

Komt deze constructie vaak voor?

Console.WriteLine("Geef leeftijd");
int leeftijd = int.Parse(Console.ReadLine());

Verhuis ze naar een methode:

static int VraagInt(string zin)
{
    Console.WriteLine(zin);
    return int.Parse(Console.ReadLine());
}

Aanroepen:

int leeftijd = VraagInt("Geef leeftijd");

Je Main blijft net en leesbaar.

Geavanceerde methode-technieken

Named parameters

Twee parameters van hetzelfde type verwisselen? Dat compileert gewoon:

static void ToonPunten(string vak, int score, string student) { }

ToonPunten("Steven", 14, "Programmeren");  // stille bug

Geef daarom expliciet aan welke waarde bij welke parameter hoort:

ToonPunten(student: "Steven", score: 14, vak: "Programmeren");

Geef je alle parameters een naam, dan maakt de volgorde niets meer uit.

Named en gewoon mengen

Mengen mag, maar dan moet elke named parameter op zijn eigen plaats blijven staan.

Dit mag:

ToonPunten("Programmeren", 14, student: "Steven");       // ok
ToonPunten(vak: "Programmeren", 14, student: "Steven");  // ok

Dit mag niet:

ToonPunten(student: "Steven", "Programmeren", 14);       // fout
ToonPunten("Programmeren", student: "Steven", 14);       // fout

Waarschuwing

Named argument ‘student’ is used out-of-position but is followed by an unnamed argument. In beide foute lijnen staat student niet op de derde plaats, terwijl er daarna nog naamloze parameters volgen.

Optionele parameters

Geef een default waarde mee. Die parameters staan altijd achteraan.

static void ToonFactuur(string klant, int korting = 0, int btw = 21)

Aanroepen:

ToonFactuur("Tim", 10, 6);
ToonFactuur("Tim", 10);   // btw = 21
ToonFactuur("Tim");       // korting = 0, btw = 21

Weglaten mag enkel van achter naar voor.

Optionele parameters: de valkuil

Je wil enkel de btw op 6 zetten:

ToonFactuur("Tim", 6);

Zonder naam landt de 6 in korting. Met btw: 6 blijft korting op zijn default.

Dat compileert zonder klacht, je merkt het pas aan de output. Gebruik een named parameter: ToonFactuur("Tim", btw: 6);

Wat is method overloading?

Method overloading: dezelfde methodenaam meerdere keren definiëren, telkens met een andere parameterlijst (een ander type en/of aantal parameters).

Je gebruikt het al: Console.WriteLine(42), Console.WriteLine("Hallo") en Console.WriteLine() zijn drie verschillende versies van WriteLine. Daarom toonde IntelliSense je de overloads.

De compiler kiest de juiste versie op basis van de parameters die je meegeeft.

Method overloading

Drie versies van Verdubbel:

// versie 1: int
static int Verdubbel(int getal)
{
    return getal * 2;
}
// versie 2: double
static double Verdubbel(double getal)
{
    return getal * 2;
}
// versie 3: string
static string Verdubbel(string tekst)
{
    return tekst + tekst;
}
Verdubbel(21);    // int    → versie 1 → 42
Verdubbel(2.5);   // double → versie 2 → 5
Verdubbel("ha");  // string → versie 3 → haha

Overloading en het returntype

static int Verdubbel(int getal)
{
    return getal * 2;
}

static double Verdubbel(int getal) //MAG NIET
{
    return getal * 2.0;
}

Belangrijk

Het returntype mág verschillen, maar telt niet mee. Twee versies die enkel in returntype verschillen geven already defines a member called ‘Verdubbel’ with the same parameter types.

Overloaden op het aantal parameters

Overloaden kan ook op het aantal parameters:

static void ToonTitel(string naam)
{
    Console.WriteLine($"*** {naam} ***");
}

static void ToonTitel()
{
    ToonTitel("Timsoft XP");
}

De versie zonder parameters hergebruikt de andere. Zo werkt ook Console.WriteLine(): zonder parameters toont die een lege lijn.

Overload enkel als de versies hetzelfde doen. BerekenOpp(lengte, breedte) naast BerekenOpp(straal) compileert, maar wie je code leest, moet raden wat er berekend wordt.

Wanneer de compiler niet kan kiezen

static void ToonPrijs(int bedrag, double korting) { }   // versie A
static void ToonPrijs(double bedrag, int korting) { }   // versie B

ToonPrijs(100, 5.5)

versie A wordt uitgevoerd

ToonPrijs(99.9, 5)

versie B wordt uitgevoerd

ToonPrijs(100, 5)

fout: the call is ambiguous

ToonPrijs(99.9, 5.5)

fout: geen enkele versie past

Belangrijk

Bij ToonPrijs(100, 5) passen A en B even goed, en dan kiest de compiler niet. Jij maakt het duidelijk: ToonPrijs(100, 5.0) of ToonPrijs(100.0, 5). Hoe hij bij twijfel tussen types wél kiest (de betterness rule) is verdiepingsstof.

Methoden debuggen: step in

Herinner je de debugknoppen uit hoofdstuk 4? Eén lieten we toen liggen: step in.

Step over versus step in.

Step over voert de methode wel uit, maar springt naar de volgende lijn van Main

Step in brengt je in je eigen methode, waar je lijn per lijn verder stapt

Methoden in actie: verdeel en heers

Een groot probleem splits je op in kleine methoden, elk met een duidelijke taak:

IN

parameters

ACTIE

UIT

returntype

Teken eerst een flowchart. Elk blokje wordt een methode. Daarna rijg je ze aan elkaar in een hoofdmethode.

Tip

Zo blijft je Main kort en lees je je programma als een inhoudstafel.

Conclusie

Een methode is een herbruikbaar codeblok: minder fouten, betere leesbaarheid, en ze doet één ding

void geeft niets terug; anders gebruik je return met het juiste type, en vang je het resultaat ook op

Parameters gaan by value (een kopie); de volgorde telt

Named en optionele parameters en overloading maken je methoden flexibel

Met /// en IntelliSense werk je sneller en met betere documentatie

Tip

Volgende halte: arrays, om vele waarden samen in één variabele bij te houden.

Meer weten

Kennisclips

Alle kennisclips van H7: 8 korte clips over de werking van methoden, returntypes, parameters, by value, return of WriteLine, combineren, de stack en bibliotheken

Oefeningen H7 · 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#-methode wil de grootste van twee getallen teruggeven, maar de compiler weigert ze met de fout “Not all code paths return a value”. Wat ontbreekt er?

static int Grootste(int a, int b)
{
    if (a > b)
    {
        return a;
    }
    if (b > a)
    {
        return b;
    }
}

Opmerking

Wanneer a en b gelijk zijn, is geen van beide if-condities waar en bereikt de code het einde van de methode zonder een return. Een methode met returntype int moet op élk pad iets teruggeven. Voeg op het einde bijvoorbeeld return a; toe, of vervang de tweede if door een else.

Samenvattende poster

Alles uit dit hoofdstuk op één A4.

Download de poster als pdf

Showcases

Afhankelijk van de stand van de maan, de goesting en de tijd maken we één of meerdere van deze showcases in de les. Of niet :)

Showcase: Avenger Mission Planner

Nick Fury managet de Avengers. Elke fase van een missie is een methode:

Methode IN UIT
Alarm niets moeilijkheidsgraad (int, 0 = geen alarm)
MissieVoorbereiden graad naam held (string)
MissieUitvoeren graad + held missiepercentage (int)
Evaluatie percentage + held niets (void)

Avenger Mission Planner: de manager

Een MissieManager rijgt de losse methoden aan elkaar:

static void MissieManager(int moeilijkheidsgraad)
{
    string held = MissieVoorbereiden(moeilijkheidsgraad);
    int percentage = MissieUitvoeren(moeilijkheidsgraad, held);
    Evaluatie(percentage, held);
}

Tip

Uitbreiding: bij een alarm waarschuw je ook DC via DCWaarschuwer(moeilijkheidsgraad). Eén extra methode-aanroep, klaar.

Showcase: verhaal-generator

Bouw van onder naar boven, elke laag hergebruikt de vorige:

GenereerKlinker() / GenereerMedeklinker()

losse letters

GenereerNaam(int lengte)

een uitspreekbare naam (klinker na medeklinker)

GenereerKorteZin()

onderwerp + werkwoord + voorwerp

GenereerVerhaal()

meerdere zinnen aan elkaar

Tip

GenereerMedeklinker hergebruikt IsKlinker: blijf letters trekken tot er een geen klinker is. Methoden die methoden gebruiken.

Verhaal-generator: zinnen samenstellen

static string GenereerKorteZin()
{
    string onderwerp = GenereerNaam(6);
    string werkwoord = GenereerWerkwoord();   // "gooit", "trapt", ...
    string voorwerp  = GenereerVoorwerp();    // "de bal", "de lepel", ...
    return $"{onderwerp} {werkwoord} {voorwerp}";
}

Tip

Uitdaging: schrijf zelf GenereerVerhaal() dat meerdere zinnen met voegwoorden (” en “,”, maar “,”, dus “) aan elkaar plakt. Ben jij de volgende Shakespeare?

Showcase: Sinterklaas cadeau-generator

De Sint verdeelt het werk over drie hulp-elfen, elk een methode:

IsBraaf(...)

braaf of stout? (bool)

BerekenAantalCadeaus(...)

hoeveel cadeaus (int)

GenereerCadeau()

een willekeurig cadeau (string)

Een TestenMaar()-methode maakt met Random willekeurige kinderen en draait alles in een loop.

Tip

Zelfde idee als de Avengers: splits het probleem op, laat elke methode één ding goed doen.