0Pricing
C# Academy · Lektion

Gute Extensions entwerfen

Wenden Sie Best Practices an und vermeiden Sie typische Fallstricke.

Gute Extensions entwerfen ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Erweiterungsmethoden entwickeln, die gern verwendet werden

Erweiterungsmethoden sind leistungsfähig, doch diese Leistung lädt zum Missbrauch ein. Gute Erweiterungsmethoden fühlen sich wie ein natürlicher Bestandteil des Typs an, sind leicht zu entdecken und überraschen die aufrufende Person nie. In dieser Lektion geht es um praktische Richtlinien.

Verhalten statt Identität erweitern

Bevorzugen Sie Erweiterungsmethoden für Hilfsfunktionen, die sich in einer Pipeline gut lesen. Wenn eine Methode wirklich zu einem Typ gehört, den Sie besitzen, machen Sie sie stattdessen zu einem echten Member.

using System;

public static class TimeExtensions
{
    // A pleasant, focused helper
    public static bool IsWeekend(this DayOfWeek day)
        => day == DayOfWeek.Saturday || day == DayOfWeek.Sunday;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(DayOfWeek.Sunday.IsWeekend());
        Console.WriteLine(DayOfWeek.Monday.IsWeekend());
    }
}

Methoden möglichst frei von Seiteneffekten halten

Erweiterungsmethoden, die einen neuen Wert zurückgeben und Seiteneffekte vermeiden, sind am einfachsten nachzuvollziehen und zu verketten. Streben Sie das Muster „Eingabe hinein, Wert heraus“ an.

using System;

public static class StringExtensions
{
    // Pure: depends only on input, returns a new string
    public static string Truncate(this string s, int max)
        => s.Length <= max ? s : s.Substring(0, max) + "...";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("Extension methods are great".Truncate(10));
    }
}

Null-Eingaben abfangen

Da Aufrufende eine Erweiterungsmethode für einen null-Empfänger aufrufen können, sollten Sie bewusst festlegen, was passieren soll. Behandeln Sie null entweder problemlos oder lösen Sie eine eindeutige ArgumentNullException aus.

using System;

public static class StringExtensions
{
    public static string SafeUpper(this string s)
    {
        if (s is null) throw new ArgumentNullException(nameof(s));
        return s.ToUpper();
    }
}

public class Program
{
    public static void Main()
    {
        try { ((string)null).SafeUpper(); }
        catch (ArgumentNullException ex) { Console.WriteLine("Caught: " + ex.ParamName); }
        Console.WriteLine("ok".SafeUpper());
    }
}

Für gute Auffindbarkeit benennen

Entwickler finden Erweiterungsmethoden, indem sie den Punkt eingeben und IntelliSense durchsuchen. Klare, verbbasierte Namen, die das Ergebnis beschreiben, machen Ihre Hilfsmethoden auffindbar und selbsterklärend.

using System;
using System.Collections.Generic;

public static class CollectionExtensions
{
    public static bool HasItems<T>(this ICollection<T> c)
        => c != null && c.Count > 0;
}

public class Program
{
    public static void Main()
    {
        var list = new List<int> { 1 };
        Console.WriteLine(list.HasItems());
    }
}

Verwandte Erweiterungsmethoden sinnvoll gruppieren

Ordnen Sie Erweiterungsmethoden zu einem Konzept in einer gut benannten statischen Klasse und einem passenden Namespace an. Dadurch bleiben die Importe aussagekräftig, und Benutzer können genau die gewünschten Hilfsmethoden einbinden.

using System;
using System.Collections.Generic;

public static class EnumerableExtensions
{
    public static IEnumerable<T> TakeFirst<T>(this IEnumerable<T> source, int n)
    {
        int taken = 0;
        foreach (var item in source)
        {
            if (taken++ >= n) yield break;
            yield return item;
        }
    }
}

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 1, 2, 3, 4 };
        Console.WriteLine(string.Join(",", nums.TakeFirst(2)));
    }
}

Überraschendes Verhalten nicht verbergen

Eine Erweiterungsmethode, die unkompliziert wirkt, aber aufwendige oder zustandsbehaftete Arbeit ausführt, verletzt die Erwartungen. Machen Sie den Aufwand erkennbar. Wenn die Methode eine Datenbank abfragt oder den Zustand verändert, sollte sich das in ihrem Namen widerspiegeln.

using System;

public static class MathExtensions
{
    // Cheap and obvious: no hidden cost
    public static int ClampMin(this int value, int min)
        => value < min ? min : value;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine((-3).ClampMin(0));
        Console.WriteLine(5.ClampMin(0));
    }
}

