Singleton is the canonical "exactly one instance + global access" pattern. Factory Method creates objects but doesn't restrict count. Proxy is structural (controls access). Decorator adds behavior.

Singleton هو النمط الكلاسيكي لـ "نسخة وحيدة + وصول عام". Factory Method يُنشئ كائنات لكن لا يقيد العدد. Proxy نمط هيكلي للتحكم بالوصول. Decorator يضيف سلوكًا.

Strategy = client calls strategy.execute() through a common interface; the runtime picks the correct concrete strategy. That's polymorphism. (Abstraction defines the contract; polymorphism is what makes the call work.)

Strategy = العميل يستدعي strategy.execute() عبر واجهة مشتركة، والمحرك يختار الاستراتيجية الصحيحة وقت التشغيل. هذا polymorphism. (التجريد يُعرّف العقد، أما polymorphism فهو ما يُشغّل الاستدعاء.)

Template Method defines the skeleton of an algorithm in a base class and lets subclasses override specific steps. The mechanism is inheritance + method overriding. Strategy uses aggregation; Template Method uses inheritance — that's the classic exam contrast.

Template Method يضع هيكل الخوارزمية في الكلاس الأب ويترك للأبناء تنفيذ خطوات معينة. الآلية هي الوراثة + override. Strategy يستخدم aggregation، أما Template Method فيستخدم الوراثة — هذا الفرق الكلاسيكي في الامتحانات.

UserRepository (high-level) directly depends on the concrete SqlConnection (low-level). Both should depend on an abstraction. Switching to MongoDB or any other store would force editing the repository — also violating OCP.

UserRepository (عالي المستوى) يعتمد مباشرة على SqlConnection ملموس (منخفض المستوى). يجب أن يعتمد كلاهما على تجريد. التبديل إلى MongoDB أو أي مخزن آخر يفرض تعديل الـ repository — وهذا أيضاً خرق لـ OCP.

Introduce IDbConnection interface. UserRepository takes it in the constructor (Dependency Injection).

أنشئ واجهة IDbConnection. الـ UserRepository يستقبلها في الـ constructor (حقن التبعية).

public interface IDbConnection {
  void Connect();
  void Execute(string query);
}

public class SqlConnection : IDbConnection {
  public void Connect() { /* ... */ }
  public void Execute(string q) { /* ... */ }
}

public class UserRepository {
  private readonly IDbConnection _connection;

  public UserRepository(IDbConnection connection) {
    _connection = connection;     // injected
  }

  public void SaveUser(string username) {
    _connection.Connect();
    _connection.Execute($"INSERT INTO Users VALUES ('{username}')");
  }
}

Just add a new class — no other code changes (this is the OCP win).

أضف كلاسًا جديدًا فقط — دون تعديل أي كود آخر (هذا انتصار OCP).

public class MongoConnection : IDbConnection {
  public void Connect() {
    Console.WriteLine("Connected to MongoDB");
  }
  public void Execute(string query) {
    Console.WriteLine($"Mongo executing: {query}");
  }
}

// Usage:
var repo = new UserRepository(new MongoConnection());
repo.SaveUser("raghad");

Purpose: the Repository pattern provides a higher-level abstraction over data access. Business logic asks the repository for "users," "orders," etc. — without knowing whether the data sits in SQL, MongoDB, an API, or memory.

الغرض: يوفّر Repository تجريداً أعلى مستوى فوق طبقة الوصول إلى البيانات. منطق العمل يطلب "users" أو "orders"... دون أن يعرف إن كانت البيانات في SQL أو MongoDB أو API أو الذاكرة.

• Separation of concerns — business logic stays clean.
• فصل الاهتمامات — منطق العمل يبقى نظيفًا.
• Testability — swap real DB for an in-memory fake during tests.
• قابلية الاختبار — استبدل القاعدة الحقيقية بنسخة في الذاكرة أثناء الاختبار.
• Centralized queries — business-specific data methods live in one place.
• تمركز الاستعلامات — كل استعلامات العمل في مكان واحد.
• Easy to change storage — swap DAOs/connections without touching consumers.
• سهولة تغيير التخزين — بدّل الـ DAOs أو الاتصالات دون لمس مستهلكي البيانات.

Idea: introduce AttackFactory with a method create(type) that returns an IAttackStrategy. The Hero asks the factory for a strategy by name/enum — never calls new directly.

الفكرة: أنشئ AttackFactory فيها ميثود create(type) ترجع IAttackStrategy. الـ Hero يطلب الاستراتيجية من الـ factory باسم/enum — ولا يستدعي new مباشرة.

interface IAttackStrategy { void attack(); }

class MeleeAttack   implements IAttackStrategy { public void attack(){ /*...*/ } }
class RangedAttack  implements IAttackStrategy { public void attack(){ /*...*/ } }
class MagicalAttack implements IAttackStrategy { public void attack(){ /*...*/ } }

enum AttackType { MELEE, RANGED, MAGICAL }

class AttackFactory {
  public IAttackStrategy create(AttackType type) {
    switch (type) {
      case MELEE:   return new MeleeAttack();
      case RANGED:  return new RangedAttack();
      case MAGICAL: return new MagicalAttack();
      default: throw new IllegalArgumentException();
    }
  }
}

class Hero {
  private IAttackStrategy attackStyle;

  public void setAttack(AttackType type, AttackFactory f) {
    this.attackStyle = f.create(type);
  }

  public void attack() { attackStyle.attack(); }
}

Why this matters: the Hero never calls new MeleeAttack(). Adding new attack types only changes the factory — Hero stays untouched. Factory + Strategy = a classic combo.

لماذا هذا مهم: الـ Hero لا يستدعي new MeleeAttack() أبدًا. إضافة هجمات جديدة تتطلب تعديل factory فقط — والـ Hero يبقى كما هو. Factory + Strategy = تركيبة كلاسيكية.