Extension Members: Methoden

1. Einführung

In der Welt der objektorientierten Programmierung stehen wir oft vor der Aufgabe, bestehende Klassen um neue Funktionalität zu erweitern. Manchmal haben wir keinen Zugriff auf den Quellcode dieser Klassen (zum Beispiel können das Standardtypen wie .NET sein, Klassen aus externen Bibliotheken oder generierter Code).

In solchen Situationen kommen Extension Methods ins Spiel – ein mächtiges und elegantes Feature von C#, das es dir erlaubt, "scheinbar" neue Methoden zu bestehenden Typen hinzuzufügen, ohne sie direkt zu verändern.

Extension Methods sind syntaktischer Zucker in C#, der es dir ermöglicht, statische Methoden so aufzurufen, als wären sie Instanzmethoden eines Typs. Sie sehen so aus und werden so verwendet, als wären sie schon immer Teil des erweiterten Typs gewesen, obwohl das eigentlich nicht stimmt.

Angenommen, du brauchst eine Methode, die den ersten Buchstaben eines Strings groß schreibt:

public static class StringUtil
{
    public static string CapitalizeFirstLetter(string str)
    {
        if (string.IsNullOrEmpty(str)) return str;
        return char.ToUpper(str[0]) + str.Substring(1);
    }
}

// Verwendung
string hello = StringUtil.CapitalizeFirstLetter("привет"); // "Привет"
Console.WriteLine(hello); 

Code wie Code, aber C# erlaubt es, das Ganze viel kompakter zu schreiben.

Die Zeile

string hello = StringUtil.CapitalizeFirstLetter("привет"); // "Привет"

kannst du so schreiben:

string hello = "привет".CapitalizeFirstLetter(); // "Привет"

Und jetzt erkläre ich dir, wie das funktioniert.

2. Wie Extension Methods funktionieren

Auch wenn Extension Methods wie Magie wirken, sind sie eigentlich ziemlich simpel. Eine Extension Method ist nichts anderes als eine ganz normale statische Methode in einer statischen Klasse, aber mit einem wichtigen Unterschied: Ihr erster Parameter ist mit dem Schlüsselwort this markiert. Genau dieser Parameter gibt an, auf welchen Typ sich die Methode als Erweiterung "anwendet".

Schauen wir uns ein Beispiel für die Erweiterung des Typs string an:

namespace MyProject.Extensions
{
    // 1. Extension Methods müssen in einer statischen Klasse deklariert werden.
    public static class StringExtensions
    {
        // 2. Die Methode muss statisch sein.
        // 3. Der erste Parameter muss mit dem Schlüsselwort 'this' markiert sein.
        public static string CapitalizeFirstLetter(this string str)
        {
            if (string.IsNullOrEmpty(str)) 
                return str; 

            // Wir nutzen String.ToUpper und String.Substring, um einen neuen String zu erzeugen
            return char.ToUpper(str[0]) + str.Substring(1);
        }

        // Noch ein Beispiel:
        public static int WordCount(this string text)
        {
            if (string.IsNullOrEmpty(text))
                return 0;

            // Einfaches Zählen der Wörter, indem wir nach Leerzeichen splitten
            return text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
        }
    }
}    

Um diese Methoden zu verwenden, musst du nur den Namespace MyProject.Extensions in deiner Datei einbinden:

using MyProject.Extensions; // Wichtig: Namespace importieren, wo die Extension Methods deklariert sind

string hello = "привет, мир!";
Console.WriteLine(hello.CapitalizeFirstLetter()); // Gibt aus: "Привет, мир!"

string sentence = "Это тестовая строка для подсчета слов.";
Console.WriteLine($"Количество слов: {sentence.WordCount()}"); // Gibt aus: "Количество слов: 6"

string emptyString = "";
Console.WriteLine(emptyString.CapitalizeFirstLetter()); // Gibt aus: ""

Wichtig: Wenn das Schlüsselwort this vor dem ersten Parameter string str fehlen würde, wäre CapitalizeFirstLetter einfach eine normale statische Methode der Klasse StringExtensions und du müsstest sie als StringExtensions.CapitalizeFirstLetter("привет") aufrufen. Erst this macht daraus eine Extension Method und erlaubt den objektorientierten Aufrufstil.

3. Syntax von Extension Methods

