Паттерны проектирования GoF на C#

public sealed class Singleton
{
    private static readonly Lazy<Singleton> lazyInstance = 
        new Lazy<Singleton>(() => new Singleton());
    
    public static Singleton Instance => lazyInstance.Value;
    
    private Singleton() { }
    
    public void SomeBusinessLogic()
    {
        // Код, реализующий основную функциональность
    }
}

public interface IProduct
{
    string Operation();
}
 
public class ConcreteProductA : IProduct
{
    public string Operation() => "Result of ConcreteProductA";
}
 
public class ConcreteProductB : IProduct
{
    public string Operation() => "Result of ConcreteProductB";
}
 
public abstract class Creator
{
    public abstract IProduct FactoryMethod();
    
    public string SomeOperation()
    {
        var product = FactoryMethod();
        return $"Creator worked with {product.Operation()}";
    }
}
 
public class ConcreteCreatorA : Creator
{
    public override IProduct FactoryMethod() => new ConcreteProductA();
}
 
public class ConcreteCreatorB : Creator
{
    public override IProduct FactoryMethod() => new ConcreteProductB();
}

public static class ProductFactory
{
    public static IProduct CreateProduct(string type)
    {
        switch (type)
        {
            case "A": return new ConcreteProductA();
            case "B": return new ConcreteProductB();
            default: throw new ArgumentException("Unknown product type");
        }
    }
}

// Интерфейсы продуктов
public interface IButton
{
    void Render();
    void HandleClick();
}
 
public interface ITextBox
{
    void Render();
    void HandleInput();
}
 
// Конкретные продукты для Windows
public class WindowsButton : IButton
{
    public void Render() => Console.WriteLine("Rendering Windows-style button");
    public void HandleClick() => Console.WriteLine("Windows button clicked");
}
 
public class WindowsTextBox : ITextBox
{
    public void Render() => Console.WriteLine("Rendering Windows-style text box");
    public void HandleInput() => Console.WriteLine("Handling input in Windows text box");
}
 
// Конкретные продукты для macOS
public class MacOSButton : IButton
{
    public void Render() => Console.WriteLine("Rendering macOS-style button");
    public void HandleClick() => Console.WriteLine("macOS button clicked");
}
 
public class MacOSTextBox : ITextBox
{
    public void Render() => Console.WriteLine("Rendering macOS-style text box");
    public void HandleInput() => Console.WriteLine("Handling input in macOS text box");
}
 
// Абстрактная фабрика
public interface IUIFactory
{
    IButton CreateButton();
    ITextBox CreateTextBox();
}
 
// Конкретные фабрики
public class WindowsUIFactory : IUIFactory
{
    public IButton CreateButton() => new WindowsButton();
    public ITextBox CreateTextBox() => new WindowsTextBox();
}
 
public class MacOSUIFactory : IUIFactory
{
    public IButton CreateButton() => new MacOSButton();
    public ITextBox CreateTextBox() => new MacOSTextBox();
}

public class Product
{
public string PartA { get; set; }
public string PartB { get; set; }
public string PartC { get; set; }
public int PartD { get; set; }
public bool PartE { get; set; }
 
public override string ToString() =>
    $"Product parts: {PartA}, {PartB}, {PartC}, {PartD}, {PartE}";
}
 
public interface IBuilder
{
IBuilder BuildPartA();
IBuilder BuildPartB(string value);
IBuilder BuildPartC(string value);
IBuilder BuildPartD(int value);
IBuilder BuildPartE(bool value);
Product GetResult();
}
 
public class ConcreteBuilder : IBuilder
{
private readonly Product _product = new Product();
 
public IBuilder BuildPartA()
{
    _product.PartA = "Part A default";
    return this;
}
 
public IBuilder BuildPartB(string value)
{
    _product.PartB = value;
    return this;
}
 
public IBuilder BuildPartC(string value)
{
    _product.PartC = value;
    return this;
}
 
public IBuilder BuildPartD(int value)
{
    _product.PartD = value;
    return this;
}
 
public IBuilder BuildPartE(bool value)
{
    _product.PartE = value;
    return this;
}
 
public Product GetResult() => _product;
}

