Methoden combineren
Methoden nesten
In het begin ga je vooral vanuit je Main methoden aanroepen, maar dat is geen verplichting. Je kan ook vanuit methoden andere methoden aanroepen. Je kan zelfs vanuit die aangeroepen methode weer andere aanroepen, enz.
Volgende (nutteloze) programma’tje toont dit in actie:
static void SchrijfT()
{
Console.Write("T");
}
static void SchrijfI()
{
Console.Write("I");
}
static void SchrijfM()
{
Console.Write("M");
}
static void SchrijfNaam()
{
SchrijfT();
SchrijfI();
SchrijfM();
}
public static void Main()
{
SchrijfNaam();
}Er verschijnt “Tim” op het scherm.

De volgorde waarin je je methoden in je bestand schrijft maakt niets uit. SchrijfNaam mag dus perfect ónder Main staan, ook al roept Main ze al op de eerste lijn aan. Bij variabelen is dat wél anders: die moet je declareren voor je ze gebruikt.
Hoe groot mag een methode zijn?
Er bestaat geen regel die zegt hoeveel lijnen een methode mag tellen, maar er is wel een goede vuistregel: een methode doet één ding. Krijg je de naam van je methode niet bedacht zonder er “En” in te stoppen (LeesInEnBerekenEnToon), dan zitten er eigenlijk drie methoden in.
Twijfel je? Stel jezelf de vraag of je in één zin kan uitleggen wat de methode doet. Lukt dat niet, dan splits je ze best op. In de kennisclip “Goede methoden schrijven” ga ik hier dieper op in.
Oneindige methode-lussen
Wanneer je programma’s complexer worden moet je zeker opletten dat je geen oneindige methode-lussen creëert. Zie je de fout in volgende code?
public static void Main()
{
SchrijfNaam();
}
static void SchrijfNaam()
{
SchrijfNaam();
Console.WriteLine("Klaar?");
}Deze code heeft een methode die zichzelf aanroept, zonder dat deze ooit afsluit. Hierdoor komen we dus in een oneindige aanroep van de methode SchrijfNaam. Dit programma zal een leeg scherm tonen (daar er nooit aan de tweede lijn in de methode wordt geraakt) en dan crashen met een StackOverflowException. Iedere aanroep neemt namelijk een stukje geheugen in op de zogenaamde stack, en die raakt vol. Wat die stack precies is lees je in hoofdstuk 10.
Zo’n lus kan ook over twee (of meer) methoden lopen. Hier roepen Tik en Tak elkaar om beurt aan:
static void Tik()
{
Console.Write("Tik ");
Tak();
}
static void Tak()
{
Console.Write("Tak ");
Tik();
}Roep je Tik() aan, dan eindigt geen enkele aanroep. Je ziet een hele reeks Tik Tak, tot de stack vol zit en het programma crasht met een StackOverflowException. Geen van beide methoden roept zichzelf aan, dus zo’n circulaire aanroep zie je minder snel dan bij SchrijfNaam.
Kennisclip: De stack: elke aanroep legt er een frame bij
Een methode die zichzelf aanroept, maar op een gegeven moment wél stopt, heet een recursieve methode. Dat is een geavanceerd concept dat we in dit boek niet behandelen. Enkel in hoofdstuk 18 kom je het nog kort tegen.
Lokale functies…en waarom je ze beter niet gebruikt
Sinds C# 7.0 kan je methoden definiëren binnenin een andere methode. Dit noemt men lokale functies (local functions). Alhoewel ze zeker hun nut hebben, is het in deze fase van C# leren geen goed idee om lokale functies te gebruiken.
Het is veel belangrijker dat je eerst goed leert methoden schrijven. Beginnende programmeurs schrijven soms per ongeluk een lokale functies. Dan ontdekken ze dat ze die methode nergens kunnen aanroepen. Lokale functies zijn alleen oproepbaar binnen de methode waarin ze zijn gedefinieerd.
Kortom, zorg dat je nooit dit schrijft!
static void Main(string[] args)
{
TimVindtDitNietLeuk();
static void TimVindtDitNietLeuk() //NIET DOEN!
{
Console.WriteLine("Doe dit niet!");
}
}Maar wel
static void TimVindtDitNietLeuk() //Beter!
{
Console.WriteLine("Doe dit niet!");
}
static void Main(string[] args)
{
TimVindtDitNietLeuk();
}Dit is niet enkel een kwestie van smaak: op een vaardigheidsproef kost een methode in een methode je 3 punten.
Kennisclip: Methoden combineren
Commentaar aan methoden toevoegen
Het is aan te raden om steeds boven een methode een nieuwe vorm van commentaar te plaatsen als volgt: ///
Visual Studio zal dan automatisch de parameters verwerken van je methode zodat je vervolgens enkel nog het doel van iedere parameter moet schrijven.
Stel dat we een methode hebben geschreven die de macht van een getal berekent (wat dom is…er bestaat al zoiets als Math.Pow). We zouden dan volgende commentaar toevoegen:
/// <summary>
/// Berekent de macht van een getal.
/// </summary>
/// <param name="grondtal">Het getal dat je tot macht wilt verheffen</param>
/// <param name="exponent">De exponent van de macht</param>
/// <returns></returns>
static int Macht(int grondtal, int exponent)
{
int result = 1;
for (int i = 0; i < exponent; i++)
{
result *= grondtal;
}
return result;
}Wanneer we nu elders de methode Macht gebruiken dan krijgen we automatische extra informatie:


