C# / .NET Kompendium PLEN
.NET / C# / Algorytmy, struktury danych

Metody rozszerzające (Extension Methods) w C

Co to jest - dodawanie metod do typu, którego nie możesz (albo nie chcesz) modyfikować

Extension methods pozwalają "dodać" metodę do istniejącego typu (nawet takiego, do którego nie masz dostępu do kodu źródłowego, np. string czy List<T> z .NET), bez dziedziczenia czy modyfikowania oryginalnej klasy.

public static class StringExtensions
{
    // "this" przed pierwszym parametrem - TO oznacza, że jest to extension method
    public static bool IsValidEmail(this string input)
    {
        return !string.IsNullOrWhiteSpace(input) && input.Contains("@");
    }
}
string email = "test@example.com";
bool valid = email.IsValidEmail(); // wywołanie WYGLĄDA jak normalna metoda instancji!

Jak to działa "pod spodem" - cukier składniowy

To jest kluczowe do zrozumienia - email.IsValidEmail() to tylko składnia, kompilator faktycznie generuje wywołanie statycznej metody:

// To co piszesz:
bool valid = email.IsValidEmail();

// To co kompiluje się "pod spodem":
bool valid = StringExtensions.IsValidEmail(email);

string fizycznie nie zmienia się - nie dostaje nowej metody "wewnątrz" swojej definicji. To jest tylko wygodna składnia dla wywołania statycznej metody, gdzie pierwszy parametr staje się "obiektem", na którym wywołujesz metodę.

Wymagania składniowe

public static class OrderExtensions       // 1. Klasa MUSI być statyczna
{
    public static decimal GetDiscountedTotal(this Order order, decimal discountPercent) // 2. Metoda MUSI być statyczna, "this" na pierwszym parametrze
    {
        return order.TotalAmount * (1 - discountPercent / 100);
    }
}
  • Klasa zawierająca extension methods musi być static
  • Metoda musi być static
  • Pierwszy parametr musi mieć modyfikator this, wskazujący typ, który "rozszerzasz"

Najbardziej znany przykład - CAŁE LINQ to extension methods

To jest coś, czego być może nie zauważyłeś, mimo używania tego codziennie:

public static class Enumerable // fragment prawdziwego kodu .NET (uproszczony)
{
    public static IEnumerable<T> Where<T>(this IEnumerable<T> source, Func<T, bool> predicate)
    {
        foreach (var item in source)
            if (predicate(item)) yield return item;
    }

    public static IEnumerable<TResult> Select<T, TResult>(this IEnumerable<T> source, Func<T, TResult> selector)
    {
        foreach (var item in source)
            yield return selector(item);
    }
}
var orders = new List<Order> { /* ... */ };
var expensiveOrderIds = orders.Where(o => o.Total > 1000).Select(o => o.Id); // Where/Select to EXTENSION METHODS!

Cała biblioteka LINQ (Where, Select, OrderBy, FirstOrDefault, ToList...) to zbiór extension methods na IEnumerable<T> - to jest właśnie dlaczego LINQ "po prostu działa" na dowolnej kolekcji implementującej IEnumerable<T>, nawet napisanej przez kogoś innego, bez modyfikowania jej kodu.

Praktyczne zastosowanie #1 - "rozszerzanie" typów wbudowanych .NET

public static class DateTimeExtensions
{
    public static bool IsWeekend(this DateTime date)
        => date.DayOfWeek == DayOfWeek.Saturday || date.DayOfWeek == DayOfWeek.Sunday;

    public static DateTime StartOfMonth(this DateTime date)
        => new DateTime(date.Year, date.Month, 1);
}
if (DateTime.Now.IsWeekend()) { Console.WriteLine("Weekend!"); }
var start = DateTime.Now.StartOfMonth();

Nie możesz dziedziczyć po DateTime (to struct, jak omawialiśmy, nie wspiera dziedziczenia) ani zmodyfikować jego kodu źródłowego (to wbudowany typ .NET) - extension method to jedyny sposób na dodanie "własnych" metod do takiego typu.

Praktyczne zastosowanie #2 - metody pomocnicze dla interfejsów

public interface IOrderRepository
{
    Task<Order> GetByIdAsync(int id);
    Task<List<Order>> GetAllAsync();
}

public static class OrderRepositoryExtensions
{
    // Metoda "wygodna", zbudowana na bazie podstawowych metod interfejsu -
    // NIE trzeba jej implementować w KAŻDEJ klasie implementującej IOrderRepository
    public static async Task<bool> ExistsAsync(this IOrderRepository repository, int id)
    {
        var order = await repository.GetByIdAsync(id);
        return order != null;
    }
}
IOrderRepository repo = new OrderRepository(context);
bool exists = await repo.ExistsAsync(5); // działa dla KAŻDEJ implementacji IOrderRepository automatycznie

To jest przydatna technika - jeśli chcesz dodać "wygodną" metodę pochodną od podstawowego kontraktu interfejsu, nie musisz dodawać jej do samego interfejsu (co wymusiłoby implementację we WSZYSTKICH klasach implementujących) - extension method daje ją "za darmo" wszystkim implementacjom naraz.

Ograniczenia extension methods

1. Nie mają dostępu do private/protected członków - działają tylko przez publiczne API typu, który rozszerzają:

public static class OrderExtensions
{
    public static void Broken(this Order order)
    {
        // order._internalField; // ❌ błąd - extension method nie ma dostępu do private/protected
    }
}

2. Metody instancyjne zawsze mają PRIORYTET nad extension methods - jeśli klasa ma "prawdziwą" metodę o tej samej sygnaturze, ta prawdziwa zawsze "wygrywa":

public class Order
{
    public string Describe() => "Prawdziwa metoda"; // metoda INSTANCYJNA
}

public static class OrderExtensions
{
    public static string Describe(this Order order) => "Extension method"; // ta SAMA nazwa
}

var order = new Order();
order.Describe(); // "Prawdziwa metoda" - metoda instancyjna ZAWSZE wygrywa

3. Wymagają using odpowiedniej przestrzeni nazw, żeby były widoczne:

using MyApp.Extensions; // MUSISZ zaimportować namespace, w którym jest OrderExtensions

Podsumowanie

Extension methods to statyczne metody w statycznej klasie, z modyfikatorem this na pierwszym parametrze - kompilator tłumaczy wywołanie obj.Method() na StaticClass.Method(obj), dając wrażenie dodania nowej metody do typu, bez faktycznej modyfikacji jego definicji. To jest fundament LINQ (Where, Select to extension methods na IEnumerable<T>) i praktyczny sposób na dodanie "wygodnych" metod do typów wbudowanych .NET albo do interfejsów, bez wymuszania ich implementacji na każdej klasie implementującej ten interfejs.

Postaw mi kawę