Skip to content
The Chat Archive
gpt-4-0314· OpenAI WildChat-4.8M (AI2)

напиши паттерн Стратегия (Strategy) на C#

  1. User

    напиши паттерн Стратегия (Strategy) на C#

  2. Assistant

    Стратегия (Strategy) является поведенческим паттерном, который определяет семейство алгоритмов, инкапсулирует каждый из них и делает их взаимозаменяемыми. Ниже приведен пример паттерна стратегии на языке C#.

    using System;
    
    // Базовый интерфейс стратегий
    public interface IStrategy
    {
        void ExecuteAlgorithm();
    }
    
    // Конкретная стратегия 1
    public class ConcreteStrategyA : IStrategy
    {
        public void ExecuteAlgorithm()
        {
            Console.WriteLine("Concrete strategy A");
        }
    }
    
    // Конкретная стратегия 2
    public class ConcreteStrategyB : IStrategy
    {
        public void ExecuteAlgorithm()
        {
            Console.WriteLine("Concrete strategy B");
        }
    }
    
    // Контекст для стратегий
    public class Context
    {
        private IStrategy _strategy;
    
        public Context(IStrategy strategy)
        {
            _strategy = strategy;
        }
    
        public void SetStrategy(IStrategy strategy)
        {
            _strategy = strategy;
        }
    
        public void ExecuteStrategy()
        {
            _strategy.ExecuteAlgorithm();
        }
    }
    
    // Клиентский код
    public class Client
    {
        public static void Main()
        {
            // Создаем контекст и стратегии
            IStrategy strategyA = new ConcreteStrategyA();
            IStrategy strategyB = new ConcreteStrategyB();
            Context context = new Context(strategyA);
    
            // Используем стратегию A
            context.ExecuteStrategy();
    
            // Меняем стратегию на B в контексте и запускаем ее
            context.SetStrategy(strategyB);
            context.ExecuteStrategy();
        }
    }
    

    В данном примере есть интерфейс IStrategy, который определяет метод ExecuteAlgorithm(). Классы ConcreteStrategyA и ConcreteStrategyB реализуют этот интерфейс, определяя свои алгоритмы.

    Класс Context содержит ссылку на объект IStrategy и предоставляет методы для изменения стратегии и выполнения соответствующего алгоритма. В клиентском коде создаются объекты конкретных стратегий, и они используются в контексте для выполнения алгоритмов.

  3. User

    напиши паттерн Посредник (Mediator) на C#

  4. Assistant

    Посредник (Mediator) является поведенческим паттерном, который позволяет уменьшить связанность множества классов между собой, благодаря перемещению этих связей в один класс-посредник. Ниже приведен пример паттерна посредник на языке C#.

    using System;
    using System.Collections.Generic;
    
    // Интерфейс посредника
    public interface IMediator
    {
        void Notify(object sender, string eventMessage);
    }
    
    // Базовый посредник
    public class BaseMediator : IMediator
    {
        private readonly List<Component> components = new List<Component>();
    
        public void AddComponent(Component component)
        {
            components.Add(component);
            component.SetMediator(this);
        }
    
        public void Notify(object sender, string eventMessage)
        {
            foreach (var component in components)
            {
                if (component != sender)
                {
                    component.HandleEvent(eventMessage);
                }
            }
        }
    }
    
    // Базовый компонент
    public abstract class Component
    {
        protected IMediator mediator;
    
        public void SetMediator(IMediator newMediator)
        {
            mediator = newMediator;
        }
    
        public abstract void HandleEvent(string eventMessage);
    }
    
    // Конкретный компонент A
    public class ComponentA : Component
    {
        public void DoSomething()
        {
            Console.WriteLine("Component A triggered an action");
            mediator.Notify(this, "A");
        }
    
        public override void HandleEvent(string eventMessage)
        {
            if (eventMessage == "B")
            {
                Console.WriteLine("Component A received an event from Component B");
            }
        }
    }
    
    // Конкретный компонент B
    public class ComponentB : Component
    {
        public void DoSomething()
        {
            Console.WriteLine("Component B triggered an action");
            mediator.Notify(this, "B");
        }
    
        public override void HandleEvent(string eventMessage)
        {
            if (eventMessage == "A")
            {
                Console.WriteLine("Component B received an event from Component A");
            }
        }
    }
    

    В данном примере есть интерфейс IMediator и его реализация BaseMediator. BaseMediator определяет метод Notify(), который передает события от одного компонента другим.

    Абстрактный класс Component определяет методы для установки посредника и обработки событий. Конкретные компоненты (ComponentA и ComponentB) являются наследниками Component и переопределяют метод HandleEvent() для обработки событий от других компонентов.

    Для использования паттерна Посредник в вашем коде, вы можете создать экземпляры конкретных компонентов и посредника, а затем добавить компоненты в посредник:

    public class Client
    {
        public static void Main()
        {
            var mediator = new BaseMediator();
    
            var componentA = new ComponentA();
            var componentB = new ComponentB();
    
            mediator.AddComponent(componentA);
            mediator.AddComponent(componentB);
    
            componentA.DoSomething(); // Component A triggered an action
                                      // Component B received an event from Component A
    
            componentB.DoSomething(); // Component B triggered an action
                                      // Component A received an event from Component B
        }
    }
    

    Таким образом, компоненты обмениваются сообщениями через посредника, не являясь прямо связанными друг с другом, что уменьшает их связанность.