TOC

This article is currently in the process of being translated into Dutch (~86% 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 gedragen 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().

The 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.

Whether to use out or ref really depends on the situation, as you will realize once you start using them. Both are typically used to work around the issue of only being able to return one value from a function, with C#.

Using the out modifier is just like using the ref modifier, as shown above. Simply change the ref keyword to the out keyword. In the example above, also remember to remove the value assigned to number in the method and declare it in the call function instead.

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 is aanvaardbaar, maar het kan nog 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!