Делегаты в C# подробнее

Всем привет, эта статья создана для ребят, которые знакомы с делегатами, но хотели бы разобраться, что это поподробнее.

Что же такое делегаты?

Делегаты — это указатели на методы

Такое понятие нам дает практически каждый сайт, на который мы перейдем по запросу «Делегаты C#».

Также, как мы уже знаем — делегаты это ссылочный тип. Но давайте подумаем, где они храняться, как передаются и просто работают?

Сами методы хранятся в метаданных класса/структуры. «ссылки на методы» для делегатов хранятся в хипе. Но только лишь ссылка на метод храниться в хипе у делегата или что — то еще? Давайте проверим

Создадим простой класс счетчика

class Counter {     public int Num = 0;      public void Iteration()     {         Num++;         Console.WriteLine(Num + " Из Iteration");     } }

Здесь у нас при вызове функции переменная Num увеличивается на единичку и потом значение выводится на экран

Теперь возьмем делегат и назначим его к нашему методу Iteration. Вызовем метод Invoke у делегата и выведем на экран значение Num у экземпляра нашего класса

public static void Main()     {         Counter cnt = new Counter();         Action act = cnt.Iteration;         act();          Console.WriteLine(cnt.Num + " Из Main");     }

На экране увидим:
1 Из Iteration
1 Из Main

Результат логичный, но давайте всё же разберём, почему именно так.
Для начала нужно — где хранятся сами методы структур и классов? Они хранятся в метаданных. Получается, делегат будет выделять место в куче, где будет просто ссылка на указанный метод?
Почти Верно!

Но тогда как делегат узнаёт значение Num нашего класса? Всё просто, под капотом в делегате еще и будет храниться ссылка на наш класс => на все его переменные. Именно поэтому наш делегат будет знать значение, он использует не просто функцию, определенную в метаданных, но и еще ссылку на экземпляр класса этой фукнции. А наши экземпляра располагаются в хипе. Данные к ним у нас будут, поэтому все хорошо.

Как это выглядит в Low-level c#? У нас также есть тут ссылка

public static void Main()   {     Counter cnt = new Counter();     new Action((object) cnt, __methodptr(Iteration))();     Console.WriteLine(string.Concat(cnt.Num.ToString(), " Из Main"));   } 

Но что произойдет, если наш класс счетчика станет структурой?

Вывод будет:

1 Из Iteration
0 Из Main

Под капотом, мы будем боксить нашу структуру, копировать ее значение. Структура, которая фактически принимается делегатом и структура cnt — разные обьекты.

Поэтому, если мы сделаем следующее:

public static void Main()     {         Counter cnt = new Counter();         Action act = cnt.Iteration;         act();         Action act2 = act;         act2();         Console.WriteLine(cnt.Num + " Из Main");     }

Вывод будет:

1 Из Iteration
2 Из Iteration
0 Из Main

Структура уже будет в хипе, новый делегат будет указывать уже на структуру в хипе, а не просто копировать ее. Но эти действия никак не влияют на нашу переменную cnt.

Теперь давайте поговорим про замыкания

public static void Main()     {         Counter cnt = new Counter();         Action act =()=>         {             cnt.Iteration();         };         cnt.Iteration();         act();                  Console.WriteLine(cnt.Num + " Из Main");     }

Вот пример кода, как мы видим, у нас есть СТРУКТУРА Counter, все также, но мы используем лямбда функцию и уже внутри функции вызываем у переменной cnt метод.

Вывод:

1 Из Iteration
2 Из Iteration
2 Из Main

Low-level c# код:

using System; using System.Runtime.CompilerServices;  internal class Programm {   public static void Main()   {     Programm.<>c__DisplayClass0_0 cDisplayClass00 = new Programm.<>c__DisplayClass0_0();     cDisplayClass00.cnt = new Counter();     Action act = new Action((object) cDisplayClass00, __methodptr(<Main>b__0));     cDisplayClass00.cnt.Iteration();     act();     Console.WriteLine(string.Concat(cDisplayClass00.cnt.Num.ToString(), " Из Main"));   }    public Programm()   {     base..ctor();   }    [CompilerGenerated]   private sealed class <>c__DisplayClass0_0   {     public Counter cnt;      public <>c__DisplayClass0_0()     {       base..ctor();     }      internal void <Main>b__0()     {       this.cnt.Iteration();     }   } } 

У нас наша лямбда-функция преобразуется в полноценный класс, в котором и создается наша переменная cnt, пусть это и структура, но она часть класса => хранится в хипе, лямбда-функция преобразуется в отдельный метод для созданного компилятором класса. Все действия которые мы совершаем вручную с cnt на самом деле происходят с полем созданного компилятором класса. Именно поэтому у нас происходит работа с одной и той же структурой Counter.