var builder = new ConcreteBuilder();
var product = builder
    .BuildPartA()
    .BuildPartB("Custom Part B")
    .BuildPartE(true)
    .GetResult();

var product = new Product
{
    PartA = "Part A default",
    PartB = "Custom Part B",
    PartE = true
};

public interface IPrototype<T>
{
T Clone();
}
 
public class ConcretePrototype : IPrototype<ConcretePrototype>
{
public string Property1 { get; set; }
public int Property2 { get; set; }
public ComplexObject ComplexProperty { get; set; }
 
public ConcretePrototype Clone()
{
    // Создаём новый экземпляр
    var clone = new ConcretePrototype
    {
        Property1 = this.Property1,
        Property2 = this.Property2,
        // Глубокое клонирование для сложных объектов
        ComplexProperty = this.ComplexProperty?.Clone()
    };
    
    return clone;
}
}
 
// Вспомогательный класс для демонстрации глубокого клонирования
public class ComplexObject : IPrototype<ComplexObject>
{
public string Data { get; set; }
 
public ComplexObject Clone() => new ComplexObject { Data = this.Data };
}

// 1. Классический Singleton с двойной проверкой блокировки
public sealed class ClassicSingleton
{
private static ClassicSingleton _instance;
private static readonly object _lock = new object();
    
private ClassicSingleton() { /* Тяжелая инициализация */ }
    
public static ClassicSingleton Instance
{
    get
    {
        if (_instance == null)
        {
            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = new ClassicSingleton();
                }
            }
        }
        return _instance;
    }
}
}
 
// 2. Ленивый Singleton с Lazy<T>
public sealed class LazySingleton
{
private static readonly Lazy<LazySingleton> _lazyInstance = 
    new Lazy<LazySingleton>(() => new LazySingleton());
    
private LazySingleton() { /* Тяжелая инициализация */ }
    
public static LazySingleton Instance => _lazyInstance.Value;
}
 
// 3. Singleton со статическим конструктором
public sealed class StaticSingleton
{
private static readonly StaticSingleton _instance = new StaticSingleton();
    
static StaticSingleton() { }
private StaticSingleton() { /* Тяжелая инициализация */ }
    
public static StaticSingleton Instance => _instance;
}

// Было
public void SomeMethod()
{
var logger = Logger.Instance;
logger.Log("Some message");
}
 
// Стало
public class Service
{
private readonly ILogger _logger;
 
public Service(ILogger logger)
{
    _logger = logger;
}
 
public void SomeMethod()
{
    _logger.Log("Some message");
}
}
 
// В конфигурации DI-контейнера
services.AddSingleton<ILogger, Logger>();

// Существующий интерфейс, к которому нужно адаптироваться
public interface ITarget
{
    string GetRequest();
}
 
// Несовместимый класс, который нужно использовать
public class Adaptee
{
    public string GetSpecificRequest()
    {
        return "Specific request from the adaptee";
    }
}
 
// Адаптер, который связывает несовместимые интерфейсы
public class Adapter : ITarget
{
    private readonly Adaptee _adaptee;
 
    public Adapter(Adaptee adaptee)
    {
        _adaptee = adaptee;
    }
 
    public string GetRequest()
    {
        // Адаптируем вызов к специфичному интерфейсу Adaptee
        return $"Adapter: {_adaptee.GetSpecificRequest()}";
    }
}

// Интерфейс реализации
public interface IImplementation
{
    string OperationImplementation();
}
 
// Конкретные реализации
public class ConcreteImplementationA : IImplementation
{
    public string OperationImplementation()
    {
        return "ConcreteImplementationA";
    }
}
 
public class ConcreteImplementationB : IImplementation
{
    public string OperationImplementation()
    {
        return "ConcreteImplementationB";
    }
}
 
// Абстракция
public class Abstraction
{
    protected IImplementation _implementation;
 
    public Abstraction(IImplementation implementation)
    {
        _implementation = implementation;
    }
 
    public virtual string Operation()
    {
        return $"Abstraction: {_implementation.OperationImplementation()}";
    }
}
 
// Расширенная абстракция
public class ExtendedAbstraction : Abstraction
{
    public ExtendedAbstraction(IImplementation implementation) : base(implementation)
    {
    }
 
    public override string Operation()
    {
        return $"ExtendedAbstraction: {_implementation.OperationImplementation()}";
    }
}

