Цепочки методов в C# с Fluent API

// Традиционный подход
var settings = new Settings();
settings.SetTheme("Dark");
settings.EnableNotifications();
settings.SetFontSize(14);
 
// Fluent-подход
var settings = new Settings()
    .SetTheme("Dark")
    .EnableNotifications()
    .SetFontSize(14);

// Традиционный подход
var calculator = new Calculator(10);
calculator.Add(5);
calculator.Multiply(2);
var result = calculator.Result(); // результат = 30
 
// Fluent-подход
var result = new Calculator(10)
    .Add(5)
    .Multiply(2)
    .Result(); // результат = 30

public class Person
{
    private string _name;
    private int _age;
    
    public Person SetName(string name)
    {
        _name = name;
        return this;
    }
    
    public Person SetAge(int age)
    {
        _age = age;
        return this;
    }
    
    public void ShowDetails()
    {
        Console.WriteLine($"Имя: {_name}, Возраст: {_age}");
    }
}

var person = new Person()
    .SetName("Мария")
    .SetAge(27);
    
person.ShowDetails(); // Вывод: Имя: Мария, Возраст: 27

public class PersonBuilder
{
    private string _name;
    private int _age;
    
    public PersonBuilder WithName(string name)
    {
        if (string.IsNullOrEmpty(name))
            throw new ArgumentException("Имя не может быть пустым");
            
        _name = name;
        return this;
    }
    
    public PersonBuilder WithAge(int age)
    {
        if (age < 0 || age > 150)
            throw new ArgumentException("Некорректный возраст");
            
        _age = age;
        return this;
    }
    
    public Person Build()
    {
        if (string.IsNullOrEmpty(_name))
            throw new InvalidOperationException("Имя не задано");
            
        return new Person(_name, _age);
    }
}

var builder = new QueryBuilder().Where("age > 18");
var query1 = builder.OrderBy("name").Build();
var query2 = builder.OrderBy("age").Build();
 
// Что будет содержать query2?

public class ImmutableQueryBuilder
{
    private readonly List<string> _conditions;
    private readonly List<string> _orderBy;
    
    public ImmutableQueryBuilder()
    {
        _conditions = new List<string>();
        _orderBy = new List<string>();
    }
    
    private ImmutableQueryBuilder(List<string> conditions, List<string> orderBy)
    {
        _conditions = new List<string>(conditions);
        _orderBy = new List<string>(orderBy);
    }
    
    public ImmutableQueryBuilder Where(string condition)
    {
        var newConditions = new List<string>(_conditions) { condition };
        return new ImmutableQueryBuilder(newConditions, _orderBy);
    }
    
    public ImmutableQueryBuilder OrderBy(string field)
    {
        var newOrderBy = new List<string>(_orderBy) { field };
        return new ImmutableQueryBuilder(_conditions, newOrderBy);
    }
}

var baseBuilder = new ImmutableQueryBuilder().Where("age > 18");
var query1 = baseBuilder.OrderBy("name").Build();
var query2 = baseBuilder.OrderBy("age").Build(); // Содержит только условие + сортировку по возрасту

public class ObjectPool<T> where T : class, new()
{
    private readonly ConcurrentBag<T> _objects = new ConcurrentBag<T>();
 
    public T Get() => _objects.TryTake(out T item) ? item : new T();
 
    public void Return(T item) => _objects.Add(item);
}

public class LazyQueryBuilder
{
    private readonly List<Func<string, string>> _transformations = new List<Func<string, string>>();
 
    public LazyQueryBuilder Where(string condition)
    {
        _transformations.Add(query => query + " WHERE " + condition);
        return this;
    }
 
    public LazyQueryBuilder OrderBy(string field)
    {
        _transformations.Add(query => query + " ORDER BY " + field);
        return this;
    }
 
    public string Build()
    {
        return _transformations.Aggregate("SELECT * FROM Users", (query, transform) => transform(query));
    }
}

public struct ValueQueryBuilder
{
    private string _query;
 
    public ValueQueryBuilder(string tableName)
    {
        _query = $"SELECT * FROM {tableName}";
    }
 