object nicht erweitern

Die Erweiterung von object verunreinigt jeden Typ im Programm mit Ihrer Methode und überfrachtet IntelliSense überall. Zielen Sie stattdessen auf den spezifischsten sinnvollen Typ oder die spezifischste sinnvolle Schnittstelle.

using System;

public static class IntExtensions
{
    // Specific to int, not object - far less noisy
    public static string ToOrdinal(this int n)
    {
        if (n % 10 == 1 && n % 100 != 11) return n + "st";
        if (n % 10 == 2 && n % 100 != 12) return n + "nd";
        if (n % 10 == 3 && n % 100 != 13) return n + "rd";
        return n + "th";
    }
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(1.ToOrdinal());
        Console.WriteLine(22.ToOrdinal());
    }
}

Für Sequenzen bevorzugt IEnumerable zurückgeben

Geben Sie für Sequenzoperatoren IEnumerable<T> zurück und verwenden Sie verzögerte Ausführung. Dadurch lassen sie sich gut kombinieren, und Sie vermeiden, dass Aufrufende Daten materialisieren müssen, die sie möglicherweise nicht benötigen.

using System;
using System.Collections.Generic;

public static class SeqExtensions
{
    public static IEnumerable<int> Doubled(this IEnumerable<int> source)
    {
        foreach (var n in source) yield return n * 2;
    }
}

public class Program
{
    public static void Main()
    {
        var nums = new List<int> { 1, 2, 3 };
        foreach (var n in nums.Doubled()) Console.WriteLine(n);
    }
}

Eine Checkliste für gute Erweiterungsmethoden

Fragen Sie vor der Veröffentlichung einer Erweiterungsmethode: Ist der Name klar? Ist die Methode frei von Seiteneffekten, oder sind diese offensichtlich? Wird null behandelt? Ist der Zieltyp spezifisch? Ist die Methode sinnvoll gruppiert? Wenn Sie alle Fragen mit Ja beantworten, haben Sie eine Hilfsmethode, die andere gern verwenden werden.

using System;

public static class StringExtensions
{
    public static string OrDefault(this string s, string fallback)
        => string.IsNullOrEmpty(s) ? fallback : s;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine("".OrDefault("N/A"));
        Console.WriteLine("value".OrDefault("N/A"));
    }
}

Probieren Sie es selbst aus

Wenden Sie die Checkliste an: ein spezifischer Zieltyp, ein klarer Name, Toleranz gegenüber null und ein Ergebnis ohne Seiteneffekte. Diese kleine Erweiterungsmethode erfüllt jede Richtlinie.

using System;
using System.Collections.Generic;

public static class DictionaryExtensions
{
    // Clear name, specific type, null-safe, pure
    public static TValue GetOrDefault<TKey, TValue>(
        this IReadOnlyDictionary<TKey, TValue> dict, TKey key, TValue fallback)
    {
        if (dict == null) return fallback;
        return dict.TryGetValue(key, out var value) ? value : fallback;
    }
}

public class Program
{
    public static void Main()
    {
        var ages = new Dictionary<string, int> { ["Ann"] = 30 };
        Console.WriteLine(ages.GetOrDefault("Ann", -1));
        Console.WriteLine(ages.GetOrDefault("Bob", -1));
    }
}

Kurze Überprüfung

Wenden Sie die Richtlinien für das Design an.

Zusammenfassung

Gut entworfene Erweiterungsmethoden fühlen sich nativ und vorhersehbar an.

  • Bevorzugen Sie Hilfsmethoden ohne Seiteneffekte, die Werte zurückgeben und sich gut verketten lassen.
  • Legen Sie das Verhalten bei null fest und dokumentieren Sie es.
  • Verwenden Sie klare, verbbasierte Namen für eine gute Auffindbarkeit.
  • Zielen Sie auf spezifische Typen oder Schnittstellen, nicht auf object.
  • Gruppieren Sie verwandte Hilfsmethoden und geben Sie für Sequenzen IEnumerable<T> zurück.

Häufig gestellte Fragen

Ist die Lektion „Gute Extensions entwerfen“ kostenlos?

Ja — der vollständige Text von „Gute Extensions entwerfen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Gute Extensions entwerfen“?

Wenden Sie Best Practices an und vermeiden Sie typische Fallstricke. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Gute Extensions entwerfen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Extension Methods definieren
  2. Interfaces und Generics erweitern
  3. Auflösung von Extension Methods
  4. Gute Extensions entwerfen
← Zurück zu C# Academy