// Базовый компонент
public abstract class Component
{
    public string Name { get; }
 
    protected Component(string name)
    {
        Name = name;
    }
 
    public abstract void Add(Component component);
    public abstract void Remove(Component component);
    public abstract bool IsComposite();
    public abstract string Operation();
}
 
// Лист - простой компонент, который не может иметь вложенных компонентов
public class Leaf : Component
{
    public Leaf(string name) : base(name)
    {
    }
 
    public override void Add(Component component)
    {
        throw new NotImplementedException("Нельзя добавлять элементы в Leaf");
    }
 
    public override void Remove(Component component)
    {
        throw new NotImplementedException("Нельзя удалять элементы из Leaf");
    }
 
    public override bool IsComposite() => false;
 
    public override string Operation() => $"Leaf: {Name}";
}
 
// Составной компонент, который может содержать другие компоненты
public class Composite : Component
{
    private readonly List<Component> _children = new List<Component>();
 
    public Composite(string name) : base(name)
    {
    }
 
    public override void Add(Component component)
    {
        _children.Add(component);
    }
 
    public override void Remove(Component component)
    {
        _children.Remove(component);
    }
 
    public override bool IsComposite() => true;
 
    public override string Operation()
    {
        int level = 0;
        StringBuilder result = new StringBuilder($"Composite: {Name}\n");
        foreach (var child in _children)
        {
            result.Append(new string('-', level + 2))
                  .Append("> ")
                  .Append(child.Operation())
                  .Append("\n");
        }
        return result.ToString();
    }
}

// Базовый интерфейс компонента
public interface IComponent
{
    string Operation();
}
 
// Конкретный компонент, который мы будем декорировать
public class ConcreteComponent : IComponent
{
    public string Operation()
    {
        return "ConcreteComponent";
    }
}
 
// Базовый декоратор
public abstract class Decorator : IComponent
{
    protected readonly IComponent _component;
 
    protected Decorator(IComponent component)
    {
        _component = component;
    }
 
    // По умолчанию просто делегируем операцию декорируемому компоненту
    public virtual string Operation()
    {
        return _component.Operation();
    }
}
 
// Конкретные декораторы добавляют своё поведение
public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(IComponent component) : base(component)
    {
    }
 
    public override string Operation()
    {
        return $"ConcreteDecoratorA({base.Operation()})";
    }
}
 
public class ConcreteDecoratorB : Decorator
{
    public ConcreteDecoratorB(IComponent component) : base(component)
    {
    }
 
    public override string Operation()
    {
        return $"ConcreteDecoratorB({base.Operation()})";
    }
}

// Сложная подсистема
public class SubsystemA
{
    public string OperationA() => "Subsystem A ready!";
}
 
public class SubsystemB
{
    public string OperationB() => "Subsystem B ready!";
}
 
public class SubsystemC
{
    public string OperationC() => "Subsystem C ready!";
}
 
// Фасад, который упрощает работу с подсистемой
public class Facade
{
    private readonly SubsystemA _subsystemA;
    private readonly SubsystemB _subsystemB;
    private readonly SubsystemC _subsystemC;
 
    public Facade()
    {
        _subsystemA = new SubsystemA();
        _subsystemB = new SubsystemB();
        _subsystemC = new SubsystemC();
    }
 
    // Методы фасада делегируют работу соответствующим подсистемам
    public string Operation()
    {
        var result = new StringBuilder();
        result.AppendLine("Facade initializes subsystems:");
        result.AppendLine(_subsystemA.OperationA());
        result.AppendLine(_subsystemB.OperationB());
        result.AppendLine(_subsystemC.OperationC());
        return result.ToString();
    }
}

// Общий интерфейс для реального объекта и заместителя
public interface ISubject
{
    void Request();
}
 
// Реальный объект, который выполняет работу
public class RealSubject : ISubject
{
    public void Request()
    {
        Console.WriteLine("RealSubject: Handling request...");
    }
}
 
// Заместитель, который контролирует доступ к реальному объекту
public class Proxy : ISubject
{
    private RealSubject _realSubject;
    private readonly bool _hasAccess;
 
    public Proxy(bool hasAccess)
    {
        _hasAccess = hasAccess;
    }
 
    // Ленивая инициализация реального объекта
    public void Request()
    {
        if (_hasAccess)
        {
            if (_realSubject == null)
            {
                Console.WriteLine("Proxy: Creating RealSubject...");
                _realSubject = new RealSubject();
            }
            Console.WriteLine("Proxy: Access granted. Forwarding to real subject.");
            _realSubject.Request();
        }
        else
        {
            Console.WriteLine("Proxy: Access denied.");
        }
    }
}

// Неизменяемое общее состояние символа
public class CharacterStyle
{
    public string FontFamily { get; }
    public int FontSize { get; }
    public bool IsBold { get; }
    public bool IsItalic { get; }
 
    public CharacterStyle(string fontFamily, int fontSize, bool isBold, bool isItalic)
    {
        FontFamily = fontFamily;
        FontSize = fontSize;
        IsBold = isBold;
        IsItalic = isItalic;
    }
}
 
// Flyweight Factory, которая управляет разделяемыми объектами
public class StyleFactory
{
    private readonly Dictionary<string, CharacterStyle> _styles = new Dictionary<string, CharacterStyle>();
 
    public CharacterStyle GetStyle(string fontFamily, int fontSize, bool isBold, bool isItalic)
    {
        // Создаём ключ для кеширования
        string key = $"{fontFamily}-{fontSize}-{isBold}-{isItalic}";
 
        // Проверяем, существует ли уже такой стиль
        if (!_styles.ContainsKey(key))
        {
            _styles[key] = new CharacterStyle(fontFamily, fontSize, isBold, isItalic);
        }
 
        return _styles[key];
    }
}

// Обобщенный интерфейс адаптера
public interface IAdapter<TInput, TOutput>
{
    TOutput Convert(TInput input);
}
 
// Конкретная реализация адаптера для преобразования из одного формата в другой
public class XmlToJsonAdapter : IAdapter<XDocument, JObject>
{
    public JObject Convert(XDocument input)
    {
        // Логика преобразования XML в JSON
        return JObject.Parse(JsonConvert.SerializeXNode(input));
    }
}

public abstract class Handler
{
private Handler _nextHandler;
 
public Handler SetNext(Handler handler)
{
    _nextHandler = handler;
    return handler;
}
 
public virtual object Handle(object request)
{
    if (_nextHandler != null)
    {
        return _nextHandler.Handle(request);
    }
    
    return null;
}
}
 
public class ConcreteHandler1 : Handler
{
public override object Handle(object request)
{
    if (request.ToString() == "Request1")
    {
        return $"Handler1: I'll handle the {request.ToString()}";
    }
    
    return base.Handle(request);
}
}
 
public class ConcreteHandler2 : Handler
{
public override object Handle(object request)
{
    if (request.ToString() == "Request2")
    {
        return $"Handler2: I'll handle the {request.ToString()}";
    }
    
    return base.Handle(request);
}
}

public interface ICommand
{
void Execute();
void Undo();
}
 
public class LightOnCommand : ICommand
{
private readonly Light _light;
 
public LightOnCommand(Light light)
{
    _light = light;
}
 
public void Execute()
{
    _light.TurnOn();
}
 
public void Undo()
{
    _light.TurnOff();
}
}
 
public class Light
{
private bool _isOn;
public string Name { get; }
 
public Light(string name)
{
    Name = name;
    _isOn = false;
}
 
public void TurnOn()
{
    _isOn = true;
    Console.WriteLine($"Light {Name} is now ON");
}
 
public void TurnOff()
{
    _isOn = false;
    Console.WriteLine($"Light {Name} is now OFF");
}
}
 
public class RemoteControl
{
private readonly ICommand[] _onCommands;
private readonly ICommand[] _offCommands;
private ICommand _lastCommand;
 
public RemoteControl(int slots = 7)
{
    _onCommands = new ICommand[slots];
    _offCommands = new ICommand[slots];
    
    // Заполняем массивы пустыми командами по умолчанию
    var noCommand = new NoCommand();
    for (int i = 0; i < slots; i++)
    {
        _onCommands[i] = noCommand;
        _offCommands[i] = noCommand;
    }
    
    _lastCommand = noCommand;
}
 
public void SetCommand(int slot, ICommand onCommand, ICommand offCommand)
{
    _onCommands[slot] = onCommand;
    _offCommands[slot] = offCommand;
}
 
public void PressOnButton(int slot)
{
    _onCommands[slot].Execute();
    _lastCommand = _onCommands[slot];
}
 
public void PressOffButton(int slot)
{
    _offCommands[slot].Execute();
    _lastCommand = _offCommands[slot];
}
 
public void PressUndoButton()
{
    _lastCommand.Undo();
}
}
 