    public ValueQueryBuilder Where(string condition)
    {
        _query += " WHERE " + condition;
        return this;
    }
 
    public string Build() => _query;
}

public class ThreadSafeBuilder
{
    private readonly object _lock = new object();
    private string _name;
 
    public ThreadSafeBuilder WithName(string name)
    {
        lock (_lock)
        {
            _name = name;
            return this;
        }
    }
 
    public string Build()
    {
        lock (_lock)
        {
            return _name;
        }
    }
}

public class ImmutableBuilder
{
    private readonly string _name;
 
    public ImmutableBuilder() : this(string.Empty) { }
 
    private ImmutableBuilder(string name)
    {
        _name = name;
    }
 
    public ImmutableBuilder WithName(string name)
    {
        return new ImmutableBuilder(name);
    }
 
    public string Build() => _name;
}

public class Result<T>
{
    public bool IsSuccess { get; }
    public string Error { get; }
    public T Value { get; }
 
    private Result(bool isSuccess, T value, string error)
    {
        IsSuccess = isSuccess;
        Value = value;
        Error = error;
    }
 
    public static Result<T> Success(T value) => new Result<T>(true, value, null);
    public static Result<T> Failure(string error) => new Result<T>(false, default, error);
}
 
public class FluentCalculator
{
    private int _value;
    private string _error;
 
    public FluentCalculator(int initial)
    {
        _value = initial;
    }
 
    public FluentCalculator Divide(int divisor)
    {
        if (divisor == 0)
        {
            _error = "Деление на ноль недопустимо";
            return this;
        }
        
        _value /= divisor;
        return this;
    }
 
    public Result<int> GetResult()
    {
        if (_error != null)
            return Result<int>.Failure(_error);
            
        return Result<int>.Success(_value);
    }
}

var result = new FluentCalculator(10)
    .Divide(2)
    .Divide(0)  // Ошибка, но цепочка продолжается
    .Divide(5)
    .GetResult();
 
if (result.IsSuccess)
    Console.WriteLine($"Результат: {result.Value}");
else
    Console.WriteLine($"Ошибка: {result.Error}");

public class EmailBuilder
{
    private string _to;
    private string _subject;
    private string _body;
 
    public EmailBuilder To(string recipient)
    {
        _to = recipient;
        return this;
    }
 
    public EmailBuilder WithSubject(string subject)
    {
        _subject = subject;
        return this;
    }
 
    public EmailBuilder WithBody(string body)
    {
        _body = body;
        return this;
    }
 
    // Метод-терминатор
    public Email Build()
    {
        if (string.IsNullOrEmpty(_to))
            throw new InvalidOperationException("Получатель не указан");
            
        return new Email(_to, _subject, _body);
    }
    
    // Альтернативный терминатор
    public void Send()
    {
        var email = Build();
        // Логика отправки email
        Console.WriteLine($"Email отправлен на адрес {_to}");
    }
}

public static class StringExtensions
{
    public static StringBuilder AppendIf(this StringBuilder builder, bool condition, string value)
    {
        if (condition)
            builder.Append(value);
        return builder;
    }
 
    public static StringBuilder AppendLineIf(this StringBuilder builder, bool condition, string value)
    {
        if (condition)
            builder.AppendLine(value);
        return builder;
    }
}

var isAdmin = true;
var isNewUser = false;
 
var message = new StringBuilder()
    .Append("Здравствуйте, ")
    .Append(userName)
    .AppendLine("!")
    .AppendIf(isAdmin, "У вас есть права администратора. ")
    .AppendLineIf(isNewUser, "Добро пожаловать в систему!")
    .ToString();

public class Query<T>
{
    private readonly IEnumerable<T> _source;
    private readonly List<Func<T, bool>> _filters = new List<Func<T, bool>>();
 
    public Query(IEnumerable<T> source)
    {
        _source = source;
    }
 
    public Query<T> Where(Func<T, bool> predicate)
    {
        _filters.Add(predicate);
        return this;
    }
 
    public IEnumerable<T> Execute()
    {
        IEnumerable<T> result = _source;
        
        foreach (var filter in _filters)
        {
            result = result.Where(filter);
        }
        
        return result;
    }
}

var users = new List<User>() { /* ... */ };
 
var activeAdmins = new Query<User>(users)
    .Where(u => u.IsActive)
    .Where(u => u.Role == "Admin")
    .Execute()
    .ToList();

public class SqlQueryBuilder
{
    private string _table;
    private readonly List<string> _columns = new List<string>();
    private readonly List<string> _conditions = new List<string>();
    private readonly List<string> _orderBy = new List<string>();
    private int? _limit;
 
    public SqlQueryBuilder FromTable(string tableName)
    {
        _table = tableName;
        return this;
    }
 
    public SqlQueryBuilder Select(params string[] columns)
    {
        _columns.AddRange(columns);
        return this;
    }
 
    public SqlQueryBuilder Where(string condition)
    {
        _conditions.Add(condition);
        return this;
    }
 
    public SqlQueryBuilder OrderBy(string column, bool ascending = true)
    {
        _orderBy.Add($"{column} {(ascending ? "ASC" : "DESC")}");
        return this;
    }
 
    public SqlQueryBuilder Limit(int count)
    {
        _limit = count;
        return this;
    }
 
    public string Build()
    {
        if (string.IsNullOrEmpty(_table))
            throw new InvalidOperationException("Таблица не указана");
 
        var query = new StringBuilder();
        
        query.Append("SELECT ");
        query.Append(_columns.Any() ? string.Join(", ", _columns) : "*");
        query.Append($" FROM {_table}");
 
        if (_conditions.Any())
            query.Append($" WHERE {string.Join(" AND ", _conditions)}");
 
        if (_orderBy.Any())
            query.Append($" ORDER BY {string.Join(", ", _orderBy)}");
 
        if (_limit.HasValue)
            query.Append($" LIMIT {_limit}");
 
        return query.ToString();
    }
}

var query = new SqlQueryBuilder()
    .FromTable("Users")
    .Select("Id", "Name", "Email")
    .Where("Age > 18")
    .Where("IsActive = 1")
    .OrderBy("LastLogin", ascending: false)
    .Limit(10)
    .Build();
 
// Результат: SELECT Id, Name, Email FROM Users WHERE Age > 18 AND IsActive = 1 ORDER BY LastLogin DESC LIMIT 10

public class WebServiceConfigurator
{
    private readonly WebServiceOptions _options = new WebServiceOptions();
 
    public WebServiceConfigurator WithPort(int port)
    {
        _options.Port = port;
        return this;
    }
 
    public WebServiceConfigurator WithMaxConnections(int maxConnections)
    {
        _options.MaxConnections = maxConnections;
        return this;
    }
 
    public WebServiceConfigurator EnableLogging(bool enabled = true)
    {
        _options.LoggingEnabled = enabled;
        return this;
    }
 
    public WebServiceConfigurator WithAuthenticationProvider(IAuthProvider provider)
    {
        _options.AuthProvider = provider;
        return this;
    }
 
    public WebService Create()
    {
        return new WebService(_options);
    }
}

var service = new WebServiceConfigurator()
    .WithPort(8080)
    .WithMaxConnections(100)
    .EnableLogging()
    .WithAuthenticationProvider(new OAuth2Provider())
    .Create();

public class OrderBuilder
{
    private readonly Order _order = new Order();
    private readonly List<OrderItem> _items = new List<OrderItem>();
    private readonly List<string> _validationErrors = new List<string>();
 
    public OrderBuilder ForCustomer(Customer customer)
    {
        _order.CustomerId = customer.Id;
        _order.CustomerEmail = customer.Email;
        return this;
    }
 
    public OrderBuilder WithShippingAddress(Address address)
    {
        _order.ShippingAddress = address;
        return this;
    }
 
    public OrderBuilder WithPaymentMethod(PaymentMethod paymentMethod)
    {
        _order.PaymentMethod = paymentMethod;
        return this;
    }
 
