Overladen van methoden

Veel programmeertalen gebruiken een techniek die we standaard/optionele parameters noemen. Het laat de programmeur toe om één of meerdere parameters optioneel te maken door ze een standaard waarde te geven. Dit is vooral nuttig als je functionaliteiten wil toevoegen aan reeds bestaande code.

Zo kan het gebeuren dat je extra functionaliteit wil toevoegen aan een bestaande functie maar dat je daarvoor een of meerdere extra parameters nodig hebt. Als je deze parameters zomaar zou toevoegen zou je ervoor zorgen dat bestaande code die deze funtie aanroept niet meer werkt. De nieuwe parameters die je hebt toegevoegd aan je functie zouden in de oude code ontbreken. Om dit te omzeilen kan je nieuw toegevoegd parameters definiëren als optioneel en hen een standaard waarde meegeven die overeenstemt met hoe de code zijn werk deed voor je de nieuwe parameters had toegevoegd.

Standaard parameters werden geïntroduceerd in C# versie 4.0. Voor de release van deze versie gebruikten programmeurs een andere techniek die hetzelfde deed namelijk het overladen van methoden (method overloading). Dit laat de programmeur toe om verschillende methoden te definiëren met dezelfde naam zolang ze maar een verschillende set aan parameters ontvangen. Als je de standaardklassen in het .NET framework gebruikt zal je al snel zien dat het overladen van methoden overal gebruikt wordt. Een goed voorbeeld hiervan is de Substring() methode van de String klasse. Die heeft een extra overload die er als volgt uitziet:

string Substring (int startIndex)
string Substring (int startIndex, int length)

Je kan de Substring() methode op 2 manieren aanroepen, met één of met twee parameters. Als je deze methode aanroept met een parameter wordt ervan uitgegaan dat de length parameter de rest van de String is. Dit bespaart ons tijd als we simpelweg het laatste stuk van een String geretourneerd willen krijgen.

Als we meerdere versies van dezelfde funtie kunnen definiëren, hoe vermijden we dan dat dezelfde code opduikt op meerdere plaatsen? We zorgen ervoor dat de simpele versie van een methode de meer complexe versie van de methode al het werk laat opknappen. Bekijk even het volgende voorbeeld:

class SillyMath
{
    public static int Plus(int number1, int number2)
    {
        return Plus(number1, number2, 0);
    }

    public static int Plus(int number1, int number2, int number3)
    {
        return number1 + number2 + number3;
    }
}

We definiëren twee verschillende versies van een Plus methode. De eerste aanvaardt 2 parameters, om 2 getallen op te tellen, de tweede versie aanvaardt 3 parameters. Het optellen wordt effectief gedaan in de versie die 3 parameters aanvaardt. Als we slechts 2 getallen wensen op te tellen reopen we de methode op met 3 parameters en gebruiken we 0 als derde parameter (deze werkt hier als default waarde). Het is misschien een dom voorbeeld, zoals ook aangegeven door de naam van de klasse, maar het zou je toch een idee moeten geven van hoe dit allemaal in zijn werk gaat.

Je kan zelfs (als je de zou willen) 4 cijfers optellen door nog een extra overload toe te voegen:

class SillyMath
{
    public static int Plus(int number1, int number2)
    {
        return Plus(number1, number2, 0);
    }

    public static int Plus(int number1, int number2, int number3)
    {
        return Plus(number1, number2, number3, 0);
    }

    public static int Plus(int number1, int number2, int number3, int number4)
    {
        return number1 + number2 + number3 + number4;
    }
}

Het leuke hieraan is dat alle reeds bestaande code die de Plus methode aanroept zal blijven werken alsof niets verandert is. Hoe meer je C# gebruikt, hoe meer je het overladen van methoden zal waarderen.