Um Extension Methods zu erstellen und zu nutzen, folge diesen Schritten:

1. Erstelle eine statische Klasse: Alle Extension Methods müssen in einer statischen Klasse deklariert werden. Der Name ist egal, aber üblich ist [TypeName]Extensions (z.B. StringExtensions, ListExtensions, DateTimeExtensions).
2. Deklariere eine statische Methode: Schreibe in deiner statischen Klasse eine ganz normale statische Methode.
3. Markiere den ersten Parameter mit this: Das Wichtigste: Der erste Parameter deiner statischen Methode muss mit this markiert sein, gefolgt vom Typ, den du erweitern willst. Dieser Parameter repräsentiert die Instanz, für die du die Extension Method aufrufst.
4. Namespace einbinden: In der Datei, in der du die Extension Method nutzen willst, stelle sicher, dass du den Namespace (using) eingebunden hast, in dem deine statische Klasse mit den Extension Methods deklariert ist. Sonst findet der Compiler deine Erweiterungen nicht.
5. Wie eine normale Methode verwenden: Jetzt kannst du deine Extension Method so aufrufen, als wäre sie eine ganz normale Instanzmethode des entsprechenden Typs.

4. Wie die "Magie" wirklich funktioniert

Die "Magie" der Extension Methods ist das Werk des C#-Compilers. Während der Programmausführung sind Extension Methods keine echten Methoden des Typs. Stattdessen wandelt der C#-Compiler den Aufruf einer Extension Method in einen normalen statischen Methodenaufruf um.

Wenn du obj.Method(args) schreibst, wobei Method eine Extension Method ist, wandelt der Compiler das beim Bauen des Programms tatsächlich in ContainingClass.Method(obj, args) um. Das passiert für dich unsichtbar und erzeugt die Illusion, dass die Methode Teil der Klasse ist.

Namenskonflikte: Extension Methods vs Normale Methoden

Was passiert, wenn eine Klasse schon eine "native" (Instanz-)Methode mit demselben Namen und derselben Signatur wie deine Extension Method hat?

public class MyClass
{
    public void DoSomething(int value)
    {
        Console.WriteLine($"Родной метод MyClass.DoSomething: {value}");
    }
}

public static class MyClassExtensions
{
    public static void DoSomething(this MyClass instance, int value)
    {
        Console.WriteLine($"Extension Method MyClassExtensions.DoSomething: {value}");
    }
}

// Verwendung:
MyClass obj = new MyClass();
obj.DoSomething(10); // Ruft die native Methode MyClass.DoSomething: 10 auf

Prioritätsregel: Wenn eine Klasse schon eine Instanzmethode mit demselben Namen und derselben Signatur (Anzahl und Typen der Parameter) hat, wird immer die native Instanzmethode aufgerufen und nicht die Extension Method. Extension Methods haben bei Namenskonflikten immer die niedrigere Priorität.

Einschränkungen von Extension Methods

• Du kannst keine bestehenden Methoden überschreiben (override): Extension Methods nehmen nicht am Polymorphismus teil.
• Du kannst keine neuen Felder, Properties oder Events hinzufügen: Nur Methoden sind möglich. Du kannst damit keinen neuen Zustand zu einem Typ hinzufügen.
• Du kannst keine statischen Klassen erweitern: Der erste Parameter this muss immer eine Instanz (ein Objekt) des Typs sein.
• Du kannst keine Felder oder Properties erweitern: Nur Typen können erweitert werden.
• Kein Zugriff auf private oder geschützte Member: Extension Methods können nur mit public Membern des erweiterten Typs arbeiten.

Du kannst aber Extension Methods hinzufügen zu:

• Interfaces: Das ist richtig mächtig! Du kannst einer ganzen Gruppe von Klassen, die ein Interface implementieren, eine Methode hinzufügen, ohne das Interface oder jede Klasse zu ändern. Zum Beispiel bekommen alle Klassen, die IEnumerable<T> implementieren, die Extension Methods aus LINQ.
• Dem Typ object: Damit kannst du Extension Methods schreiben, die für jedes Objekt in C# verfügbar sind. Aber Vorsicht: Das kann das globale Namensraum verschmutzen und zu Namenskonflikten führen.

5. Echte Beispiele und Best Practices

