C# / .NET Kompendium PLEN
.NET / C# / C# — fundamenty języka

Delegaty w C

Co to jest delegat - definicja

Delegat to typ referencyjny, który wskazuje na metodę (a właściwie na jedną lub więcej metod) - zamiast przechowywać dane, przechowuje odniesienie do kodu, który da się wywołać. To odpowiednik wskaźnika na funkcję ze świata C/C++, ale silnie typowany i bezpieczny.

Widziałeś to już w praktyce, nawet o tym nie wiedząc - w RelayCommand:

public class RelayCommand : ICommand
{
    private readonly Action<object> _execute;      // ← to jest delegat
    private readonly Predicate<object> _canExecute; // ← to też jest delegat
}

Action<object> i Predicate<object> to wbudowane, gotowe typy delegatów w .NET - nie musisz definiować własnych do większości przypadków.

Deklaracja własnego delegata

// Definicja typu delegata - opisuje SYGNATURĘ metody, na którą będzie wskazywał
public delegate void OrderProcessedHandler(Order order, DateTime processedAt);

// Metoda pasująca do tej sygnatury
public void LogOrderProcessed(Order order, DateTime processedAt)
{
    Console.WriteLine($"Zamówienie {order.Id} przetworzone o {processedAt}");
}

// Użycie
OrderProcessedHandler handler = LogOrderProcessed;
handler(myOrder, DateTime.Now); // wywołuje LogOrderProcessed pod spodem

Delegat OrderProcessedHandler może wskazywać na dowolną metodę o sygnaturze void (Order, DateTime) - nazwa metody nie ma znaczenia, liczy się tylko sygnatura.

Trzy wbudowane typy delegatów, które pokrywają 95% przypadków

W praktyce od lat prawie nikt nie definiuje własnych delegatów (jak OrderProcessedHandler wyżej) - .NET dostarcza generyczne, gotowe:

// Action<> - zwraca void, przyjmuje 0-16 parametrów
Action doSomething = () => Console.WriteLine("Zrobione");
Action<string> log = message => Console.WriteLine(message);
Action<Order, DateTime> processOrder = (order, date) => { /* ... */ };

// Func<> - zwraca wartość (ostatni parametr generyczny to typ zwracany), 0-16 parametrów wejściowych
Func<int, int, int> add = (a, b) => a + b;
Func<Order, bool> isValid = order => order.Items.Count > 0;
Func<string, Task<User>> getUserAsync = async id => await _service.GetUserAsync(id);

// Predicate<T> - specjalny przypadek Func<T, bool>, głównie do filtrowania/wyszukiwania
Predicate<Order> hasItems = order => order.Items.Count > 0;

Predicate<T> to w praktyce dokładnie to samo co Func<T, bool> - istnieje głównie historycznie (był w .NET zanim Func<> się pojawił) i bywa używany w API typu List<T>.Find(Predicate<T>).

Multicast - delegat może wskazywać na wiele metod naraz

To jest coś, czego nie ma w zwykłym wskaźniku na funkcję z C - delegaty w .NET są multicast, czyli jeden delegat może "trzymać" listę wielu metod i wywołać je wszystkie po kolei:

Action<string> logger = null;
logger += msg => Console.WriteLine($"Console: {msg}");
logger += msg => File.AppendAllText("log.txt", msg);
logger += msg => SendToRemoteLoggingService(msg);

logger("Aplikacja wystartowała"); // wywołuje WSZYSTKIE trzy metody po kolei, w kolejności dodania

+= dodaje metodę do listy wywołań (invocation list), -= usuwa. To jest zresztą dokładnie mechanizm, na którym oparte są eventy w C# - event to w gruncie rzeczy delegat multicast z ograniczonym dostępem (patrz niżej).

Pułapka z multicast + Func<>: jeśli delegat zwraca wartość (Func<>), a masz podpiętych kilka metod, zwrócona zostanie tylko wartość z OSTATNIEJ wywołanej metody - reszta wyników jest "gubiona". To częste źródło błędów, gdy ktoś nieświadomie multicastuje Func<>.

Delegat vs Event - różnica, o którą często pytają

public class OrderProcessor
{
    // Zwykły delegat jako pole/property - KAŻDY z zewnątrz może:
    // - wywołać go (Invoke)
    // - CAŁKOWICIE nadpisać listę handlerów przez =
    public Action<Order> OnOrderProcessed;

    // Event - ogranicza to, co można zrobić z zewnątrz klasy
    public event Action<Order> OrderProcessed;

    public void Process(Order order)
    {
        // wewnątrz klasy - dozwolone oba warianty
        OnOrderProcessed?.Invoke(order);
        OrderProcessed?.Invoke(order);
    }
}
var processor = new OrderProcessor();

processor.OnOrderProcessed += HandleOrder;  // OK - dodanie
processor.OnOrderProcessed = null;          // ⚠️ OK składniowo - ktoś z zewnątrz może SKASOWAĆ wszystkich innych subskrybentów!
processor.OnOrderProcessed(order);          // ⚠️ OK składniowo - ktoś z zewnątrz może ręcznie ODPALIĆ event!