    public OrderBuilder AddItem(Product product, int quantity)
    {
        if (quantity <= 0)
        {
            _validationErrors.Add($"Количество для продукта {product.Id} должно быть положительным");
            return this;
        }
 
        var item = new OrderItem
        {
            ProductId = product.Id,
            ProductName = product.Name,
            Price = product.Price,
            Quantity = quantity
        };
 
        _items.Add(item);
        return this;
    }
 
    public Order Build()
    {
        // Проверяем наличие ошибок валидации
        if (_validationErrors.Any())
            throw new OrderValidationException(_validationErrors);
 
        // Проверяем обязательные поля
        if (_order.CustomerId == 0)
            throw new OrderValidationException("Не указан покупатель");
 
        if (_order.ShippingAddress == null)
            throw new OrderValidationException("Не указан адрес доставки");
 
        if (!_items.Any())
            throw new OrderValidationException("Корзина пуста");
 
        // Рассчитываем итоговую сумму
        _order.TotalAmount = _items.Sum(i => i.Price * i.Quantity);
        _order.Items = _items;
        _order.CreatedAt = DateTime.UtcNow;
 
        return _order;
    }
}

var order = new OrderBuilder()
    .ForCustomer(customer)
    .WithShippingAddress(address)
    .WithPaymentMethod(PaymentMethod.CreditCard)
    .AddItem(laptop, 1)
    .AddItem(mouse, 2)
    .Build();

var adults = persons
    .Where(p => p.Age >= 18)
    .OrderBy(p => p.LastName)
    .ThenBy(p => p.FirstName)
    .Select(p => new { p.FullName, p.Age })
    .ToList();

public class EmployeeCollection
{
    private readonly List<Employee> _employees;
 
    public EmployeeCollection(IEnumerable<Employee> employees)
    {
        _employees = new List<Employee>(employees);
    }
 
    public EmployeeCollection ActiveOnly()
    {
        return new EmployeeCollection(_employees.Where(e => e.IsActive));
    }
 
    public EmployeeCollection InDepartment(string department)
    {
        return new EmployeeCollection(_employees.Where(e => e.Department == department));
    }
 
    public EmployeeCollection WithExperience(int minYears)
    {
        return new EmployeeCollection(_employees.Where(e => e.YearsOfExperience >= minYears));
    }
 
    public EmployeeCollection SortByExperience()
    {
        return new EmployeeCollection(_employees.OrderByDescending(e => e.YearsOfExperience));
    }
 
    public List<Employee> ToList() => new List<Employee>(_employees);
}

var seniorDevelopers = new EmployeeCollection(allEmployees)
    .ActiveOnly()
    .InDepartment("Development")
    .WithExperience(5)
    .SortByExperience()
    .ToList();

public class Validator<T>
{
    private readonly T _obj;
    private readonly List<string> _errors = new List<string>();
 
    public Validator(T obj)
    {
        _obj = obj;
    }
 
    public Validator<T> Verify(Func<T, bool> predicate, string errorMessage)
    {
        if (!predicate(_obj))
            _errors.Add(errorMessage);
            
        return this;
    }
 
    public Validator<T> VerifyNotNull<TProperty>(Func<T, TProperty> selector, string propertyName)
    {
        if (selector(_obj) == null)
            _errors.Add($"{propertyName} не может быть пустым");
            
        return this;
    }
 
    public ValidationResult GetResult()
    {
        return new ValidationResult(_errors);
    }
}
 
public class ValidationResult
{
    public bool IsValid => !Errors.Any();
    public IReadOnlyList<string> Errors { get; }
 
    public ValidationResult(IEnumerable<string> errors)
    {
        Errors = new List<string>(errors);
    }
}

var result = new Validator<User>(user)
    .VerifyNotNull(u => u.Name, "Имя")
    .VerifyNotNull(u => u.Email, "Email")
    .Verify(u => u.Email.Contains("@"), "Email должен содержать символ @")
    .Verify(u => u.Age >= 18, "Возраст должен быть не менее 18 лет")
    .GetResult();
 
if (!result.IsValid)
{
    foreach (var error in result.Errors)
        Console.WriteLine(error);
}

public class ScheduleBuilder
{
    private readonly Schedule _schedule = new Schedule();
 