Интересный пример, где эти знания пригодятся — довольно популярный «квиз»:

static void Main(string[] args)     {         Action act = null;         for (int i = 0; i < 10; i++)         {             act += () => { Console.WriteLine(i); };                      }         act();     }

На первый взгляд — просится ответ 0, 1, 2, 3 …

Но давайте применим уже имеющиеся знания — у нас есть делегат Action, к нему каждый раз «прибавляется» одна и та же функция — вывод i, наша лямбда-функция должна преобразоваться в класс, в котором будет поле i (именно её мы и используем в цикле), а также в классе будет присутствовать функция, выводящая на экран значение i. Посмотрим на вывод:

10
10
10
10
10
10
10
10
10
10

namespace ConsoleApp1 {   internal class Program   {     [NullableContext(1)]     private static void Main(string[] args)     {       Action act = (Action) null;       Program.<>c__DisplayClass0_0 cDisplayClass00 = new Program.<>c__DisplayClass0_0();       for (cDisplayClass00.i = 0; cDisplayClass00.i < 10; cDisplayClass00.i++)         act = (Action) Delegate.Combine((Delegate) act, (Delegate) new Action((object) cDisplayClass00, __methodptr(<Main>b__0)));       act();     }      public Program()     {       base..ctor();     }      [CompilerGenerated]     private sealed class <>c__DisplayClass0_0     {       public int i; // эту переменную дергаем в цикле и лямбда-функции        public <>c__DisplayClass0_0()       {         base..ctor();       }        internal void <Main>b__0()       {         Console.WriteLine(this.i); // тут наша фукнция с выводом       }     }   } } 

Будут везде десятки, так как наша переменная i — часть класса => находится в хипе, общая для всех делегатов, а исполнение наших делегатов начинается после цикла for. Получается, когда делегат начинает своё выполнение он работает с переменной i, которая после «прокрутки» цикла for — принимает значение 10.

Что насчет операций «вычитания», «сложения» делегатов? Фактически мы уже увидели выше, что происходит — мы создаем НОВЫЙ делегат, который хранит ссылки на обьекты и методы всех функций, которые мы ему скормили.

Например:

class Program {     static void Main(string[] args)     {         var cnter = new Counter();         Action act = cnter.Iteration;         act += cnter.Iteration;         act();         act += Console.WriteLine;      } }

На IL:

internal class Program   {     [NullableContext(1)]     private static void Main(string[] args)     {       Counter cnter = new Counter();       Action act1 = (Action) Delegate.Combine((Delegate) new Action((object) cnter, __methodptr(Iteration)), (Delegate) new Action((object) cnter, __methodptr(Iteration)));       act1();       Action act2 = (Action) Delegate.Combine((Delegate) act1, (Delegate) (Program.<>O.<0>__WriteLine ?? (Program.<>O.<0>__WriteLine = new Action((object) null, __methodptr(WriteLine)))));     }      public Program()     {       base..ctor();     }      [CompilerGenerated]     private static class <>O     {       public static Action <0>__WriteLine;     }   }

Мы видим — передаем ссылку на объект + ссылка на метод объекта. Но что будет, если счетчик будет структурой?:

class Program {     static void Main(string[] args)     {         var cnter = new Counter();         Action act = cnter.Iteration;         act += cnter.Iteration;         act += act;         act();         Console.WriteLine(cnter.Num);     } }

IL код:

internal class Program   {     [NullableContext(1)]     private static void Main(string[] args)     {       Counter cnter = new Counter();       Action act = (Action) Delegate.Combine((Delegate) new Action((object) cnter, __methodptr(Iteration)), (Delegate) new Action((object) cnter, __methodptr(Iteration)));       ((Action) Delegate.Combine((Delegate) act, (Delegate) act))();       Console.WriteLine(cnter.Num);     }      public Program()     {       base..ctor();     }   }

Вывод будет :1 Из Iteration
1 Из Iteration
2 Из Iteration
2 Из Iteration
0

Почему же так?
Сперва Action act = cnter.Iteration; создается копия структуры

Далее создается ЕЩЕ одна копия структуры, новый делегат хранит ссылки на 2 разных экземпляра структуры.

А после — мы под капотом храним ссылки на уже готовый делегат. То есть мы снова не создаем объекты. Уже храним ссылки на готовый делегат. Поэтому мы будем работать только с 2 экземплярами нашей структуры. В общем — не путаем функции, на которые мы только-только ссылаем делегаты с уже существующим делегатом.

На этом всё, главное — не забывать о существовании структур и как они передаются!!!