Extension Methods sind nicht nur ein theoretisches Konzept, sondern ein mächtiges Werkzeug für den Alltag. Hier ein paar praktische Szenarien:

1. Erweiterung von DateTime:

Nützliche Methoden für die Arbeit mit Datumswerten, die oft in der Business-Logik gebraucht werden.

using System;

namespace MyProject.TimeHelpers
{
    public static class DateTimeExtensions
    {
        public static bool IsWeekend(this DateTime date)
        {
            return date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday;
        }

        public static bool IsWeekday(this DateTime date)
        {
            return !date.IsWeekend(); // Nutzt schon existierende Extension Method!
        }

        public static DateTime NextDay(this DateTime date)
        {
            return date.AddDays(1);
        }

        public static DateTime AddBusinessDays(this DateTime date, int days)
        {
            DateTime newDate = date;
            while (days > 0)
            {
                newDate = newDate.NextDay();
                if (newDate.IsWeekday())
                {
                    days--;
                }
            }
            return newDate;
        }
    }
}

Verwendung:

using MyProject.TimeHelpers;

DateTime today = DateTime.Now;
if (today.IsWeekend())
{
    Console.WriteLine("Сегодня выходной!");
}
else
{
    Console.WriteLine("Сегодня будний день.");
}

DateTime tomorrow = today.NextDay();
Console.WriteLine($"Завтра: {tomorrow.ToShortDateString()}");

DateTime futureDate = today.AddBusinessDays(5);
Console.WriteLine($"Через 5 рабочих дней будет: {futureDate.ToShortDateString()}");

2. Erweiterung eines eigenen Typs (z.B. Dog):

Auch wenn du Zugriff auf den Quellcode der Klasse hast, können Extension Methods nützlich sein, um Hilfslogik auszulagern oder das Single Responsibility Principle einzuhalten.

namespace MyProject.Animals
{
    public class Dog
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string Breed { get; set; }
    }

    public static class DogExtensions
    {
        public static bool IsPuppy(this Dog dog)
        {
            // Bedingte Bestimmung eines Welpen
            return dog.Age < 2;
        }

        public static string GetAgeCategory(this Dog dog)
        {
            if (dog.Age < 1) return "Щенок";
            if (dog.Age < 7) return "Взрослая собака";
            return "Пожилая собака";
        }

        public static void Bark(this Dog dog)
        {
            Console.WriteLine($"{dog.Name} говорит: Гав! Гав!");
        }
    }
}

Verwendung:

using MyProject.Animals;

var sharik = new Dog { Name = "Шарик", Age = 1, Breed = "Дворняга" };
if (sharik.IsPuppy())
{
    Console.WriteLine($"{sharik.Name} — еще щенок!"); // Шарик — еще щенок!
}

Console.WriteLine($"{sharik.Name} в категории: {sharik.GetAgeCategory()}"); // Шарик в категории: Щенок
sharik.Bark(); // Шарик говорит: Гав! Гав!

var rex = new Dog { Name = "Рекс", Age = 5, Breed = "Овчарка" };
Console.WriteLine($"{rex.Name} в категории: {rex.GetAgeCategory()}"); // Рекс в категории: Взрослая собака

Best Practices:

Wähle sinnvolle Namen: Die Namen der Erweiterungsklassen (StringExtensions, ListExtensions) und der Methoden selbst sollten klar und selbsterklärend sein.

Platziere sie in logischen Namespaces: Gruppiere Extension Methods in Namespaces, die ihren Zweck widerspiegeln, um das globale Namensraum sauber zu halten.

Benutze sie mit Bedacht: Übertreibe es nicht mit Extension Methods. Wenn du Zugriff auf den Quellcode der Klasse hast und die Methode direkt hinzufügen kannst, ist das vielleicht die sauberere Lösung. Extension Methods sind am besten für nicht-intrusive Funktionalität geeignet.

Vermeide Namenskonflikte: Denke an die Priorität der nativen Methoden. Wenn deine Extension Method denselben Namen und dieselbe Signatur wie eine existierende Methode hat, wird sie nicht aufgerufen.

Saubere Methoden: Extension Methods sollten eine klare, fokussierte Aufgabe erfüllen. Mach sie nicht zu komplex.

Testbarkeit: Extension Methods sind ganz normale statische Methoden und daher super einfach zu testen.