C# Academy · Les

Extensiemethoden definiëren

Schrijf statische methoden met de this-modifier.

Les 1 van 413 stappen

Extensiemethoden definiëren is een gratis C# Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C# Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C# Academy bevat in totaal 4 lessen.

Wat is een extensiemethode?

Met een extensiemethode kun je nieuwe methoden toevoegen aan een bestaand type zonder het aan te passen of een afgeleid type te maken. Je roept de methode aan alsof het een instantiemethode is, maar eigenlijk is het een speciale static-methode.

Extensies zijn ideaal wanneer je de broncode van een type (zoals string of int) niet beheert, maar het wel handige nieuwe functionaliteit wilt geven.

De drie vereisten

Om een extensiemethode te declareren heb je een statische klasse, een statische methode en een eerste parameter nodig die is gemarkeerd met het sleutelwoord this. De parameter this geeft het type aan dat je uitbreidt.

using System;

public static class StringExtensions
{
    public static int WordCount(this string text)
    {
        if (string.IsNullOrWhiteSpace(text)) return 0;
        return text.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}

public class Program
{
    public static void Main()
    {
        string sentence = "the quick brown fox";
        Console.WriteLine(sentence.WordCount());
    }
}

Aanroepen als instantiemethode

Hoewel WordCount statisch is, roep je het aan als sentence.WordCount(). De compiler herschrijft die aanroep op de achtergrond naar StringExtensions.WordCount(sentence).

using System;
using System.Linq;

public static class StringExtensions
{
    public static string Repeat(this string text, int times)
    {
        return string.Concat(Enumerable.Repeat(text, times));
    }
}

public class Program
{
    public static void Main()
    {
        // These two lines do exactly the same thing
        Console.WriteLine("ab".Repeat(3));
        Console.WriteLine(StringExtensions.Repeat("ab", 3));
    }
}

De parameter this ontvangt de instantie

De waarde links van de punt wordt de parameter this. Je kunt er meer parameters achter zetten, die aanroepers op de normale manier doorgeven.

using System;

public static class IntExtensions
{
    public static bool IsBetween(this int value, int low, int high)
    {
        return value >= low && value <= high;
    }
}

public class Program
{
    public static void Main()
    {
        int age = 25;
        Console.WriteLine(age.IsBetween(18, 65));
        Console.WriteLine(10.IsBetween(1, 5));
    }
}

Je eigen typen uitbreiden

Extensies zijn niet alleen bedoeld voor bibliotheektypen. Je kunt ook je eigen klassen uitbreiden. Dat is handig om een schoon kerntype te behouden en elders extra hulpfuncties toe te voegen.

using System;

public class Money
{
    public decimal Amount { get; }
    public Money(decimal amount) { Amount = amount; }
}

public static class MoneyExtensions
{
    public static string ToUsd(this Money m) => "$" + m.Amount.ToString("0.00");
}

public class Program
{
    public static void Main()
    {
        var price = new Money(19.5m);
        Console.WriteLine(price.ToUsd());
    }
}

Extensies hebben geen toegang tot private leden

Een extensiemethode is gewoon een statische methode in een andere klasse en kan dus alleen het openbare (of interne, binnen dezelfde assembly) oppervlak van het type gebruiken. De methode kan niet bij private velden komen.

using System;

public class Counter
{
    private int _count;
    public int Value => _count;
    public void Increment() => _count++;
}

public static class CounterExtensions
{
    // Can only use public members like Value and Increment
    public static bool IsZero(this Counter c) => c.Value == 0;
}

public class Program
{
    public static void Main()
    {
        var c = new Counter();
        Console.WriteLine(c.IsZero());
        c.Increment();
        Console.WriteLine(c.IsZero());
    }
}

Extensiemethoden koppelen

Omdat elke extensie een waarde retourneert, kun je ze koppelen tot een vloeiende pijplijn. Dit leest van boven naar beneden en is de stijl die LINQ gebruikt.

using System;

public static class TextExtensions
{
    public static string Shout(this string s) => s.ToUpper();
    public static string Bang(this string s) => s + "!";
}

public class Program
{
    public static void Main()
    {
        string result = "hello".Shout().Bang();
        Console.WriteLine(result);
    }
}

Null en extensiemethoden

In tegenstelling tot een echte aanroep van een instantiemethode kan een extensiemethode ook worden uitgevoerd wanneer de ontvanger null is, omdat er niets wordt gedereferentieerd totdat je code de ontvanger gebruikt. Zo kun je null-veilige hulpfuncties schrijven.

using System;

public static class StringExtensions
{
    public static bool IsBlank(this string text)
    {
        // text may be null here, and that is fine
        return string.IsNullOrWhiteSpace(text);
    }
}

public class Program
{
    public static void Main()
    {
        string nothing = null;
        Console.WriteLine(nothing.IsBlank());
        Console.WriteLine("x".IsBlank());
    }
}

Instantiemethoden hebben voorrang op extensies

Als er een echte instantiemethode met een overeenkomende signatuur bestaat, geeft de compiler daar altijd de voorkeur aan boven een extensiemethode. Extensies vullen alleen functionaliteit aan die het type nog niet biedt.

using System;

public static class Ext
{
    // This will be ignored because string already has ToString()
    public static string ToString(this string s, int n) => s + n;
}

public class Program
{
    public static void Main()
    {
        // Resolves to the built-in instance ToString(), not the extension
        Console.WriteLine("value: " + "abc".ToString());
    }
}

Een praktische hulpfunctiebibliotheek

Door verwante extensies in één statische klasse te groeperen, maak je een overzichtelijke bibliotheek met hulpfuncties. Hier is een kleine klasse met numerieke hulpfuncties die je in een project opnieuw kunt gebruiken.

using System;

public static class NumberExtensions
{
    public static bool IsEven(this int n) => n % 2 == 0;
    public static int Squared(this int n) => n * n;
    public static double Percent(this int n) => n / 100.0;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(4.IsEven());
        Console.WriteLine(5.Squared());
        Console.WriteLine(50.Percent());
    }
}

Probeer het zelf

Combineer wat je hebt geleerd: één statische klasse met meerdere gerichte extensies die je vloeiend aanroept. Zo worden alledaagse bibliotheken met hulpfuncties precies gebouwd.

using System;

public static class StringExtensions
{
    public static string Capitalize(this string s)
        => string.IsNullOrEmpty(s) ? s : char.ToUpper(s[0]) + s.Substring(1);
    public static string Surround(this string s, char c) => c + s + c;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("hello".Capitalize().Surround('*'));
    }
}

Korte test

Test je begrip van het declareren van extensiemethoden.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd dat een extensiemethode een static-methode is in een static-klasse waarvan de eerste parameter this gebruikt. Je roept de methode aan met instantiële syntaxis, maar de compiler vertaalt dit naar een normale statische aanroep.

Drie vereisten: statische klasse, statische methode en this als eerste parameter.
Alleen openbare leden zijn toegankelijk.
Instantiemethoden hebben altijd voorrang.
Extensies kunnen worden gekoppeld en zelfs worden uitgevoerd op ontvangers die null zijn.

Gratis beginnen

Leer C# met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 93
Lessen: 346

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Extensiemethoden definiëren” gratis?

Ja — de volledige tekst van “Extensiemethoden definiëren” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C# Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C# Academy bevat in totaal 4 lessen.

Wat leer ik in “Extensiemethoden definiëren”?

Schrijf statische methoden met de this-modifier. Je oefent met C# Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C# Academy te beginnen?

Ervaring vooraf is niet nodig. C# Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Extensiemethoden definiëren”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C# Academy?

Ja. Elke les over C# Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C# Academy