KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C#

Functies en parameters: partiële toepassing en closures

Leer over methoden, lokale functies en lambda’s in C#. Ontdek het verschil tussen parameters en argumenten, hoe je een functie met een vastgezet argument maakt en waarom een closure wijzigingen aan een vastgelegde variabele ziet.

Versie: .NET 10; repository net10.0 and LangVersion=preview; feature versions require per-entry verification

Syntax

static int Add(int left, int right) => left + right;
Func<int, int> addTen = value => Add(10, value);

In C# kun je gedrag uitdrukken als een methode, lokale functie of anonieme functie, zoals een lambda. Een methode hoort bij een type. Je kunt een lokale functie declareren in de body van een member of tussen instructies op het hoogste niveau. In dat laatste geval is er in de broncode geen omsluitende memberdeclaratie nodig. De vorm value => expression is een voorbeeld van een lambda met één parameter en een expressie als body. Een lambda kan nul, één of meerdere parameters hebben. De body kan een expressie of een blok met instructies zijn. Een parameter is een benoemde variabele in een declaratie; een argument is een waarde of expressie die bij een aanroep wordt opgegeven. Argumenten worden standaard op waarde doorgegeven; bij een referentietype wordt de verwijzing gekopieerd, niet het object.

Met een delegate kun je aanroepbaar gedrag opslaan en doorgeven. Func<int, int> beschrijft een delegate die één int accepteert en een int retourneert; Action<int> retourneert geen waarde. Een lambda kan worden omgezet naar een compatibel delegatetype. Lokale functies zijn geschikt voor benoemde hulpbewerkingen, terwijl lambda’s geschikt zijn voor kort gedrag dat als argument wordt doorgegeven.

Bij partiële toepassing leg je enkele argumenten vast en maak je een functie die de overige accepteert. C# doet dit niet automatisch wanneer je een verplicht argument weglaat: je kunt expliciet een lambda maken die de aanroep omhult. In het voorbeeld retourneert BindLeft(10) een delegate die alleen nog right nodig heeft. Dit is iets anders dan een optionele parameter, die bij een aanroep een standaardwaarde levert.

Een closure combineert een functie met vastgelegde variabelen uit de omringende scope. De variabele wordt vastgelegd, niet een momentopname van de waarde: na offset = 20 levert het aanroepen van addOffset(3) 23 op. Een vastgelegde variabele kan langer bestaan dan de aanroep waardoor deze is gemaakt, zoals left in BindLeft. Let op gedeelde veranderlijke toestand en objecten die daardoor langer in het geheugen blijven. Een lambda of lokale functie met het kenmerk static kan geen lokale variabelen of instantietoestand vastleggen.

Referentie-identificatoren die in dit item worden behandeld: Partial application and closures.

Voorbeelden

using System;

internal static class Program
{
    private static int Add(int left, int right) => left + right;

    private static Func<int, int> BindLeft(int left) =>
        right => Add(left, right);

    private static void Main()
    {
        Func<int, int> addTen = BindLeft(10);
        Console.WriteLine(addTen(3));

        int offset = 10;
        Func<int, int> addOffset = value => Add(offset, value);
        offset = 20;
        Console.WriteLine(addOffset(3));
    }
}

Resultaat

13
23

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen