Advanced OOP Patterns

using System;

// STRATEGY pattern = a family of interchangeable algorithms behind ONE interface.
// The caller picks which algorithm to use at runtime — no if/else ladders.
interface IDiscountStrategy
{
    decimal Apply(decimal price);   // each strategy returns the discounted price
}

// Each concrete strategy is one self-contained algorithm.
class NoDiscount : IDiscountStrategy
{
    public decimal Apply(decimal price) => price;            // full price
}

class PercentOff : IDiscountStrateg
...

using System;

// 🎯 YOUR TURN — wire up a Strategy and pick one at runtime.

interface IDiscountStrategy
{
    decimal Apply(decimal price);
}

class NoDiscount : IDiscountStrategy
{
    public decimal Apply(decimal price) => price;          // done for you
}

class HalfPrice : IDiscountStrategy
{
    // 1) Return HALF of the price.
    public decimal Apply(decimal price) => ___;           // 👉 price * 0.5m
}

class Checkout
{
    private IDiscountStrategy _discount;
    public Checkout(IDisco
...

using System;

// FACTORY METHOD = one place that decides which concrete object to build.
// Callers ask for "a shape" by name and get back the right IShape — they
// never write 'new Circle()' or 'new Square()' themselves.
interface IShape
{
    double Area();
    string Name { get; }
}

class Circle : IShape
{
    private readonly double _r;
    public Circle(double r) => _r = r;
    public string Name => "Circle";
    public double Area() => Math.PI * _r * _r;
}

class Square : IShape
{
    p
...

using System;

// 🎯 YOUR TURN — finish a factory that returns different IShape objects.

interface IShape
{
    double Area();
    string Name { get; }
}

class Circle : IShape
{
    private readonly double _r;
    public Circle(double r) => _r = r;
    public string Name => "Circle";
    public double Area() => Math.PI * _r * _r;
}

class Square : IShape
{
    private readonly double _side;
    public Square(double side) => _side = side;
    public string Name => "Square";
    public double Ar
...

using System;
using System.Collections.Generic;

// OBSERVER = a subject notifies a list of observers when something happens.
// The subject doesn't know what each observer DOES — only how to call it.
interface IObserver
{
    void Notify(string eventName);
}

// The SUBJECT holds subscribers and broadcasts to all of them.
class Stock
{
    private readonly List<IObserver> _observers = new();

    public void Subscribe(IObserver o) => _observers.Add(o);
    public void Unsubscribe(IObserver o) =
...

using System;

// SINGLETON = a class with exactly ONE shared instance for the whole app.
// Used for things there should only ever be one of: config, a logger, a cache.
sealed class AppConfig
{
    // 'static readonly' is initialised once, lazily, and is THREAD-SAFE in C#
    // because the runtime guarantees a type's static fields run only once.
    private static readonly AppConfig _instance = new AppConfig();

    // The single, global access point.
    public static AppConfig Instance => _i
...

using System;

// DEPENDENCY INVERSION: depend on an INTERFACE, not a concrete class.
// High-level code (OrderService) shouldn't be glued to one low-level detail.
interface IMessageSender
{
    void Send(string message);
}

// Two concrete details — both honour the same contract.
class EmailSender : IMessageSender
{
    public void Send(string message) => Console.WriteLine($"📧 {message}");
}

class SmsSender : IMessageSender
{
    public void Send(string message) => Console.WriteLine($"📱 {mes
...