// Пустая команда для инициализации по умолчанию
public class NoCommand : ICommand
{
public void Execute() { }
public void Undo() { }
}

public interface IAggregate<T>
{
IIterator<T> CreateIterator();
}
 
public interface IIterator<T>
{
T Current { get; }
bool MoveNext();
void Reset();
}
 
public class ConcreteAggregate<T> : IAggregate<T>
{
private readonly T[] _items;
 
public ConcreteAggregate(T[] items)
{
    _items = items;
}
 
public IIterator<T> CreateIterator()
{
    return new ConcreteIterator<T>(this);
}
 
public int Count => _items.Length;
public T this[int index] => _items[index];
}
 
public class ConcreteIterator<T> : IIterator<T>
{
private readonly ConcreteAggregate<T> _aggregate;
private int _currentIndex = 0;
 
public ConcreteIterator(ConcreteAggregate<T> aggregate)
{
    _aggregate = aggregate;
}
 
public T Current
{
    get
    {
        if (_currentIndex >= _aggregate.Count)
        {
            throw new InvalidOperationException("Iterator has reached the end of collection");
        }
        
        return _aggregate[_currentIndex];
    }
}
 
public bool MoveNext()
{
    _currentIndex++;
    return _currentIndex < _aggregate.Count;
}
 
public void Reset()
{
    _currentIndex = 0;
}
}

public class NumberCollection
{
private readonly List<int> _numbers = new List<int>();
 
public void Add(int number)
{
    _numbers.Add(number);
}
 
// Создание итератора с помощью yield return
public IEnumerable<int> GetEvenNumbers()
{
    foreach (var number in _numbers)
    {
        if (number % 2 == 0)
            yield return number;
    }
}
}

public interface IMediator
{
void Notify(object sender, string ev);
}
 
public class ConcreteMediator : IMediator
{
private readonly Component1 _component1;
private readonly Component2 _component2;
 
public ConcreteMediator(Component1 component1, Component2 component2)
{
    _component1 = component1;
    _component1.SetMediator(this);
    
    _component2 = component2;
    _component2.SetMediator(this);
}
 
public void Notify(object sender, string ev)
{
    if (ev == "A")
    {
        Console.WriteLine("Mediator reacts on A and triggers following operations:");
        _component2.DoC();
    }
    
    if (ev == "D")
    {
        Console.WriteLine("Mediator reacts on D and triggers following operations:");
        _component1.DoB();
        _component2.DoC();
    }
}
}
 
public class BaseComponent
{
protected IMediator _mediator;
 
public void SetMediator(IMediator mediator)
{
    _mediator = mediator;
}
}
 
public class Component1 : BaseComponent
{
public void DoA()
{
    Console.WriteLine("Component 1 does A");
    _mediator.Notify(this, "A");
}
 
public void DoB()
{
    Console.WriteLine("Component 1 does B");
    _mediator.Notify(this, "B");
}
}
 
public class Component2 : BaseComponent
{
public void DoC()
{
    Console.WriteLine("Component 2 does C");
    _mediator.Notify(this, "C");
}
 
public void DoD()
{
    Console.WriteLine("Component 2 does D");
    _mediator.Notify(this, "D");
}
}

// Класс, состояние которого будем сохранять
public class Originator
{
private string _state;
 
public Originator(string state)
{
    _state = state;
}
 
public string State
{
    get => _state;
    set
    {
        Console.WriteLine($"State changing from {_state} to {value}");
        _state = value;
    }
}
 
// Создаёт снимок текущего состояния
public IMemento Save() => new ConcreteMemento(_state);
 
// Восстанавливает состояние из снимка
public void Restore(IMemento memento)
{
    if (memento is ConcreteMemento concreteMemento)
    {
        _state = concreteMemento.GetState();
        Console.WriteLine($"State restored to {_state}");
    }
}
}
 
