Extension metoder

Extension metoder er en funktion i C#, der gør det muligt at tilføje nye metoder til eksisterende typer uden at ændre deres kildekode eller aflede nye typer. Dette er særligt nyttigt, når det kommer til at udvide funktionaliteten af typer fra tredjepartsbiblioteker eller .NET, hvor kildekoden ikke er tilgængelig eller ikke kan ændres.

For at oprette en extension metode, skal metoden være en statisk metode inden for en statisk klasse, og det første parameter skal være af typen, der udvides, skal markeres med nøgleordet this. Denne første parameter repræsenterer instansen af typen, som extension metoden kaldes på.

Extension metoder opfører sig som instansmetoder i den forstand, at de kan kaldes på instanser af den udvidede type på samme måde som almindelige instansmetoder. Det er dog vigtigt at huske, at extension metoder kun kan få adgang til de offentlige medlemmer af den udvidede type, da de ikke er en del af typens egentlige implementering.

Når der findes både en instansmetode og en extension metode med samme navn og signatur på en given type, vil instansmetoden altid have forrang, og extension metoden vil blive ignoreret.

Nyt i .NET 10: Extension Properties og Static Extensions

Fra .NET 10 og C# 13 er extension-konceptet blevet betydeligt udvidet. Nu er det ikke kun muligt at oprette extension metoder, men også:

Extension properties (både instance og static)
Static extension methods

Dette giver langt flere muligheder for at udvide eksisterende typer på en elegant måde.

Extension Properties (Instance)

Du kan nu tilføje properties til eksisterende typer:

public static class StringExtensions
{
    // Extension property der returnerer længden i ord
    public static int WordCount(this string text)
    {
        get
        {
            if (string.IsNullOrWhiteSpace(text))
                return 0;
            return text.Split(new[] { ' ', '\t', '\n', '\r' }, 
                StringSplitOptions.RemoveEmptyEntries).Length;
        }
    }

    // Extension property der tjekker om en string er et palindrom
    public static bool IsPalindrome(this string text)
    {
        get
        {
            if (string.IsNullOrEmpty(text))
                return false;
            string reversed = new string(text.Reverse().ToArray());
            return text.Equals(reversed, StringComparison.OrdinalIgnoreCase);
        }
    }
}

// Brug:
string tekst = "Dette er en test";
Console.WriteLine($"Antal ord: {tekst.WordCount}");

string palindrom = "Anna";
Console.WriteLine($"Er palindrom: {palindrom.IsPalindrome}");

Static Extension Methods og Properties

Du kan også udvide typer med statiske medlemmer:

public static class DateTimeExtensions
{
    // Static extension method
    public static DateTime DanishIndependenceDay(this DateTime _)
    {
        return new DateTime(DateTime.Now.Year, 6, 5);
    }

    // Static extension property
    public static DateTime DanishConstitutionDay(this DateTime _)
    {
        get => new DateTime(DateTime.Now.Year, 6, 5);
    }
}

// Brug (bemærk statisk tilgang):
DateTime grundlovsdag = DateTime.DanishConstitutionDay;
DateTime selvstændighedsdag = DateTime.DanishIndependenceDay();
Console.WriteLine($"Grundlovsdag: {grundlovsdag:d}");

Praktisk eksempel med forskellige extension-typer

public static class IntExtensions
{
    // Instance extension method
    public static bool IsEven(this int number)
    {
        return number % 2 == 0;
    }

    // Instance extension property
    public static bool IsPositive(this int number)
    {
        get => number > 0;
    }

    // Static extension method
    public static int MaxSafeInteger(this int _)
    {
        return int.MaxValue;
    }

    // Static extension property
    public static int DefaultValue(this int _)
    {
        get => 0;
    }
}

// Brug:
int tal = 42;
Console.WriteLine($"Er lige: {tal.IsEven()}");
Console.WriteLine($"Er positivt: {tal.IsPositive}");
Console.WriteLine($"Max værdi: {int.MaxSafeInteger()}");
Console.WriteLine($"Standard værdi: {int.DefaultValue}");

Forskellen på metoder og properties

Extension properties kan ikke have parametre (udover implicit this), mens extension methods kan have flere parametre. Properties er især nyttige når du vil beregne en værdi baseret på objektets tilstand uden at skulle kalde en metode eksplicit med parenteser.

Kompatibilitet

Extension properties og static extensions kræver .NET 10 og C# 13 eller nyere. I ældre versioner kan du kun bruge traditionelle instance extension methods.

Traditionelle Extension Methods

Her er et eksempel på traditionelle extension metoder:

using System;

namespace Extension
{
    public static class MineMetoder
    {
        // Udvider DateTime
        public static bool IsWeekend(this DateTime d) {
            if (d.DayOfWeek == DayOfWeek.Sunday || d.DayOfWeek == DayOfWeek.Saturday)
                return true;

            return false;
        }

        // Udvider string
        public static string LeftPartOfString(this string text, int number)
        {
            text += new string(' ', number);
            return text.Substring(0, number);
        }
    }
}

Spørgsmål til AI

For at få mest muligt ud af AI-værktøjer som ChatGPT, er det vigtigt at stille klare og præcise spørgsmål (og skabe det rigtige kontekst - se her). Her er nogle spørgsmål til denne side:

Grundlæggende spørgsmål til AI

Hvad er extension methods i C#?
Hvordan opretter jeg extension methods?
Hvornår skal jeg bruge extension methods?
Hvad er begrænsningerne ved extension methods?
Hvordan organiserer jeg extension methods?
Kan jeg lave extension methods på interfaces?
Hvad er extension properties i .NET 10?
Hvad er forskellen mellem extension methods og extension properties?
Hvordan laver jeg static extension members?
Hvornår skal jeg bruge extension properties frem for extension methods?