Замыкания

Замыкание (closure) представляет объект функции, который запоминает свое лексическое окружение даже в том случае, когда она выполняется вне своей области видимости.

Технически замыкание включает три компонента:

внешняя функция, которая определяет некоторую область видимости и в которой определены некоторые переменные и параметры - лексическое окружение

переменные и параметры (лексическое окружение), которые определены во внешней функции

вложенная функция, которая использует переменные и параметры внешней функции

В языке C# реализовать замыкания можно разными способами - с помощью локальных функций и лямбда-выражений.

Рассмотрим создание замыканий через локальные функции:

var fn = Outer(); // fn = Inner, так как метод Outer возвращает функцию Inner
// вызываем внутреннюю функцию Inner
fn(); // 6
fn(); // 7
fn(); // 8

Action Outer() // метод или внешняя функция
{
int x = 5; // лексическое окружение - локальная переменная
void Inner() // локальная функция
{
x++; // операции с лексическим окружением
Console.WriteLine(x);
}
return Inner; // возвращаем локальную функцию
}
Здесь метод Outer в качестве возвращаемого типа имеет тип Action, то есть метод возвратить функцию, которая не принимает параметров и имеет тип void.

Action Outer()
Внутри метода Outer определена переменная x - это и есть лексическое окружение для внутренней функции:

int x = 5;
Также внутри метода Outer определена внутренняя функция - локальная функция Inner, которая обращается к своему лексическому окружению - переменной x - увеличивает ее значение на единицу и выводит на консоль:

void Inner()
{
x++;
Console.WriteLine(x);
}
Эта локальная функция возвращается методом Outer:

return Inner;
В программе вызываем метод Outer и получаем в переменную fn локальную функцию Inner:

var fn = Outer();
Переменная fn и представляет собой замыкание, то есть объединяет две вещи: функцию и окружение, в котором функция была создана. И несмотря на то, что мы получили локальную функцию и можем ее вызывать вне ее метода, в котором она определена, тем не менее она запомнила свое лексическое окружение и может к нему обращаться и изменять, что мы увидим по консольному выводу:

fn(); // 6
fn(); // 7
fn(); // 8
Реализация с помощью лямбда-выражений
С помощью лямбд можно сократить определение замыкания:

var outerFn = () =>
{
int x = 10;
var innerFn = () => Console.WriteLine(++x);
return innerFn;
};

var fn = outerFn(); // fn = innerFn, так как outerFn возвращает innerFn
// вызываем innerFn
fn(); // 11
fn(); // 12
fn(); // 13
Применение параметров
Кроме внешних переменных к лексическому окружению также относятся параметры окружающего метода. Рассмотрим использование параметров:

var fn = Multiply(5);

Console.WriteLine(fn(5)); // 25
Console.WriteLine(fn(6)); // 30
Console.WriteLine(fn(7)); // 35

Operation Multiply(int n)
{
int Inner(int m)
{
return n * m;
}
return Inner;
}
delegate int Operation(int n);
Здесь внешняя функция - метод Multiply возвращает функцию, которая принимает число int и возвращает число int. Для этого определен делегат Operation, который будет представлять возвращаемый тип:

delegate int Operation(int n);
Хотя также можно было бы использовать встроенный делегат Func<int, int>.

Вызов метода Multiply() возвращает локальную функцию, которая соответствует сигнатуре делегата Operation:

int Inner(int m)
{
return n * m;
}
Эта функция запоминает окружение, в котором она была создана, в частности, значение параметра n. Кроме того, сама принимает параметр и возвращает произведение параметров n и m.

В итоге при вызове метода Multiply определяется переменная fn, которая получает локальную функцию Inner и ее лексическое окружение - значение параметра n:

var fn = Multiply(5);
В данном случае параметр n равен 5.

При вызове локальной функции, например, в случае:

Console.WriteLine(fn(6)); // 30
Число 6 передается для параметра m локальной функции, которая возвращает произведение n и m, то есть 5 * 6 = 30.

Также можно было бы сократить весь этот код с помощью лямбд:

var multiply = (int n) => (int m) => n * m;

var fn = multiply(5);

Console.WriteLine(fn(5)); // 25
Console.WriteLine(fn(6)); // 30
Console.WriteLine(fn(7)); // 35