    public DayScheduleBuilder OnMonday => ConfigureDay(DayOfWeek.Monday);
    public DayScheduleBuilder OnTuesday => ConfigureDay(DayOfWeek.Tuesday);
    public DayScheduleBuilder OnWednesday => ConfigureDay(DayOfWeek.Wednesday);
    public DayScheduleBuilder OnThursday => ConfigureDay(DayOfWeek.Thursday);
    public DayScheduleBuilder OnFriday => ConfigureDay(DayOfWeek.Friday);
    
    private DayScheduleBuilder ConfigureDay(DayOfWeek day)
    {
        return new DayScheduleBuilder(this, _schedule, day);
    }
 
    public Schedule Build() => _schedule;
}
 
public class DayScheduleBuilder
{
    private readonly ScheduleBuilder _parent;
    private readonly Schedule _schedule;
    private readonly DayOfWeek _day;
 
    public DayScheduleBuilder(ScheduleBuilder parent, Schedule schedule, DayOfWeek day)
    {
        _parent = parent;
        _schedule = schedule;
        _day = day;
    }
 
    public TimeSlotBuilder At(TimeSpan time) => new TimeSlotBuilder(this, _schedule, _day, time);
}
 
public class TimeSlotBuilder
{
    private readonly DayScheduleBuilder _parent;
    private readonly Schedule _schedule;
    private readonly DayOfWeek _day;
    private readonly TimeSpan _startTime;
 
    public TimeSlotBuilder(DayScheduleBuilder parent, Schedule schedule, DayOfWeek day, TimeSpan startTime)
    {
        _parent = parent;
        _schedule = schedule;
        _day = day;
        _startTime = startTime;
    }
 
    public DayScheduleBuilder Schedule(string activity, TimeSpan duration)
    {
        _schedule.AddActivity(_day, _startTime, activity, duration);
        return _parent;
    }
}

var schedule = new ScheduleBuilder()
    .OnMonday
        .At(new TimeSpan(9, 0, 0))
        .Schedule("Встреча команды", TimeSpan.FromHours(1))
        .At(new TimeSpan(13, 0, 0))
        .Schedule("Обед", TimeSpan.FromMinutes(45))
    .OnWednesday
        .At(new TimeSpan(14, 30, 0))
        .Schedule("Код-ревью", TimeSpan.FromHours(1.5))
    .Build();

public class ImageProcessor
{
    private readonly Image _image;
 
    public ImageProcessor(Image image)
    {
        _image = image;
    }
 
    public ImageProcessor Resize(int width, int height)
    {
        // Логика изменения размера
        Console.WriteLine($"Изображение изменено до {width}x{height}");
        return this;
    }
 
    public ImageProcessor Rotate(int degrees)
    {
        // Логика поворота
        Console.WriteLine($"Изображение повернуто на {degrees} градусов");
        return this;
    }
 
    public ImageProcessor ApplyFilter(string filterName)
    {
        // Логика применения фильтра
        Console.WriteLine($"Применен фильтр {filterName}");
        return this;
    }
 
    public ImageProcessor Crop(int x, int y, int width, int height)
    {
        // Логика обрезки
        Console.WriteLine($"Изображение обрезано: ({x},{y}) {width}x{height}");
        return this;
    }
 
    public Image GetResult()
    {
        return _image;
    }
}

var processedImage = new ImageProcessor(originalImage)
    .Resize(800, 600)
    .Rotate(90)
    .Crop(50, 50, 700, 500)
    .ApplyFilter("Sepia")
    .GetResult();

public class ApiRequestBuilder
{
    private readonly HttpClient _client;
    private readonly string _baseUrl;
    private readonly Dictionary<string, string> _headers = new Dictionary<string, string>();
    private readonly Dictionary<string, string> _queryParams = new Dictionary<string, string>();
 
    public ApiRequestBuilder(HttpClient client, string baseUrl)
    {
        _client = client;
        _baseUrl = baseUrl;
    }
 
    public ApiRequestBuilder WithHeader(string name, string value)
    {
        _headers[name] = value;
        return this;
    }
 
    public ApiRequestBuilder WithParameter(string name, string value)
    {
        _queryParams[name] = value;
        return this;
    }
 