processor.OrderProcessed += HandleOrder;    // OK - jedyna dozwolona operacja z zewnątrz
processor.OrderProcessed = null;            // ❌ Błąd kompilacji
processor.OrderProcessed(order);            // ❌ Błąd kompilacji - Invoke tylko wewnątrz klasy

event to modyfikator, który ogranicza publiczny dostęp do delegata tylko do += i -= - nie da się z zewnątrz ani nadpisać całej listy, ani ręcznie wywołać. To hermetyzacja w czystej postaci - klasa jest właścicielem "kiedy i czy" event się odpala, subskrybenci mogą tylko się dopisać/wypisać.

Delegaty jako parametry - podstawa LINQ i całego stylu funkcyjnego w C

To jest chyba najczęstsze praktyczne użycie, z którym stykasz się codziennie, nawet o tym nie myśląc:

// Where przyjmuje Func<Order, bool> - delegat/predykat
var expensiveOrders = orders.Where(o => o.Total > 1000);

// Select przyjmuje Func<Order, TResult> - delegat transformujący
var orderIds = orders.Select(o => o.Id);

// OrderBy przyjmuje Func<Order, TKey>
var sorted = orders.OrderBy(o => o.CreatedDate);

Każda z tych metod LINQ przyjmuje delegat jako parametr - Where(Func<T, bool> predicate). Lambda o => o.Total > 1000 to po prostu skrócona składnia tworzenia instancji delegata - kompilator "widzi" sygnaturę oczekiwaną przez Where i dopasowuje do niej Twoją lambdę.

Delegaty jako mechanizm callback / Strategy pattern

Klasyczny use case - przekazujesz "co zrobić" jako parametr, zamiast hardkodować logikę wewnątrz metody:

public class RetryHelper
{
    public static async Task<T> ExecuteWithRetryAsync<T>(
        Func<Task<T>> operation,           // co wykonać
        int maxAttempts = 3,
        Action<Exception, int> onRetry = null) // co zrobić przy każdej porażce (opcjonalnie)
    {
        for (int attempt = 1; attempt <= maxAttempts; attempt++)
        {
            try
            {
                return await operation();
            }
            catch (Exception ex) when (attempt < maxAttempts)
            {
                onRetry?.Invoke(ex, attempt);
                await Task.Delay(TimeSpan.FromSeconds(attempt));
            }
        }
        throw new InvalidOperationException("Nie powinno się zdarzyć");
    }
}

// Użycie
var user = await RetryHelper.ExecuteWithRetryAsync(
    operation: () => _userService.GetUserAsync("123"),
    maxAttempts: 3,
    onRetry: (ex, attempt) => _logger.LogWarning($"Próba {attempt} nieudana: {ex.Message}")
);

RetryHelper nie wie nic o tym, co konkretnie robi operation - dostaje tylko "przepis" jako delegat i wykonuje go zgodnie z własną logiką retry. To jest praktycznie wzorzec projektowy Strategy, zaimplementowany bez tworzenia hierarchii interfejsów/klas - tylko przez delegaty.

Delegaty a wyrażenia lambda - co się dzieje "pod spodem"

Func<int, int> square = x => x * x;

Kompilator generuje w przybliżeniu:

private static int SquareLambda(int x) => x * x; // wygenerowana, "ukryta" metoda

Func<int, int> square = new Func<int, int>(SquareLambda);

Lambda to więc cukier składniowy - tworzy metodę (statyczną albo instancyjną, zależnie czy przechwytuje zmienne z otoczenia) i owija ją w instancję odpowiedniego delegata.

Domknięcia (closures) - lambda może "przechwycić" zmienne z otaczającego zakresu:

public Func<Order, bool> CreateMinTotalFilter(decimal minTotal)
{
    return order => order.Total >= minTotal; // "minTotal" jest przechwycone z parametru metody
}

var filter = CreateMinTotalFilter(500m);
filter(someOrder); // "pamięta" wartość 500m, mimo że CreateMinTotalFilter już dawno się zakończyło

To działa, bo kompilator w takich przypadkach generuje dodatkową klasę (tzw. closure class), która przechowuje przechwycone zmienne jako pola, i lambda staje się metodą na instancji tej klasy zamiast zwykłą metodą statyczną.

Podsumowanie - gdzie to wszystko się łączy

  • ICommand/RelayCommand - Action<object> i Predicate<object> to delegaty przekazane w konstruktorze, dzięki czemu RelayCommand jest reużywalny dla dowolnej logiki, bez tworzenia osobnej klasy ICommand na każdą akcję w aplikacji
  • PropertyChanged/CanExecuteChanged - to eventy, czyli ograniczone (do +=/-=) delegaty multicast
  • DI z Func<T> - czasem wstrzykuje się Func<IService> zamiast IService, gdy potrzebujesz fabryki tworzącej nową instancję na żądanie, zamiast gotowej instancji
  • LINQ w repozytoriach (Where, Select) - wszędzie tam, gdzie filtrujesz/mapujesz kolekcje zamówień, użytkowników itd.

Delegaty to w praktyce fundament, na którym stoi cały styl "przekaż zachowanie jako parametr" w C# - od najprostszego callbacku, przez LINQ, po eventy i cały system bindingu w WPF.

Postaw mi kawę