Функциональное программирование в C#: от А до Я — полное руководство

Функциональное программирование в C#: от А до Я

Функциональное программирование (ФП) — это парадигма, рассматривающая вычисления как вычисление математических функций и избегающая изменяемого состояния и побочных эффектов. Несмотря на то, что C# является мультипарадигменным языком с мощной поддержкой объектно-ориентированного программирования (ООП), его современные версии (начиная с C# 3.0 и далее) активно интегрируют элементы функционального стиля. Это позволяет писать более лаконичный, предсказуемый и легко тестируемый код.

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

1. Основы: Лямбда-выражения и Делегаты

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

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

using System;
using System.Collections.Generic;

public class LambdaExample
{
    public static void Main()
    {
        var numbers = new List<int> { 5, 3, 8, 1, 9 };
        
        // Сортировка по убыванию с помощью лямбда-выражения
        numbers.Sort((x, y) => y.CompareTo(x));
        
        Console.WriteLine(string.Join(", ", numbers)); 
        // Вывод: 9, 8, 5, 3, 1
    }
}

Ключевые концепции, которые здесь работают:

• Делегаты Func<> и Action<>: Func<T, TResult> возвращает значение, Action<T> — нет. Лямбды неявно преобразуются к этим типам.
• Замыкания (Closures): Лямбда может захватывать переменные из внешней области видимости, что делает её мощным инструментом, но требует осторожности из-за возможных побочных эффектов.

2. LINQ: Декларативный стиль работы с данными

Language Integrated Query (LINQ) — это, пожалуй, самый яркий пример применения ФП в C#. Он позволяет писать декларативные запросы к коллекциям, базам данных и XML, используя цепочки методов.

Вместо императивных циклов foreach мы используем функциональные операции:

using System;
using System.Linq;
using System.Collections.Generic;

public class LinqExample
{
    public static void Main()
    {
        var people = new List<Person>
        {
            new Person { Name = "Alice", Age = 30 },
            new Person { Name = "Bob", Age = 17 },
            new Person { Name = "Charlie", Age = 25 }
        };

        // Функциональный запрос: фильтрация, проекция, сортировка
        var result = people
            .Where(p => p.Age >= 18)                    // Фильтрация (предикат)
            .OrderBy(p => p.Name)                       // Сортировка
            .Select(p => new { p.Name, IsAdult = true }) // Проекция (анонимный тип)
            .ToList();

        foreach (var item in result)
        {
            Console.WriteLine($"{item.Name} - Adult: {item.IsAdult}");
        }
        // Вывод: Alice - Adult: True, Charlie - Adult: True
    }

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
}

Ключевые операторы LINQ:

• Where — фильтрация (аналог filter).
• Select — преобразование (аналог map).
• Aggregate — свертка (аналог reduce).
• Any, All — проверка условий.

Важно помнить про отложенное выполнение (deferred execution): запрос LINQ выполняется только при переборе результата (например, через ToList() или foreach).

3. Неизменяемость и Чистые функции

Два столпа ФП — это неизменяемость (immutability) и чистые функции (pure functions). Чистая функция всегда возвращает одинаковый результат для одних и тех же аргументов и не имеет побочных эффектов (не изменяет состояние).

В C# мы можем создавать неизменяемые типы с помощью record (C# 9+) или классов со свойствами только для чтения:

using System;

// Record автоматически предоставляет неизменяемость и value-based equality
public record Person(string Name, int Age);

public class FunctionalExample
{
    // Чистая функция: не изменяет входные данные, не имеет побочных эффектов
    public static Person CelebrateBirthday(Person p)
    {
        // Создаем новый экземпляр с измененным возрастом
        return p with { Age = p.Age + 1 };
    }

    public static void Main()
    {
        var original = new Person("Alice", 30);
        var updated = CelebrateBirthday(original);

        Console.WriteLine($"Original: {original}"); // Person { Name = Alice, Age = 30 }
        Console.WriteLine($"Updated: {updated}");   // Person { Name = Alice, Age = 31 }
        // Объект original остался неизменным!
    }
}

Преимущества такого подхода:

• Предсказуемость: Легко отслеживать, где и как меняются данные.
• Потокобезопасность: Неизменяемые объекты можно свободно использовать в многопоточных сценариях без блокировок.
• Тестируемость: Чистые функции легко тестировать изолированно.

4. Продвинутые паттерны: Каррирование и Функторы

Хотя C# не является чистым функциональным языком, вы можете реализовать продвинутые паттерны:

Каррирование (Currying) — преобразование функции с несколькими аргументами в последовательность функций с одним аргументом:

using System;

public class CurryingExample
{
    // Обычная функция
    static Func<int,