TOC

This article is currently in the process of being translated into Dutch (~99% done).

De Basis:

Function parameters

In het vorige hoofdstuk zagen we we voor het eerst functies. We hadden het ook kort over parameters. Parameters zijn simpel in gebruik, maar hier enkele tips om ze veel krachtiger te maken.

Het eerste dat we zullen bekijken, zijn de 'ref modifier' en 'out modifier'. C#, en andere programmeertalen ook, maken een onderscheid tussen twee types parameters: "waarde" (value) en "verwijzing" (reference). Standaard in C# is dit op waarde, wat wil zeggen dat als je een parameter meegeeft bij een funtie je eigenlijk een kopie van het object (en dus geen verwijzing naar het object) meegeeft in de functie. Dit zorgt er ook voor dat je wijzigingen kan aanbrengen aan een parameter vanuit de functie zonder dat het oorspronkelijk object dat je meegaf als parameter wordt aangepast.

Met de keywords 'ref' en 'out' kunnen we dit gedrag aanpassen zodat we een referentie naar het object meegeven in plaats van de waarde van het object.

De ref modifier

Bekijk volgend voorbeeld:

static void Main(string[] args)
{
    int number = 20;
    AddFive(number);
    Console.WriteLine(number);
    Console.ReadKey();
}

static void AddFive(int number)
{
    number = number + 5;
}

We hebben een integer gedefinieerd en er de waarde 20 aan toegewezen. Daarna gebruiken we de funtie AddFive(), deze zou 5 moeten toevoegen aan de waarde. Dit gebeurt echter niet omdat de waarde die we toekennen aan de variabele 'number' in de functie AddFive() niet geretourneerd wordt uit de functie, want we hebben een kopie van de waarde van deze variabele meegegeven en geen referentie naar deze variabele. Dit is nu eenmaal hoe C# werkt, en in de meeste gevallen is dit ook het gewenste resultaat. In dit voorbeeld willen we echter de variabele aanpassen vanuit onze functie. Dit kunnen we doen door het ref keyword in te geven:

static void Main(string[] args)
{
    int number = 20;
    AddFive(ref number);
    Console.WriteLine(number);
    Console.ReadKey();
}

static void AddFive(ref int number)
{
    number = number + 5;
}

Zoals je kan zien hebben we ref keyword toegevoegd aan de declaratie van onze functie, we gebruiken dit ook bij het aanroepen van de functie. Als je het programma nu uitvoert zal je merken dat de waarde van variable nu wel is aangepast na het doorlopen van de functie AddFive().

De out modifier

De out modifier werkt grotendeels hetzelfde als de ref modifier. Ze vereisen beiden dat de parameter by reference doorgegeven wordt in plaats van by value, maar er zijn twee belangrijke verschillen. Een waarde die doorgegeven wordt aan een ref modifier moet geïnitialiseerd zijn voordat de methode aangeroepen wordt, wat niet geldt voor de out modifier waar je gebruik kan maken van niet-geïnitaliseerde waarden. Daarnaast kan je een functieaanroep met een out parameter niet verlaten zonder er een waarde aan toe te kennen. Omdat je niet-geïnitialiseerde waarden als een out parameter kan meegeven, is het niet mogelijk een out parameter binnen een functie te gebruiken: je kunt er alleen een nieuwe waarde aan toekennen.

Het gebruik van out of ref hangt van de situatie af, zoals je je zult realiseren wanneer je ze gaat gebruiken. Beide worden gebruikt om het probleem te omzeilen om in C# alleen maar één waarde van een functie te kunnen tonen.

Het gebruik van de out modifier is hetzelfde als van de ref modifier (zie boven). Verander slechts het ref keyword door het out keyword. Denk er aan om in bovenstaand voorbeeld de waarde die aan de number method is toegekend te verwijderen en die in plaats daarvan in de call functie te declareren.

De params modifier

In alle voorbeelden die we reeds aanhaalden had de functie een vast aantal parameters. In sommige gevallen is het echter nodig om een functie te gebruiken die eender welke hoeveelheid parameters aanvaardt. Dit zou je natuurlijk kunnen doen door functie een array of een lijst te laten gebruiken als parameter, zoals in dit voorbeeld:

static void GreetPersons(string[] names) { }

Maar deze functie aanroepen zou nogal omslachtig zijn. In de kortste versie ziet dit er als volgt uit:

GreetPersons(new string[] { "John", "Jane", "Tarzan" });

Dit kun je zo toepassen, maar het kan beter door gebruik te maken van het params keyword:

static void GreetPersons(params string[] names) { }

Om de functie dan aan te roepen ziet het er als volgt uit:

GreetPersons("John", "Jane", "Tarzan");

Een groot voordeel van het gebruiken van de params modifier is dat het ook toegelaten is om geen parameters mee te geven aan de functie. Functies met params kunnen naast de params parameter ook gelijktijdig andere parameters aanvaarden, op voorwaarde dat de params parameter de laatste parameter is die je doorgeeft. Je kan nooit meer dan een params parameter per functie gebruiken. Hier is een laatste voorbeeld:

static void Main(string[] args)
{
    GreetPersons(0);
    GreetPersons(25, "John", "Jane", "Tarzan");
    Console.ReadKey();
}

static void GreetPersons(int someUnusedParameter, params string[] names)
{
    foreach(string name in names)
Console.WriteLine("Hello, " + name);
}
This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!

This article has been deprecated!

This article has been re-organized and updated to better match the rest of the tutorial.

We suggest that you read this article instead: Method parameters