Update Design Patterns

Implementação dos padrões comportamentais: Observer, State, Strategy, Template Method e Visitor

Author: vitorcaetanodev

ObserverPattern.cs

@@ -0,0 +1,82 @@
+// Observer.cs
+
+using System;
+using System.Collections.Generic;
+
+public interface IObserver
+{
+    void Update(string message);
+}
+
+public class ConcreteObserver : IObserver
+{
+    private readonly string _name;
+    
+    public ConcreteObserver(string name)
+    {
+        _name = name;
+    }
+
+    public void Update(string message)
+    {
+        Console.WriteLine($"Observer {_name} recebeu a mensagem: {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 void Attach(IObserver observer)
+    {
+        _observers.Add(observer);
+    }
+
+    public void Detach(IObserver observer)
+    {
+        _observers.Remove(observer);
+    }
+
+    public void Notify()
+    {
+        foreach (var observer in _observers)
+        {
+            observer.Update(_state);
+        }
+    }
+
+    public string State
+    {
+        get => _state;
+        set
+        {
+            _state = value;
+            Notify();
+        }
+    }
+}
+
+// Testando Observer
+public class Program
+{
+    public static void Main()
+    {
+        var subject = new ConcreteSubject();
+
+        var observer1 = new ConcreteObserver("Observer 1");
+        var observer2 = new ConcreteObserver("Observer 2");
+
+        subject.Attach(observer1);
+        subject.Attach(observer2);
+
+        subject.State = "Novo estado!";
+    }
+}

StatePattern.cs

@@ -0,0 +1,58 @@
+// State.cs
+
+using System;
+
+public interface IState
+{
+    void Handle();
+}
+
+public class ConcreteStateA : IState
+{
+    public void Handle()
+    {
+        Console.WriteLine("Estado A: Realizando ação A.");
+    }
+}
+
+public class ConcreteStateB : IState
+{
+    public void Handle()
+    {
+        Console.WriteLine("Estado B: Realizando ação B.");
+    }
+}
+
+public class Context
+{
+    private IState _state;
+
+    public Context(IState state)
+    {
+        _state = state;
+    }
+
+    public void SetState(IState state)
+    {
+        _state = state;
+    }
+
+    public void Request()
+    {
+        _state.Handle();
+    }
+}
+
+// Testando State
+public class Program
+{
+    public static void Main()
+    {
+        var context = new Context(new ConcreteStateA());
+
+        context.Request();
+
+        context.SetState(new ConcreteStateB());
+        context.Request();
+    }
+}

StrategyPattern.cs

@@ -0,0 +1,57 @@
+// Strategy.cs
+
+using System;
+
+public interface IStrategy
+{
+    void Execute();
+}
+
+public class ConcreteStrategyA : IStrategy
+{
+    public void Execute()
+    {
+        Console.WriteLine("Estratégia A: Execução da estratégia A.");
+    }
+}
+
+public class ConcreteStrategyB : IStrategy
+{
+    public void Execute()
+    {
+        Console.WriteLine("Estratégia B: Execução da estratégia B.");
+    }
+}
+
+public class Context
+{
+    private IStrategy _strategy;
+
+    public Context(IStrategy strategy)
+    {
+        _strategy = strategy;
+    }
+
+    public void SetStrategy(IStrategy strategy)
+    {
+        _strategy = strategy;
+    }
+
+    public void ExecuteStrategy()
+    {
+        _strategy.Execute();
+    }
+}
+
+// Testando Strategy
+public class Program
+{
+    public static void Main()
+    {
+        var context = new Context(new ConcreteStrategyA());
+        context.ExecuteStrategy();
+
+        context.SetStrategy(new ConcreteStrategyB());
+        context.ExecuteStrategy();
+    }
+}

TemplateMethod.cs

@@ -0,0 +1,62 @@
+// TemplateMethod.cs
+
+using System;
+
+public abstract class AbstractClass
+{
+    public void TemplateMethod()
+    {
+        StepOne();
+        StepTwo();
+        StepThree();
+    }
+
+    protected abstract void StepOne();
+    protected abstract void StepTwo();
+
+    // Passo fixo
+    protected void StepThree()
+    {
+        Console.WriteLine("Passo três: Passo fixo.");
+    }
+}
+
+public class ConcreteClassA : AbstractClass
+{
+    protected override void StepOne()
+    {
+        Console.WriteLine("Classe A: Executando passo um.");
+    }
+
+    protected override void StepTwo()
+    {
+        Console.WriteLine("Classe A: Executando passo dois.");
+    }
+}
+
+public class ConcreteClassB : AbstractClass
+{
+    protected override void StepOne()
+    {
+        Console.WriteLine("Classe B: Executando passo um.");
+    }
+
+    protected override void StepTwo()
+    {
+        Console.WriteLine("Classe B: Executando passo dois.");
+    }
+}
+
+// Testando Template Method
+public class Program
+{
+    public static void Main()
+    {
+        var classA = new ConcreteClassA();
+        classA.TemplateMethod();
+
+        var classB = new ConcreteClassB();
+        classB.TemplateMethod();
+    }
+}
+

VisitorPattern.cs

@@ -0,0 +1,70 @@
+// Visitor.cs
+
+using System;
+
+public interface IElement
+{
+    void Accept(IVisitor visitor);
+}
+
+public class ConcreteElementA : IElement
+{
+    public void Accept(IVisitor visitor)
+    {
+        visitor.Visit(this);
+    }
+
+    public void OperationA()
+    {
+        Console.WriteLine("Elemento A: Executando operação A.");
+    }
+}
+
+public class ConcreteElementB : IElement
+{
+    public void Accept(IVisitor visitor)
+    {
+        visitor.Visit(this);
+    }
+
+    public void OperationB()
+    {
+        Console.WriteLine("Elemento B: Executando operação B.");
+    }
+}
+
+public interface IVisitor
+{
+    void Visit(ConcreteElementA elementA);
+    void Visit(ConcreteElementB elementB);
+}
+
+public class ConcreteVisitor : IVisitor
+{
+    public void Visit(ConcreteElementA elementA)
+    {
+        elementA.OperationA();
+        Console.WriteLine("Visitor: Realizando visita ao Elemento A.");
+    }
+
+    public void Visit(ConcreteElementB elementB)
+    {
+        elementB.OperationB();
+        Console.WriteLine("Visitor: Realizando visita ao Elemento B.");
+    }
+}
+
+// Testando Visitor
+public class Program
+{
+    public static void Main()
+    {
+        var elementA = new ConcreteElementA();
+        var elementB = new ConcreteElementB();
+
+        var visitor = new ConcreteVisitor();
+
+        elementA.Accept(visitor);
+        elementB.Accept(visitor);
+    }
+}