// Интерфейс для всех снимков
public interface IMemento
{
DateTime GetDate();
}
 
// Конкретная реализация снимка
public class ConcreteMemento : IMemento
{
private readonly string _state;
private readonly DateTime _date;
 
public ConcreteMemento(string state)
{
    _state = state;
    _date = DateTime.Now;
}
 
// Возвращает сохранённое состояние (доступно только Originator)
public string GetState() => _state;
 
// Публичный метод для получения метаданных
public DateTime GetDate() => _date;
}
 
// Опекун, который хранит историю снимков
public class Caretaker
{
private readonly List<IMemento> _mementos = new List<IMemento>();
private readonly Originator _originator;
 
public Caretaker(Originator originator)
{
    _originator = originator;
}
 
public void Backup()
{
    Console.WriteLine("Saving state...");
    _mementos.Add(_originator.Save());
}
 
public void Undo()
{
    if (_mementos.Count == 0)
    {
        return;
    }
 
    var memento = _mementos[_mementos.Count - 1];
    _mementos.Remove(memento);
 
    Console.WriteLine($"Restoring to: {memento.GetDate()}");
    _originator.Restore(memento);
}
 
public void ShowHistory()
{
    Console.WriteLine("History of states:");
    foreach (var memento in _mementos)
    {
        Console.WriteLine($" - {memento.GetDate()}");
    }
}
}

// Интерфейс для наблюдателей
public interface IObserver
{
void Update(string message);
}
 
// Интерфейс для субъекта (за которым наблюдают)
public interface ISubject
{
void Attach(IObserver observer);
void Detach(IObserver observer);
void Notify();
}
 
// Конкретный субъект наблюдения
public class ConcreteSubject : ISubject
{
private readonly List<IObserver> _observers = new List<IObserver>();
private string _state;
 
public string State
{
    get => _state;
    set
    {
        _state = value;
        Notify();
    }
}
 
public void Attach(IObserver observer)
{
    Console.WriteLine("Subject: Attached an observer");
    _observers.Add(observer);
}
 
public void Detach(IObserver observer)
{
    _observers.Remove(observer);
    Console.WriteLine("Subject: Detached an observer");
}
 
public void Notify()
{
    Console.WriteLine("Subject: Notifying observers...");
    foreach (var observer in _observers)
    {
        observer.Update(_state);
    }
}
}
 
// Конкретные наблюдатели
public class ConcreteObserverA : IObserver
{
public void Update(string message)
{
    Console.WriteLine($"Observer A: Received update with state: {message}");
}
}
 
public class ConcreteObserverB : IObserver
{
public void Update(string message)
{
    Console.WriteLine($"Observer B: Got news! State is now: {message}");
}
}

public class WeatherStation
{
// Событие, на которое подписываются наблюдатели
public event EventHandler<WeatherDataEventArgs> WeatherChanged;
 
private double _temperature;
public double Temperature
{
    get => _temperature;
    set
    {
        if (_temperature != value)
        {
            _temperature = value;
            OnWeatherChanged(new WeatherDataEventArgs { Temperature = value });
        }
    }
}
 
// Метод, вызывающий событие
protected virtual void OnWeatherChanged(WeatherDataEventArgs e)
{
    WeatherChanged?.Invoke(this, e);
}
}
 
public class WeatherDataEventArgs : EventArgs
{
public double Temperature { get; set; }
}
 
public class WeatherDisplay
{
private readonly string _displayName;
 
public WeatherDisplay(string name, WeatherStation station)
{
    _displayName = name;
    // Подписываемся на событие
    station.WeatherChanged += HandleWeatherChanged;
}
 
private void HandleWeatherChanged(object sender, WeatherDataEventArgs e)
{
    Console.WriteLine($"{_displayName}: Weather changed! Temperature is now {e.Temperature}°C");
}
}

// Интерфейс стратегии
public interface IStrategy
{
int Execute(int a, int b);
}
 
// Конкретные стратегии
public class AddStrategy : IStrategy
{
public int Execute(int a, int b) => a + b;
}
 
public class SubtractStrategy : IStrategy
{
public int Execute(int a, int b) => a - b;
}
 