    public async Task<HttpResponseMessage> GetAsync(string endpoint)
    {
        var request = CreateRequest(HttpMethod.Get, endpoint);
        return await _client.SendAsync(request);
    }
 
    public async Task<HttpResponseMessage> PostAsync(string endpoint, HttpContent content)
    {
        var request = CreateRequest(HttpMethod.Post, endpoint);
        request.Content = content;
        return await _client.SendAsync(request);
    }
 
    private HttpRequestMessage CreateRequest(HttpMethod method, string endpoint)
    {
        var uriBuilder = new UriBuilder(_baseUrl)
        {
            Path = endpoint
        };
 
        // Добавляем query-параметры
        if (_queryParams.Any())
        {
            var query = string.Join("&", _queryParams.Select(p => $"{Uri.EscapeDataString(p.Key)}={Uri.EscapeDataString(p.Value)}"));
            uriBuilder.Query = query;
        }
 
        var request = new HttpRequestMessage(method, uriBuilder.Uri);
 
        // Добавляем заголовки
        foreach (var header in _headers)
        {
            request.Headers.Add(header.Key, header.Value);
        }
 
        return request;
    }
}

var api = new ApiRequestBuilder(httpClient, "https://api.example.com")
    .WithHeader("Authorization", "Bearer token123")
    .WithParameter("page", "1")
    .WithParameter("limit", "10");
 
// Выполнение GET-запроса
var response = await api.GetAsync("/users");
 
// Выполнение POST-запроса
var content = new StringContent("{\"name\":\"John\"}", Encoding.UTF8, "application/json");
var createResponse = await api.PostAsync("/users", content);

public interface IQueryBuilder
{
    IWhereBuilder Select(params string[] columns);
}
 
public interface IWhereBuilder
{
    IOrderBuilder Where(string condition);
    IOrderBuilder WhereAll();
}
 
public interface IOrderBuilder
{
    IExecutableBuilder OrderBy(string column);
    IExecutableBuilder OrderByDescending(string column);
    IExecutableBuilder Skip(int count);
    IExecutableBuilder Take(int count);
}
 
public interface IExecutableBuilder
{
    string Build();
    Task<IEnumerable<T>> ExecuteAsync<T>();
}

public class SqlBuilder : IQueryBuilder, IWhereBuilder, IOrderBuilder, IExecutableBuilder
{
    private string _table;
    private List<string> _columns = new List<string>();
    private List<string> _conditions = new List<string>();
    private string _orderBy;
    private int? _skip;
    private int? _take;
    
    public IWhereBuilder Select(params string[] columns)
    {
        _columns.AddRange(columns);
        return this;
    }
    
    public IOrderBuilder Where(string condition)
    {
        _conditions.Add(condition);
        return this;
    }
    
    public IOrderBuilder WhereAll()
    {
        return this;
    }
    
    public IExecutableBuilder OrderBy(string column)
    {
        _orderBy = $"{column} ASC";
        return this;
    }
    
    public IExecutableBuilder OrderByDescending(string column)
    {
        _orderBy = $"{column} DESC";
        return this;
    }
    
    public IExecutableBuilder Skip(int count)
    {
        _skip = count;
        return this;
    }
    
    public IExecutableBuilder Take(int count)
    {
        _take = count;
        return this;
    }
    
    public string Build()
    {
        // Формирование SQL-запроса
        return "SQL query";
    }
    
    public async Task<IEnumerable<T>> ExecuteAsync<T>()
    {
        // Выполнение запроса
        return await Task.FromResult(Enumerable.Empty<T>());
    }
}

var builder = new SqlBuilder();
var result = await builder
    .Select("Id", "Name")
    .Where("Age > 18")
    .OrderByDescending("LastVisit")
    .Take(10)
    .ExecuteAsync<User>();

public class Result<T>
{
    public bool IsSuccess { get; }
    public T Value { get; }
    public string Error { get; }
    
    private Result(bool isSuccess, T value, string error)
    {
        IsSuccess = isSuccess;
        Value = value;
        Error = error;
    }
    
