Extension methods laten je "methoden toevoegen" aan bestaande typen (inclusief typen die je niet bezit, zoals string of int) zonder deze aan te passen of over te erven. Ze worden gedefinieerd als statische methoden met een this modifier op de eerste parameter, en worden aangeroepen alsof het instance methods waren. LINQ is erop gebaseerd.
public static class StringExtensions
{
// `this string str` makes this an extension method ON string
public static bool IsValidEmail(this string str)
{
return str.Contains("@") && str.Contains(".");
}
public static string Truncate(this string str, int max)
{
return str.Length <= max ? str : str[..max] + "...";
}
}
// call them as if they were instance methods on string
"[email protected]".IsValidEmail(); // true
"long text here".Truncate(5); // "long ..."
De this modifier op de eerste parameter markeert de methode als een extensie van dat type. Het is een statische methode, maar je roept het aan als een instance method (str.IsValidEmail()), wat natuurlijk leest.
// these are equivalent — the extension call is sugar for a static call
"[email protected]".IsValidEmail();
StringExtensions.IsValidEmail("[email protected]");
Extension methods zijn compiler magic — het zijn eigenlijk statische methode-aanroepen, maar de this-parameter syntaxis laat je ze vloeiend aanroepen alsof ze bij het type hoorden. (Ze moeten in een statische klasse staan en de namespace moet geïmporteerd worden met using.)
// Where, Select, OrderBy, etc. are extension methods on IEnumerable<T>
list.Where(x => x > 0).Select(x => x * 2);
// → IEnumerable<T> has no Where method; LINQ ADDS them via extension methods
Al van LINQ's query operators (Where, Select, enz.) zijn extension methods op IEnumerable<T> — daarom ketenen ze zo vloeiend. Dit is het meest prominente gebruik van extension methods.
Extension methods zijn een belangrijk en onderscheidend C# feature, en het begrijpen ervan is waardevol zowel voor het gebruik ervan als voor het begrip van hoe belangrijke delen van C# werken — vooral LINQ, dat volledig gebouwd is op extension methods (de Where/Select/OrderBy operators zijn extensies op IEnumerable<T>, daarom ketenen ze zo vloeiend).
De feature laat je functionaliteit toevoegen aan bestaande typen — inclusief typen die je niet bezit (string, int, framework types) of niet kunt wijzigen (sealed classes, interfaces) — zonder overerving of wijziging van het origineel, terwijl je een schone, vloeiende aanroep-syntaxis behoudt (str.IsValidEmail() leest als een instance method).
Dit is nuttig voor het schrijven van helper methodes die typen natuurlijk uitbreiden, het bouwen van vloeiende API's, en het toevoegen van gedrag aan interfaces.
Het begrijpen van extension methods — hoe ze definiëren (this op de eerste parameter, in een statische klasse), dat ze syntactische suiker voor statische aanroepen zijn, en vooral dat LINQ erop gebouwd is — is belangrijk kennis voor zowel het schrijven van schone, vloeiende C# helpers als voor het begrijpen van hoe LINQ en veel vloeiende .NET API's hun syntaxis bereiken.
Aangezien extension methods ten grondslag liggen aan een van C#'s belangrijkste features (LINQ) en een veelgebruikte manier zijn om typen elegant uit te breiden, is het kennen ervan regelmatig toegepaste kennis die inzicht weerspiegelt in hoe C#'s vloeiende, uitbreidbare API's werken — en laat je soortgelijk schone, ontdekbare code schrijven.