Что такое делегат (Delegate) в C#?

Question

Что такое делегат (Delegate) в C#?

Тип вопроса: C# Core Вероятность: 65% Категория: C# Разработчик

Ответ

Делегат (Delegate) в C# — это типобезопасный указатель на метод. По сути, это объект, который знает, как вызвать конкретный метод (или группу методов), позволяя передавать методы как параметры, хранить их в переменных и вызывать динамически.

Зачем это нужно? Для реализации паттернов обратного вызова (callback), событийной модели (events) и для повышения гибкости кода, позволяя менять поведение алгоритма, не переписывая его.

Ключевые особенности:

Типобезопасность: Сигнатура делегата (возвращаемый тип и типы параметров) должна точно совпадать с сигнатурой метода, на который он ссылается.
Multicast-делегаты: Один делегат может содержать ссылки на несколько методов (+= для добавления, -= для удаления). При вызове такого делегата методы выполняются последовательно.

Пример объявления и использования пользовательского делегата:

// 1. Объявление типа делегата
public delegate int MathOperation(int a, int b);

public class Calculator
{
    // 2. Методы, совместимые с делегатом
    public static int Add(int x, int y) => x + y;
    public static int Multiply(int x, int y) => x * y;
}

class Program
{
    static void Main()
    {
        // 3. Создание экземпляра делегата и привязка к методу
        MathOperation operation = Calculator.Add;

        // 4. Вызов метода через делегат
        int result = operation(5, 3); // result = 8
        Console.WriteLine(result);

        // 5. Добавление второго метода (Multicast)
        operation += Calculator.Multiply;
        // При вызове выполнятся оба метода: Add(5,3) и Multiply(5,3)
        // Но возвращено будет значение только от последнего (Multiply -> 15)
        result = operation(5, 3); // result = 15
        Console.WriteLine(result);
    }
}

Встроенные обобщённые делегаты (часто используются вместо объявления своих):

Action<T1, T2, ...> — для методов, которые не возвращают значение (void).
```
Action<string> logAction = message => Console.WriteLine($"[LOG]: {message}");
logAction("Hello");
```
Func<T1, T2, ..., TResult> — для методов, которые возвращают значение.
```
Func<int, int, int> sumFunc = (a, b) => a + b;
int sum = sumFunc(10, 20); // sum = 30
```
Predicate<T> — для методов, возвращающих bool (частный случай Func<T, bool>).

Основные сферы применения:

События (Events): Основа механизма событий в .NET.
LINQ: Многие методы расширения LINQ принимают Func<> или Action<> как параметры.
Асинхронное программирование: В связке с async/await.
Реализация паттернов: Например, Стратегия (Strategy), где делегат инкапсулирует алгоритм.

Ответ 18+ 🔞

А, делегаты в C#! Ну это ж классика, как водка с огурцом. Смотри, представь себе такую хуйню: делегат — это типа твой личный курьер, который знает, куда и кому доставить посылку-метод. Ты ему говоришь: «Вот адрес, вот задача — иди, выполни!» А он уже сам разбирается, как это сделать.

Зачем это вообще нужно, спросишь? Ну, например, когда тебе нужно передать кусок логики как аргумент, чтоб не городить огород из условий и свитчей. Или когда пишешь событийную модель — там без делегатов вообще никуда, пиздец как удобно.

Фишки главные:

Типобезопасность — это не хуй собачий, а серьёзно. Нельзя воткнуть метод с другими параметрами, компилятор сразу наебнёт тебя ошибкой. Как в хорошем баре — тебе не нальют пиво в стакан для виски.
Multicast — это когда один делегат может тащить на себе несколько методов сразу, как олень нарты. Добавил через += — поехали, удалил через -= — высадил пассажира.

Смотри, как это выглядит в коде, на простом примере:

// Объявляем делегат — типа говорим: «Вот такие методы мы будем передавать»
public delegate int MathOperation(int a, int b);

public class Calculator
{
    // Методы, которые подходят под делегат
    public static int Add(int x, int y) => x + y;
    public static int Multiply(int x, int y) => x * y;
}

class Program
{
    static void Main()
    {
        // Цепляем делегат к методу сложения
        MathOperation operation = Calculator.Add;

        // Вызываем через делегат — как будто сам метод зовём
        int result = operation(5, 3); // Получится 8
        Console.WriteLine(result);

        // А теперь добавляем умножение — multicast, ёпта!
        operation += Calculator.Multiply;
        // Вызовутся оба метода, но вернёт значение только последний (умножение)
        result = operation(5, 3); // Получится 15
        Console.WriteLine(result);
    }
}

А ещё есть встроенные делегаты, чтоб свою хуйню не объявлять:

Action<T1, T2, ...> — для методов без возвращаемого значения (void). Просто делают работу и молчат, как сапёры.
```
Action<string> logAction = message => Console.WriteLine($"[LOG]: {message}");
logAction("Всё пропало!");
```
Func<T1, T2, ..., TResult> — для методов, которые что-то возвращают. Тут уже ждём ответ, как манны небесной.
```
Func<int, int, int> sumFunc = (a, b) => a + b;
int sum = sumFunc(10, 20); // sum = 30
```
Predicate<T> — частный случай, когда метод возвращает bool (по сути, Func<T, bool>). Спрашивает: «Ну чё, проходишь или нет?»

Где это всё применяется? Да везде, блядь!

События (Events) — основа основ, без делегатов события просто не существуют.
LINQ — там половина методов жрёт Func<> или Action<> как горячие пирожки.
Асинхронность — вместе с async/await творят чудеса.
Паттерны проектирования — например, Стратегия, где делегат заменяет целую иерархию классов.

В общем, делегаты — это как швейцарский нож в мире C#: вроде мелочь, а без них иногда вообще нихуя не сделать. Освой — и жизнь станет проще, я тебе гарантирую.