Delegaty w C#: Co Musisz Wiedzieć o Delegatach w .NET

Cześć! Dzisiaj porozmawiamy o delegatach w C#. Jest to temat, który na pierwszy rzut oka może wydawać się skomplikowany, ale naprawdę warto go zrozumieć. Delegaty to potężny mechanizm umożliwiający przekazywanie metod niczym zmiennych. Mogą one znacząco zwiększyć elastyczność naszego kodu i otworzyć wiele możliwości, które pozwolą nam tworzyć bardziej przejrzyste i rozszerzalne aplikacje.

Co to są delegaty?

Prosty przykład użycia delegata

using System;

namespace DelegatesDemo
{
    // Definicja delegata
    public delegate int MathOperation(int x, int y);

    class Program
    {
        static void Main(string[] args)
        {
            // Przypisujemy do delegata metodę Add
            MathOperation operation = Add;
            Console.WriteLine("Dodawanie 5 + 3 = " + operation(5, 3));

            // Teraz możemy zmienić zachowanie w locie
            operation = Subtract;
            Console.WriteLine("Odejmowanie 5 - 3 = " + operation(5, 3));
        }

        // Metoda do dodawania
        public static int Add(int x, int y) => x + y;
        
        // Metoda do odejmowania
        public static int Subtract(int x, int y) => x - y;
    }
}

W powyższym przykładzie MathOperation to nazwa naszego delegata. Jest to typ, który przechowuje metody zwracające int i przyjmujące dwa parametry typu int. Dzięki temu w Main możemy w dowolnym momencie zmienić, która metoda faktycznie zostanie wywołana przez delegat operation.

Delegaty wielokrotne (multicast)

using System;

namespace DelegatesDemo
{
    public delegate void LogOperation(string message);

    class Program
    {
        static void Main(string[] args)
        {
            LogOperation logOps = LogToConsole;
            logOps += LogToFile;

            // Wywołają się dwie metody: LogToConsole i LogToFile
            logOps("Start aplikacji");
        }

        static void LogToConsole(string msg) 
            => Console.WriteLine($"Konsola: {msg}");

        static void LogToFile(string msg)
        {
            // Dla uproszczenia wypisujemy w konsoli
            // W praktyce zapis do pliku
            Console.WriteLine($"Plik: {msg}");
        }
    }
}

Powyższy kod pokazuje, jak delegat logOps może wywołać dwie różne metody logujące. Dzięki temu nie trzeba pisać osobnej logiki do konsoli i pliku w jednej metodzie – można je rozdzielić i decydować, które zostaną wywołane wspólnie.

Delegaty w praktyce – przekazywanie funkcji jako parametru

using System;
using System.Collections.Generic;

namespace DelegatesDemo
{
    public delegate bool Filter<T>(T item);

    class Program
    {
        static void Main(string[] args)
        {
            var numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

            // Przekazujemy metodę IsEven jako delegat
            var evenNumbers = FilterList(numbers, IsEven);

            Console.WriteLine("Parzyste liczby:");
            foreach (var n in evenNumbers)
            {
                Console.WriteLine(n);
            }
        }

        // Metoda przyjmuje listę i delegat do filtrowania
        static List<int> FilterList(List<int> list, Filter<int> filter)
        {
            var result = new List<int>();
            foreach (var item in list)
            {
                if (filter(item))
                {
                    result.Add(item);
                }
            }
            return result;
        }

        static bool IsEven(int x) => x % 2 == 0;
    }
}

Tutaj Filter<int> to delegat definiujący metodę, która przyjmuje liczbę typu int i zwraca bool (czyli prawda/fałsz). Nasza metoda FilterList może teraz filtrować listę według dowolnego kryterium, które przekażemy jako delegat.

Wbudowane delegaty: Action, Func i Predicate

Praktyczne zastosowania delegatów

Podsumowanie