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>iPredicate<object>to delegaty przekazane w konstruktorze, dzięki czemuRelayCommandjest reużywalny dla dowolnej logiki, bez tworzenia osobnej klasyICommandna każdą akcję w aplikacjiPropertyChanged/CanExecuteChanged- to eventy, czyli ograniczone (do+=/-=) delegaty multicast- DI z
Func<T>- czasem wstrzykuje sięFunc<IService>zamiastIService, 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.