public class MultiplyStrategy : IStrategy
{
public int Execute(int a, int b) => a * b;
}
 
// Контекст, использующий стратегию
public class Context
{
private IStrategy _strategy;
 
public Context(IStrategy strategy)
{
    _strategy = strategy;
}
 
public void SetStrategy(IStrategy strategy)
{
    _strategy = strategy;
}
 
public int ExecuteStrategy(int a, int b)
{
    return _strategy.Execute(a, b);
}
}

public class Calculator
{
private Func<int, int, int> _operation;
 
public Calculator(Func<int, int, int> operation)
{
    _operation = operation;
}
 
public void SetOperation(Func<int, int, int> operation)
{
    _operation = operation;
}
 
public int Calculate(int a, int b)
{
    return _operation(a, b);
}
}
 
// Использование
var calc = new Calculator((a, b) => a + b);
Console.WriteLine(calc.Calculate(10, 5)); // 15
 
calc.SetOperation((a, b) => a * b);
Console.WriteLine(calc.Calculate(10, 5)); // 50

// Интерфейс состояния
public interface IState
{
    void InsertCoin(VendingMachine machine);
    void EjectCoin(VendingMachine machine);
    void SelectItem(VendingMachine machine);
    void DispenseItem(VendingMachine machine);
}
 
// Автомат с напитками, который меняет поведение в зависимости от состояния
public class VendingMachine
{
    public IState NoCoinState { get; private set; }
    public IState HasCoinState { get; private set; }
    public IState SoldState { get; private set; }
    public IState SoldOutState { get; private set; }
    
    public IState CurrentState { get; set; }
    public int Count { get; private set; }
    
    public VendingMachine(int count)
    {
        NoCoinState = new NoCoinState();
        HasCoinState = new HasCoinState();
        SoldState = new SoldState();
        SoldOutState = new SoldOutState();
        
        Count = count;
        CurrentState = count > 0 ? NoCoinState : SoldOutState;
    }
    
    // Методы делегируют выполнение текущему состоянию
    public void InsertCoin() => CurrentState.InsertCoin(this);
    public void EjectCoin() => CurrentState.EjectCoin(this);
    public void SelectItem() => CurrentState.SelectItem(this);
    public void DispenseItem() 
    {
        CurrentState.DispenseItem(this);
        if (CurrentState == SoldState)
        {
            Count--;
            if (Count == 0)
            {
                CurrentState = SoldOutState;
            }
            else
            {
                CurrentState = NoCoinState;
            }
        }
    }
}
 
// Примеры реализации состояний
public class NoCoinState : IState
{
    public void InsertCoin(VendingMachine machine)
    {
        Console.WriteLine("Монета принята");
        machine.CurrentState = machine.HasCoinState;
    }
    
    public void EjectCoin(VendingMachine machine)
    {
        Console.WriteLine("Нет монеты для возврата");
    }
    
    public void SelectItem(VendingMachine machine)
    {
        Console.WriteLine("Сначала вставьте монету");
    }
    
    public void DispenseItem(VendingMachine machine)
    {
        Console.WriteLine("Сначала оплатите товар");
    }
}
 
public class HasCoinState : IState
{
    public void InsertCoin(VendingMachine machine)
    {
        Console.WriteLine("Нельзя вставить больше одной монеты");
    }
    
    public void EjectCoin(VendingMachine machine)
    {
        Console.WriteLine("Монета возвращена");
        machine.CurrentState = machine.NoCoinState;
    }
    
    public void SelectItem(VendingMachine machine)
    {
        Console.WriteLine("Товар выбран");
        machine.CurrentState = machine.SoldState;
    }
    
    public void DispenseItem(VendingMachine machine)
    {
        Console.WriteLine("Сначала выберите товар");
    }
}

public class Document
{
    private IDocumentState _state;
    public string Content { get; set; }
    public string Author { get; set; }
    public List<string> ApproverComments { get; set; } = new List<string>();
 
    public Document()
    {
        _state = new DraftState();
    }
 
    public void SetState(IDocumentState state)
    {
        Console.WriteLine($"Документ переходит из состояния '{_state.GetType().Name}' в '{state.GetType().Name}'");
        _state = state;
    }
 