    public static Result<T> Success(T value) => new Result<T>(true, value, null);
    public static Result<T> Failure(string error) => new Result<T>(false, default, error);
    
    public Result<TNext> Then<TNext>(Func<T, Result<TNext>> next)
    {
        if (!IsSuccess)
            return Result<TNext>.Failure(Error);
            
        try
        {
            return next(Value);
        }
        catch (Exception ex)
        {
            return Result<TNext>.Failure(ex.Message);
        }
    }
    
    public Result<T> Catch(Action<string> errorHandler)
    {
        if (!IsSuccess)
            errorHandler(Error);
            
        return this;
    }
}

var result = UserRepository.FindById(userId)
    .Then(user => UserValidator.Validate(user))
    .Then(user => user.UpdateProfile(profileData))
    .Then(user => UserRepository.Save(user))
    .Catch(error => Logger.LogError(error));
    
if (result.IsSuccess)
    return Ok(result.Value);
else
    return BadRequest(result.Error);

public class EmailBuilder
{
    private readonly Email _email = new Email();
    
    public RecipientBuilder To(string address)
    {
        _email.To = address;
        return new RecipientBuilder(_email);
    }
}
 
public class RecipientBuilder
{
    private readonly Email _email;
    
    public RecipientBuilder(Email email)
    {
        _email = email;
    }
    
    public ContentBuilder WithSubject(string subject)
    {
        _email.Subject = subject;
        return new ContentBuilder(_email);
    }
}
 
public class ContentBuilder
{
    private readonly Email _email;
    
    public ContentBuilder(Email email)
    {
        _email = email;
    }
    
    public AttachmentBuilder WithBody(string body)
    {
        _email.Body = body;
        return new AttachmentBuilder(_email);
    }
}
 
public class AttachmentBuilder
{
    private readonly Email _email;
    
    public AttachmentBuilder(Email email)
    {
        _email = email;
    }
    
    public AttachmentBuilder Attach(string filename)
    {
        _email.Attachments.Add(filename);
        return this;
    }
    
    public Email Build()
    {
        return _email;
    }
}

var email = new EmailBuilder()
    .To("recipient@example.com")
    .WithSubject("Важное сообщение")
    .WithBody("Текст сообщения")
    .Attach("document.pdf")
    .Build();

<#@ template language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Collections.Generic" #>
<#
var properties = new[] {
    new { Name = "FirstName", Type = "string" },
    new { Name = "LastName", Type = "string" },
    new { Name = "Age", Type = "int" },
    new { Name = "Email", Type = "string" }
};
#>
using System;
 
namespace Builders {
    public class PersonBuilder {
        private Person _person = new Person();
        
<# foreach(var prop in properties) { #>
        public PersonBuilder With<#= prop.Name #>(<#= prop.Type #> value) {
            _person.<#= prop.Name #> = value;
            return this;
        }
        
<# } #>
        public Person Build() {
            return _person;
        }
    }
}

/// <summary>
/// Строитель SQL-запросов с Fluent-интерфейсом.
/// </summary>
public class QueryBuilder
{
    /// <summary>
    /// Указывает таблицу для запроса.
    /// </summary>
    /// <param name="tableName">Имя таблицы.</param>
    /// <returns>Текущий билдер для продолжения цепочки вызовов.</returns>
    /// <example>
    /// <code>
    /// var query = new QueryBuilder()
    ///     .FromTable("Users")
    ///     .Select("Id", "Name");
    /// </code>
    /// </example>
    public QueryBuilder FromTable(string tableName)
    {
        // Реализация
        return this;
    }
}

// Слишком простой случай — перегрузка не нужна
public void SaveUser(User user)
{
    // Простая операция сохранения
}
 
// Лучше, чем избыточный Fluent API
public void SaveUser(User user, bool sendNotification = false, bool logActivity = true)
{
    // Реализация с опциональными параметрами
}
 
// Избыточно сложно для такой задачи
var repository = new UserRepositoryBuilder()
.WithNotifications()
.WithLogging()
.Build()
.SaveUser(user);