    public void Submit() => _state.Submit(this);
    public void Review(bool approved, string comment) => _state.Review(this, approved, comment);
    public void Publish() => _state.Publish(this);
}

public abstract class DataProcessor
{
    // Шаблонный метод, определяющий скелет алгоритма
    public void ProcessData()
    {
        ReadData();
        ValidateData();
        ProcessDataCore();
        StoreResults();
        SendNotification();
    }
 
    // Абстрактные методы, которые должны быть реализованы подклассами
    protected abstract void ReadData();
    protected abstract void ProcessDataCore();
 
    // Методы с реализацией по умолчанию, которые подклассы могут переопределить
    protected virtual void ValidateData()
    {
        Console.WriteLine("Проверка данных на корректность");
    }
 
    protected virtual void StoreResults()
    {
        Console.WriteLine("Сохранение результатов");
    }
 
    // Хук — метод с пустой реализацией, который подклассы могут переопределить
    protected virtual void SendNotification() { }
}
 
public class CsvDataProcessor : DataProcessor
{
    protected override void ReadData()
    {
        Console.WriteLine("Чтение CSV-файла");
    }
 
    protected override void ProcessDataCore()
    {
        Console.WriteLine("Обработка данных из CSV");
    }
 
    // Переопределяем хук, добавляя функциональность
    protected override void SendNotification()
    {
        Console.WriteLine("Отправка уведомления о завершении обработки CSV");
    }
}

// Strategy pattern
public interface IValidationStrategy
{
    bool Validate(Order order);
}
 
public class DomesticOrderValidator : IValidationStrategy
{
    public bool Validate(Order order) => order.Country == "Russia" && order.Total < 100000;
}
 
public class InternationalOrderValidator : IValidationStrategy
{
    public bool Validate(Order order) => order.HasInternationalShippingDocs && order.IsTaxPaid;
}
 
// Factory Method
public static class ValidatorFactory
{
    public static IValidationStrategy CreateValidator(Order order)
    {
        return order.IsInternational 
            ? new InternationalOrderValidator() 
            : new DomesticOrderValidator();
    }
}

public interface ILogger
{
    void Log(string message);
}
 
public class FileLogger : ILogger
{
    public void Log(string message) => /* запись в файл */;
}
 
public class LoggerDecorator : ILogger
{
    protected readonly ILogger _logger;
    public LoggerDecorator(ILogger logger) => _logger = logger;
    public virtual void Log(string message) => _logger.Log(message);
}
 
public class TimestampDecorator : LoggerDecorator
{
    public TimestampDecorator(ILogger logger) : base(logger) { }
    
    public override void Log(string message)
    {
        _logger.Log($"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] {message}");
    }
}
 
// Factory создаёт и декорирует логгеры
public static ILogger CreateLogger(LoggerOptions options)
{
    ILogger logger = new FileLogger();
    
    if (options.AddTimestamp)
        logger = new TimestampDecorator(logger);
        
    return logger;
}

// Анти-пример: Singleton + репозиторий в одном классе
public sealed class UserRepository
{
    private static readonly Lazy<UserRepository> _instance = 
        new Lazy<UserRepository>(() => new UserRepository());
    public static UserRepository Instance => _instance.Value;
    
    private readonly List<User> _users = new List<User>();
    
    private UserRepository() { }
    
    public User FindById(int id) => /* ... */;
    public void Save(User user) => /* ... */;
    // Еще 15+ методов для работы с пользователями
}

// Observer + Strategy + Factory Method + Builder + Decorator + Singleton
 
// Создаем уведомление с помощью Builder
var notification = new NotificationBuilder()
    .SetTitle("Новый заказ")
    .SetBody("Клиент разместил заказ #12345")
    .SetPriority(Priority.High)
    .Build();
 
// Получаем стратегию отправки через Factory Method
var strategy = NotificationStrategyFactory.Create(
    user.PreferredChannel);
 
// Декорируем стратегию для добавления форматирования и логирования
strategy = new FormattingDecorator(strategy);
strategy = new LoggingDecorator(strategy);
 
// Используем Singleton для получения менеджера уведомлений
NotificationManager.Instance.Send(notification, strategy);
 
// Observer оповещает подписчиков об отправке