// Избыточно сложный API
var query = new FluentQueryBuilder()
.From<User>()
.Where(q => 
    q.Property(u => u.Active).EqualTo(true)
    .And()
    .Property(u => u.LastLogin).GreaterThan(DateTime.Now.AddDays(-30))
)
.OrderByDescending(u => u.LastLogin)
.Select(u => new { u.Id, u.Name })
.GetResult();
 
// Более сбалансированный подход
var query = new QueryBuilder<User>()
.Where(u => u.Active && u.LastLogin > DateTime.Now.AddDays(-30))
.OrderByDescending(u => u.LastLogin)
.Select(u => new { u.Id, u.Name })
.GetResult();

// Тестирование отдельных компонентов билдера
[Fact]
public void WithName_ShouldSetName()
{
    // Arrange
    var builder = new PersonBuilder();
    
    // Act
    builder.WithName("Алексей");
    var person = builder.Build();
    
    // Assert
    Assert.Equal("Алексей", person.Name);
}
 
// Тестирование всей цепочки
[Fact]
public void FluentChain_ShouldBuildCorrectPerson()
{
    // Arrange & Act
    var person = new PersonBuilder()
        .WithName("Алексей")
        .WithAge(25)
        .WithEmail("aleksey@example.com")
        .Build();
    
    // Assert
    Assert.Equal("Алексей", person.Name);
    Assert.Equal(25, person.Age);
    Assert.Equal("aleksey@example.com", person.Email);
}

// До рефакторинга
public class Report
{
    public void SetTitle(string title) { /* ... */ }
    public void AddSection(string section) { /* ... */ }
    public void SetFormat(Format format) { /* ... */ }
    public void Generate() { /* ... */ }
}
 
// Использование
var report = new Report();
report.SetTitle("Квартальный отчет");
report.AddSection("Доходы");
report.AddSection("Расходы");
report.SetFormat(Format.PDF);
report.Generate();

// После рефакторинга
public class Report
{
    public Report WithTitle(string title) { /* ... */ return this; }
    public Report AddSection(string section) { /* ... */ return this; }
    public Report WithFormat(Format format) { /* ... */ return this; }
    public void Generate() { /* ... */ }
}
 
// Использование
new Report()
    .WithTitle("Квартальный отчет")
    .AddSection("Доходы")
    .AddSection("Расходы")
    .WithFormat(Format.PDF)
    .Generate();

// Fluent API (билдер)
var person = new PersonBuilder()
.WithName("Михаил")
.WithAge(34)
.WithEmail("mikhail@example.com")
.Build();
 
// Инициализатор объекта
var person = new Person
{
    Name = "Михаил",
    Age = 34,
    Email = "mikhail@example.com"
};

// Fluent-класс
var query = new QueryBuilder("Users")
.Where("Age > 18")
.OrderBy("LastVisit")
.Build();
 
// Extension-методы
var query = "Users"
.AsQuery()
.Where("Age > 18")
.OrderBy("LastVisit")
.Build();

// Fluent OOP-стиль
var result = new Validator<User>(user)
.Verify(u => u.Age >= 18, "Возраст должен быть не менее 18")
.Verify(u => !string.IsNullOrEmpty(u.Email), "Email обязателен")
.GetResult();
 
// Функциональный стиль
var validateAge = (User u) => u.Age >= 18 
    ? Ok(u) 
    : Error("Возраст должен быть не менее 18");
    
var validateEmail = (User u) => !string.IsNullOrEmpty(u.Email) 
    ? Ok(u) 
    : Error("Email обязателен");
    
var result = validateAge(user)
    .Bind(validateEmail);

// Смешивание запросов и команд в Fluent API
var user = repository.GetUser(id)
.Update(updatedInfo)
.CalculateRating()
.Save();
 
// Разделение запросов и команд
var user = repository.GetUser(id);
user.Update(updatedInfo);
var rating = ratingCalculator.Calculate(user);
repository.Save(user);

// Традиционный Fluent API для неизменяемых объектов
var person = new PersonBuilder()
.WithName("Анна")
.WithAge(29)
.Build();
 
// Использование рекордов с шаблоном with
record Person(string Name, int Age);
 
var anna = new Person("Анна", 29);
var olderAnna = anna with { Age = 30 };