Software Engineer Encyclopedia
0%
Domain 06 · Software Architecture & Design Patterns · Topic 6.6

SOLID Principles: من القواعد النظرية إلى Refactoring عملي

SOLID — Five Design Principles with C# Examples

شرح SRP/OCP/LSP/ISP/DIP من خلال code smells وrefactoring وtrade-offs، مع DRY/KISS/YAGNI وcomposition وLaw of Demeter.

  • Advanced
  • ~24 min read
  • 12 sections
  • 15 code examples
  • 1 diagrams
  • 5 questions
  • Priority L1 · Essential
  • C# 14 · .NET 10

المتطلبات قبل ما تبدأ

خبرة عملية ببناء API بقاعدة بيانات — الأنماط دي حلول لمشاكل لازم تكون شفتها.

مستوى التعمق المطلوب

DEEPExplain each principle through code you have refactored.

01

SOLID مش قوانين مقدسة

Principles for managing change
Deep dive

SOLID خمس مبادئ تساعدك تقلل coupling وتخلي الكود قابل للتغيير والاختبار. هي heuristics وليست قوانين compile-time. تطبيقها حرفيًا على كل class قد ينتج interfaces كثيرة و indirection و overengineering. اسأل دائمًا: ما نوع التغيير المتوقع؟ ما السبب الذي يجعل هذه الوحدة تتغير؟ هل abstraction تقلل cost أم تزيدها؟

المبادئ: Single Responsibility، Open/Closed، Liskov Substitution، Interface Segregation، Dependency Inversion. غالبًا تتداخل: SRP يقسم responsibilities، ISP يصغر contracts، DIP يعكس dependencies، OCP يستفيد من abstractions، و LSP يضمن أن implementations تحترم contract.

02

DIP في رسمة: الاتجاه بيتقلب

Dependency inversion
Basics
BeforeInvoiceServiceSmtpClientAfterInvoiceServiceINotificationSenderSmtpSenderimplements
Before: policy depends on details. After: both depend on an abstraction owned by the policy
03

S — Single Responsibility Principle

One reason to change
Deep dive

SRP لا تعني class فيها method واحدة. معناها أن class/module لها responsibility متماسكة وسبب تغيير رئيسي. لو class تتغير بسبب business pricing وبسبب SMTP configuration وبسبب CSV formatting، عندك أكثر من actor/concern يطلب تغييرها.

C#Before — multiple reasons to change
public sealed class InvoiceService(AppDbContext db, SmtpClient smtp)
{
    public decimal CalculateTax(Invoice invoice) => invoice.Total * 0.14m;
    public Task SaveAsync(Invoice invoice) => db.SaveChangesAsync();
    public Task EmailAsync(string address) => smtp.SendMailAsync(address, "Invoice", "...");
    public string ToCsv(Invoice invoice) => $"{invoice.Id},{invoice.Total}";
}
C#After — cohesive collaborators
public sealed class TaxCalculator(ITaxPolicy policy)
{
    public Money Calculate(Invoice invoice) => policy.Calculate(invoice.Subtotal);
}
public sealed class InvoiceRepository(AppDbContext db)
{
    public Task SaveAsync(Invoice invoice, CancellationToken ct) => db.SaveChangesAsync(ct);
}
public sealed class InvoiceEmailSender(IEmailGateway email)
{
    public Task SendAsync(Invoice invoice, CancellationToken ct) =>
        email.SendAsync(invoice.CustomerEmail, "Invoice", invoice.Render(), ct);
}

لا تقسم class لمجرد أن عندها أكثر من method؛ لو كل methods تتغير مع نفس business capability، قد تكون cohesive. SRP مرتبط بالـ actors/change reasons وليس عدد الأسطر.

SRP بعمق: Responsibility و Actor و Change Axis

SRP يُفهم خطأ كأنه «class واحدة = وظيفة واحدة». المقصود أن module لا تجمع أسباب تغيير مستقلة. مثال: Invoice calculation يتغير بسبب Finance policy؛ PDF layout يتغير بسبب Branding؛ persistence يتغير بسبب DBA/storage. فصلهم يقلل أن تغيير في actor واحد يعرّض الآخرين لمخاطر غير مرتبطة.

لكن فصل كل method في class مستقلة يرفع coupling عبر constructors ويجعل flow متشظيًا. اختبر cohesion: هل methods تستخدم نفس state؟ هل لها vocabulary واحدة؟ هل تتغير مع نفس business reason؟ هل caller يحتاج المجموعة كوحدة؟ لو نعم، ربما تبقى معًا.

04

O — Open/Closed Principle

Open for extension, closed for risky modification
Deep dive

OCP يعني إضافة behavior جديد لا تتطلب تعديل مجموعة كبيرة من stable code. لا يعني عدم تعديل الكود أبدًا. استخدم polymorphism/strategy/policy عندما يوجد محور variation متوقع. لو كل حالة جديدة تحتاج تعديل switch مركزي بعشرات branches، فكر في extension point.

C#Before — growing discount switch
public decimal CalculateDiscount(string type, decimal total) => type switch
{
    "vip" => total * 0.15m,
    "employee" => total * 0.20m,
    "seasonal" => total * 0.10m,
    _ => 0m
};
C#After — policy implementations
public interface IDiscountPolicy
{
    Money Calculate(OrderSubtotal subtotal);
}
public sealed class VipDiscount : IDiscountPolicy
{
    public Money Calculate(OrderSubtotal subtotal) => subtotal.Amount * 0.15m;
}
public sealed class EmployeeDiscount : IDiscountPolicy
{
    public Money Calculate(OrderSubtotal subtotal) => subtotal.Amount * 0.20m;
}

لو discount types ثابتة اثنين ولا تتغير، switch بسيط قد يكون أوضح. لا تبنِ plugin architecture من أجل احتمال غير مؤكد. OCP مهم عندما variation متكرر أو business يضيف rules باستمرار.

OCP بعمق: Extension Points و Plugin Boundaries

OCP لا يفرض polymorphism على كل switch. extension point يستحق abstraction عندما variation متكرر أو متوقع، وعندما core stable. أمثلة: tax providers حسب country، payment processors، document parsers، pricing policies. لا تعمم على احتمالات خيالية. الـ abstraction يجب أن تعكس capability ثابتة، لا تفاصيل implementation الحالية فقط.

في plugin systems، حدد versioned contract، dependency lifecycle، error isolation، security permissions، configuration و observability. مجرد interface لا يجعل plugin safe أو compatible. OCP trade-off: كل extension point يضيف contract يجب maintainه.

OCP لا تعني إلغاء Switch: اختيار مستوى Extension المناسب

لو لديك enum مغلق من ثلاث حالات لا تتغير إلا نادرًا، switch expression واضح ومناسب. OCP تصبح ذات قيمة عندما تضيف variants باستمرار أو تريد plugins مستقلة أو implementations يملكها فريق آخر. abstraction مبكرة تخلق تكلفة discoverability و DI و testing. اختَر extension point بعد ظهور محور variation أو عند وجود requirement واضح لفتح النظام للتوسعة.

قارن change cost: لو إضافة provider تتطلب تعديل switch واحد واختبارات محددة، قد يكون هذا مقبولًا. لو التغيير يلمس عشر use cases ويكرر نفس mapping، Strategy/Factory قد تقلل التكرار. المبدأ لا يمنع التعديل؛ هو يوجه أين نسمح بالتغيير وكيف نعزل أثره.

OCP مع DI: اختيار Strategy من غير Service Locator عشوائي

بعد تعريف IDiscountPolicy، قد تحتاج اختيار policy حسب segment أو tenant. تجنب حقن IServiceProvider داخل business service ثم طلب أي type بالاسم؛ هذا Service Locator ويخفي dependencies. عرّف resolver صغيرًا يملك mapping صريحًا، أو استخدم keyed DI services عندما تكون مفاتيح الاختيار ثابتة ومناسبة لإصدار ‎.NET المستخدم.

C#Explicit strategy resolver
public sealed class DiscountPolicyResolver(
    IEnumerable<IDiscountPolicy> policies)
{
    private readonly IReadOnlyDictionary<CustomerSegment, IDiscountPolicy> _map =
        policies.ToDictionary(x => x.Segment);

    public IDiscountPolicy Resolve(CustomerSegment segment) =>
        _map.TryGetValue(segment, out var policy)
            ? policy
            : throw new InvalidOperationException(
                $"No discount policy registered for {segment}.");
}

هذا يفترض أن كل policy تكشف Segment وأن registrations فريدة؛ أضف startup validation لاكتشاف duplicate/missing keys قبل وصول request. لو كل policy تحتاج configuration مختلفة، استخدم typed options أو factory registration واضحًا. لا تجعل كل business rule keyed service لمجرد أن framework يدعمها.

OCP هنا لا تعني عدم تعديل أي ملف إطلاقًا؛ إضافة نوع جديد قد تحتاج registration واختبارات وتحديثات business data. المقصود أن checkout flow لا يحتاج تعديلًا في كل مرة يظهر فيها algorithm جديد. قِس هل التوسعة أصبحت محلية وواضحة.

05

L — Liskov Substitution Principle

Subtypes must honor the base contract
Deep dive

لو type B يرث من A، أي caller يعتمد على A يجب أن يعمل مع B دون مفاجأة تكسر contract. لا تجعل derived class تقوي preconditions أو تضعف postconditions أو ترمي exception غير متوقعة في حالات base class تقبلها. الوراثة ليست مجرد مشاركة code.

C#A classic contract violation
public class Rectangle
{
    public virtual int Width { get; set; }
    public virtual int Height { get; set; }
    public int Area => Width * Height;
}

public sealed class Square : Rectangle
{
    public override int Width { get => base.Width; set => base.Width = base.Height = value; }
    public override int Height { get => base.Height; set => base.Width = base.Height = value; }
}

Caller قد يضع Width=5 ثم Height=4 ويتوقع Area=20؛ Square يغير width عند set height فيكسر expectation. الأفضل model مختلف أو abstraction مشتركة للقراءة فقط حسب الحاجة. اختبر subclasses عبر contract tests، وليس فقط unit tests منفصلة.

LSP بعمق: Preconditions و Postconditions و Invariants

Subtype لا يجب أن تطلب شروطًا أقوى من base contract (لا تقوي preconditions)، ولا تقدم ضمانات أضعف (لا تضعف postconditions)، وتحافظ على invariants المتوقعة. مثال: interface IReadOnlyStore.GetAsync تتوقع أن ترجع null عند عدم الوجود؛ implementation ترمي exception لكل miss تكسر contract. مثال آخر: base method تقبل أي positive amount، subtype ترفض بعض القيم من غير توثيق.

Contract tests تقدر تشغل نفس test suite على كل implementations. ده مفيد للـ repository providers أو payment adapters أو storage backends. اختبر behavior المشتركة: idempotency، cancellation، not-found semantics، retryability و thread-safety assumptions.

LSP عمليًا: Preconditions و Postconditions و Invariants

Substitution ليست مجرد أن subclass ترث interface وتنفذ methods. لو contract يقول إن Withdraw(amount) يرفض الرصيد السالب، فلا يجوز implementation تسمح به. subtype لا يجب أن تشدد precondition (تطلب input أكثر تقييدًا) ولا تضعف postcondition (تضمن أقل مما يضمنه الأصل)، ويجب أن تحافظ على invariants. هذا يفسر لماذا Square/Rectangle الكلاسيكي يسبب مشكلة عندما المستهلك يتوقع تغيير width و height مستقلين.

في APIs الواقعية، اكتب contract بوضوح: هل NotFound يرجع null أم exception؟ هل cancellation ترمي OperationCanceledException؟ هل repository يضمن stable ordering؟ هل payment gateway تعتبر timeout نتيجة مجهولة أم decline؟ implementation بديلة يجب تحترم نفس المعنى. Contract tests تساعد على فرض ذلك.

Contract Tests: اختبر LSP على كل Implementations

اختبار class منفردة لا يكفي لإثبات LSP. اكتب مجموعة contract tests مشتركة وشغّلها على كل implementations. مثلًا كل IDiscountPolicy يجب ألا تنتج خصمًا سالبًا أو أكبر من subtotal، وكل IClock يجب أن يعيد UTC وفق العقد، وكل repository يجب أن يحترم عدم وجود record كـ null أو NotFound حسب contract واحد واضح.

C#Shared contract test for discount policies
public abstract class DiscountPolicyContract
{
    protected abstract IDiscountPolicy CreatePolicy();

    [Fact]
    public void Discount_is_never_negative_or_above_subtotal()
    {
        var policy = CreatePolicy();
        var order = OrderTestData.WithSubtotal(100m);
        var discount = policy.Calculate(order);

        Assert.InRange(discount.Amount, 0m, order.Subtotal.Amount);
    }
}

public sealed class SeasonalDiscountTests : DiscountPolicyContract
{
    protected override IDiscountPolicy CreatePolicy() =>
        new SeasonalDiscountPolicy(rate: 0.10m);
}

الـ test abstract base هنا مجرد شكل توضيحي؛ في التطبيق قد تستخدم xUnit MemberData أو fixtures لتشغيل نفس suite على مجموعة implementations. اختبر الحدود: صفر، قيمة قصوى، عملة مختلفة، null/empty إن كان العقد يسمح، cancellation، timeout، والـ exception semantics. إذا فشل implementation واحد، فإما implementation خالف العقد أو العقد نفسه غير محدد جيدًا.

LSP و ISP في ‎.NET: العقود تشمل Failure و Lifetime مش Method Signatures فقط

وجود نفس method signature لا يثبت أن implementation بديل صالح. لو IPaymentGateway.ChargeAsync في implementation أول يرجع failure result عند رفض البطاقة، بينما implementation ثاني يرمي exception لكل رفض متوقع، فالـ callers سيضطرون يعرفوا النوع الحقيقي. العقد يجب يوضح expected failures، timeout behavior، idempotency، cancellation، thread-safety، و resource ownership. ده جوهر LSP: consumer يعتمد على contract behavior وليس concrete class.

مثال ISP: لا تضع ChargeAsync و RefundAsync و ReconcileAsync و SubscribeWebhooksAsync في interface واحدة إذا كان كل consumer يحتاج جزءًا مختلفًا. افصل interfaces حسب client needs. لكن لا تصنع interface لكل method؛ التقسيم المفيد يقلل coupling ويعكس capabilities حقيقية، وليس مجرد زيادة عدد الملفات.

C#Split capabilities by consumer needs
public interface IPaymentCharger
{
    Task<ChargeResult> ChargeAsync(
        ChargeRequest request, CancellationToken ct);
}

public interface IPaymentRefunder
{
    Task<RefundResult> RefundAsync(
        RefundRequest request, CancellationToken ct);
}

public interface IPaymentReconciliation
{
    Task<IReadOnlyList<Settlement>> GetSettlementsAsync(
        DateOnly day, CancellationToken ct);
}

حتى DI lifetime جزء من contract: singleton implementation لا يجوز أن تحتفظ بـ scoped DbContext. transient disposable service قد ينتهي عمره عند scope disposal. implementation التي تستخدم mutable shared state يجب أن تكون thread-safe إذا lifetime يسمح بمشاركة concurrent calls. اكتب tests على contract يمكن تشغيلها على كل adapters: نفس semantics للنجاح والفشل، نفس التعامل مع cancellation، وعدم كشف provider-specific exception للـ application.

DIP لا تعني أن كل dependency يجب أن تتحول إلى interface. DateTime قد تستبدل بـ TimeProvider عندما تحتاج deterministic time tests أو controllable clock. أما pure calculation لا تحتاج interface لمجرد mocking. abstraction boundary الجيدة تُعرّف من جهة consumer وتكشف أقل surface تكفيه.

LSP عملي: لا تجعل Subclass تكسر توقعات الـ Base Contract

مثال كلاسيكي: ReadOnlyRepository يرث Repository لكنه يرمي NotSupportedException من Add و Delete. الكود compile، لكنه ليس بديلًا صالحًا لأي consumer يتوقع repository قابلًا للتعديل. الأفضل تقسيم capability إلى `IReadRepository وIWriteRepository` أو استخدام contracts أدق حسب use case. LSP لا تمنع inheritance؛ تمنع أن subtype يغير معنى العقد بطريقة تفاجئ المستهلك.

C#Separate read and write capabilities
public interface IReadRepository<T>
{
    Task<T?> GetByIdAsync(Guid id, CancellationToken ct);
}

public interface IWriteRepository<T>
{
    Task AddAsync(T entity, CancellationToken ct);
    void Remove(T entity);
}

public sealed class OrderReadRepository(AppDbContext db)
    : IReadRepository<Order>
{
    public Task<Order?> GetByIdAsync(Guid id, CancellationToken ct) =>
        db.Orders.AsNoTracking().SingleOrDefaultAsync(x => x.Id == id, ct);
}

في المثال الواقعي قد تحتاج write repository يحمل aggregate tracking، بينما read repository يرجع DTO. لا تجعل read interface ترجع tracked entity ثم تفترض أنها read-only؛ caller قد يغيرها ويحفظها لاحقًا. اجعل semantics واضحة بالـ types والـ method names.

اختبر substitutability بسلوك مشترك: contract tests تشغل على SQL adapter و in-memory fake عندما يكون fake faithful. لو fake لا يحاكي uniqueness أو concurrency، لا تستخدم نجاحه دليلًا على صحة persistence. contract tests تساعد في توحيد expected behavior لكنها لا تستبدل provider integration tests.

06

I — Interface Segregation Principle

Clients should not depend on methods they do not use
Deep dive

Interface كبيرة تجبر implementations على methods لا تحتاجها، فتظهر NotImplementedException أو empty methods. قسمها إلى capabilities صغيرة حسب clients: ICanReadOrders، ICanRefundPayments، ICanExportReports. لا تقسم إلى interfaces من method واحدة بلا سبب؛ حجم contract يجب أن يعكس client needs.

C#Before — fat interface
public interface IWorker
{
    void Work();
    void Eat();
    void Sleep();
}
C#After — role-specific contracts
public interface IWorkable { void Work(); }
public interface IRestable { void Rest(); }
public sealed class Robot : IWorkable { public void Work() { } }
public sealed class Human : IWorkable, IRestable
{
    public void Work() { }
    public void Rest() { }
}

ISP مهم في integration interfaces أيضًا. لا تجعل ICloudStorage تشمل upload/download/delete/list/share/versioning إذا بعض clients تحتاج upload فقط. واجهة أصغر تقلل mocking burden وتغير contracts.

ISP بعمق: Client-Specific Interfaces

Interface Segregation تتحدد من منظور clients. لو consumer يحتاج قراءة فقط، لا تجبره على update/delete. لو worker يحتاج send، لا تجبره على template administration. interfaces الصغيرة تسهّل fake implementations وتقلل compile-time coupling، لكنها قد تصبح fragmentation لو كل interface لا تحمل معنى مستقلًا.

في C#‎، composition of interfaces قد تعبر عن capabilities: IOrderReader و IOrderWriter و IOrderExporter. service التي تحتاج read فقط تعتمد على reader. لا تجعل كل interface generic method واحدة لمجرد تطبيق ISP؛ خلي contract cohesive.

07

D — Dependency Inversion Principle

High-level policy should not depend on low-level details
Deep dive

DIP: high-level modules لا تعتمد على low-level modules مباشرة؛ الاثنين يعتمدان على abstractions. التفاصيل تعتمد على abstractions، وليس العكس. مثال: CheckoutService لا تنشئ SmtpClient أو SqlConnection داخلها؛ تعتمد على interfaces تعبر عن احتياجها، و composition root يربط implementations.

C#High-level use case depends on a port
public interface IPaymentGateway
{
    Task<PaymentResult> ChargeAsync(Money amount, string idempotencyKey,
                                    CancellationToken ct);
}

public sealed class CheckoutService(IPaymentGateway payment)
{
    public Task<PaymentResult> PayAsync(Order order, CancellationToken ct) =>
        payment.ChargeAsync(order.Total, $"order:{order.Id}", ct);
}

DI container أداة لتنفيذ dependency injection، لكنه ليس DIP نفسه. ممكن تستخدم DI مع تصميم سيئ لو كل service تعتمد على concrete infrastructure. وممكن تحقق DIP يدويًا عبر constructor injection من غير container. لا تجعل Domain/Application تعتمد على IServiceProvider وتعمل service locator؛ ده يخفي dependencies.

DIP بعمق: Abstractions Belong to the Policy Owner

الـ abstraction غالبًا يجب أن يملكها الجزء الذي يحتاج capability، لا الجزء الذي ينفذها. Application تعرف IPaymentGateway لأنها تحتاج charge operation؛ Infrastructure تنفذها باستخدام provider SDK. لو interface عكست كل method في SDK حرفيًا، فهي ليست domain-facing port بل wrapper حول vendor API.

Dependency Injection يربط implementation عند composition root. تجنب Service Locator (IServiceProvider.GetService داخل business class) لأنه يخفي dependencies ويجعل constructor لا يوضح احتياجاته. constructor injection يجعل dependency graph مرئيًا، ويسهل test setup.

ISP و DIP عند حدود النظام الخارجي

لو interface اسمها IExternalPaymentSdk وتحتوي 40 method من vendor، ثم domain يعتمد عليها، فهذا ليس DIP جيدًا؛ أنت نقلت coupling إلى interface. عرّف port صغيرًا يعبّر عن احتياج application مثل AuthorizeAsync و RefundAsync، ثم adapter في Infrastructure يترجم إلى SDK. ISP هنا يقلل methods غير المستخدمة، و DIP يجعل policy مستقلة عن detail.

لا تبالغ في تفتيت interface إلى method واحدة لكل class؛ اجمع العمليات التي يستهلكها actor واحد وتتغير معًا. راقب interface segregation من زاوية client usage: هل implementation تضطر ترمي NotSupportedException؟ هل consumer يعتمد على method لا يستخدمها؟ هل تغيير SDK يجبر domain على التغيير؟

08

Code Smells التي تكشف انتهاكات SOLID

Diagnose before refactoring
Deep dive
  • God class: class تتحكم في كل شيء؛ غالبًا SRP/cohesion issue.
  • Shotgun surgery: تغيير واحد يحتاج تعديل ملفات كثيرة؛ قد يكون coupling عاليًا.
  • Feature envy: method تقرأ بيانات object آخر أكثر من بيانات class نفسها؛ راجع responsibility assignment.
  • Switch on type: كل نوع جديد يضيف branch في أماكن متعددة؛ قد يحتاج polymorphism.
  • Fat interface: implementations ترمي NotImplementedException؛ ISP issue.
  • Concrete dependency construction: new SqlConnection/SmtpClient داخل policy؛ DIP issue.
  • Fragile base class: تغييرات base تكسر subclasses؛ LSP/Inheritance risk.
  • Primitive obsession: string/decimal تستخدم لمعانٍ business مختلفة؛ Value Objects قد تساعد.

Code smell ليس proof تلقائيًا. افهم السياق والـ change pressure قبل refactor. بعض switches على enum ثابتة وواضحة أفضل من hierarchy معقدة.

أمثلة انتهاكات SOLID وكيف تكتشفها في Code Review

SRP لا تعني أن كل class يجب أن تكون 10 أسطر؛ تعني أن مسؤولياتها تتبع actor أو محور تغيير متماسك. class فيها 300 سطر قد تكون متماسكة لو تمثل aggregate مع قواعده، و class فيها 20 سطر قد تجمع مسؤوليتين غير مرتبطتين. اسأل: هل تعديل tax rules يجبرني على لمس email rendering؟ هل persistence change يكسر domain policy؟ لو نعم، ابحث عن فصل حقيقي.

OCP لا تعني منع switch دائمًا. switch على enum مغلق وثابت قد يكون أوضح من عشر classes. استخدم polymorphism عندما توجد variations متوقعة ومتعددة وتتغير مستقلًا. LSP ليس مجرد عدم رمي exception؛ subclass يجب ألا تقوي preconditions أو تضعف postconditions أو تكسر invariants. مثال: Square يرث Rectangle لكن setter للعرض والطول المستقلين لا يحافظ على contract المستهلك.

ISP تعني أن المستهلك لا يعتمد على عمليات لا يحتاجها؛ لا تقسم interface إلى method واحدة آليًا. DIP يعني أن high-level policy لا تعتمد على low-level details، وأن abstraction تعبر عن حاجة المستهلك لا عن API المورد. لا تنقل كل interface إلى Core؛ ضعها عند الجهة التي تملك policy التي تحتاجها.

SOLID Code Review Checklist

  • SRP: هل تتغير class لأسباب/actors غير مترابطة؟
  • OCP: هل variation متوقع ومتكرر أم أننا نبني extension point مبكرًا؟
  • LSP: هل كل implementation تحترم نفس preconditions/postconditions/error semantics؟
  • ISP: هل consumer مضطر يعتمد على methods لا يستخدمها؟
  • DIP: هل policy الداخلية تعرف SDK/database/web framework بلا ضرورة؟

اطلب من author توضيح change scenario واحد قبل اقتراح abstraction. لو لا يوجد تغيير متوقع أو testability problem، قد يكون التصميم الحالي الأبسط أفضل. لا تستخدم SOLID كـ scorecard آلي أو سبب لإعادة كتابة code يعمل ويظل قابلًا للصيانة.

SOLID Decision Checklist: هل الـ Abstraction تستحق تكلفتها؟

  • حدد سبب التغيير المتوقع: هل هو provider، business rule، protocol، أم consumer مختلف؟
  • حدد من يجب أن يملك القرار: Domain policy، Application orchestration، أم Infrastructure adapter؟
  • اسأل هل interface تعبر عن حاجة consumer أم تعكس كل تفاصيل implementation؟
  • اختبر contract على implementation بديل واحد على الأقل إذا كانت substitution هي الهدف.
  • قارن الكود قبل وبعد: هل قل عدد أماكن التعديل أم أضفت طبقات indirection فقط؟
  • افحص failure paths و cancellation و concurrency، وليس happy path فقط.

لو إضافة implementation جديدة تتطلب تعديل 12 switch متفرقة، فهناك غالبًا abstraction ناقصة. لو إضافة implementation جديدة تتطلب تسجيل class واحدة واختبارات contract، فالتصميم قد وصل إلى extension point مناسب. لا تجعل «مفتوح للتوسعة» معناه أن كل feature يمكن إضافتها دون تعديل أي سطر؛ الهدف عزل التغيير المتوقع بتكلفة معقولة.

مراجعة SOLID كاملة على Feature واحدة

طلب المنتج الجديد: دعم بوابة دفع ثانية، وخصم موسمي، مع الاحتفاظ بسلوك checkout الحالي. لا تبدأ بإنشاء IPaymentFactoryFactory. اكتب change map: payment provider variation في Infrastructure adapter، discount algorithm variation في Domain/Application policy، orchestration ثابتة في Checkout use case. بذلك تعرف أين تحتاج extension points وأين يجب أن يظل الكود مغلقًا أمام التغيير.

SRP: كل module له سبب تغيير واضح؛ provider SDK لا يختلط بحساب الخصم. OCP: إضافة policy جديدة تتم بتسجيل implementation واختبارها دون نسخ checkout flow. LSP: بوابة الدفع الجديدة تلتزم semantics النجاح والرفض وال timeout و idempotency. ISP: checkout يحتاج charge contract، بينما reconciliation job يحتاج settlements contract. DIP: use case تعتمد على ports مستقرة، والـ SDK adapter يعتمد عليها من الخارج.

بعدها اختبر حالات التغيير: implementation ثانية للبوابة لا تحتاج تعديل checkout handler؛ خصم جديد لا يغير payment adapter؛ فشل provider لا يؤدي إلى اعتبار order مدفوع؛ retry بنفس idempotency key لا يخصم مرتين. لو احتجت تغييرًا في business invariant، عدّل Domain عمدًا؛ OCP لا تمنع تعديل policy نفسها عندما requirement تغير معناها.

قيّم تكلفة التصميم: عدد interfaces، registrations، resolvers، tests، وصعوبة تتبع call flow. لو الحل الجديد أصعب في القراءة من switch بسيط، ارجع خطوة. SOLID ناجحة عندما تجعل أسباب التغيير منفصلة وتُظهر dependencies، لا عندما تنتج أكبر عدد من abstractions.

09

Composition over Inheritance و Law of Demeter

Prefer explicit collaboration
Deep dive

Composition تسمح بتركيب behavior من collaborators، بينما inheritance تربط subtype ب base contract. استخدم inheritance عند is-a حقيقي ومستقر، واستخدم composition لتبديل strategy/policy أو دمج capabilities. Law of Demeter يقلل navigation chains إلى objects لا تخص caller مباشرة؛ لكنه heuristic وليس منعًا لكل property navigation.

Tell, Don't Ask: بدل ما caller يقرأ state ويقرر نيابة عن object، اطلب behavior يحافظ على invariants. لكن لا تضع orchestration بين aggregates داخل entity واحدة. القرار عن ownership والمسؤولية أهم من اتباع slogan حرفيًا.

10

DRY و KISS و YAGNI: مبادئ مساندة

Do not confuse reuse with good design
Practical

DRY يعني لا تكرر knowledge/rule واحدة في أماكن متعددة. لا يعني منع أي تكرار نصي؛ أحيانًا نسختان متشابهتان تتطوران لأسباب مختلفة، وتجميعهما يخلق coupling. KISS اختَر أبسط حل يفي بالمتطلبات، لا أبسط code شكليًا. YAGNI لا تنفذ abstraction/feature قبل الحاجة المثبتة.

مثال: لو tax rule نفسها مستخدمة في invoice و checkout، مصدر واحد للـ policy يمنع اختلاف الحساب. لكن لو formatting لرسالة email و PDF متشابه اليوم ولهما مستقبل مختلف، لا تجبرهما على generic formatter ضخم. اسأل هل المعرفة واحدة أم التشابه عرضي؟

11

Trade-offs و Refactoring Workflow

Improve design without rewriting everything
Practical

ابدأ بـ characterization tests للسلوك الحالي، ثم refactor خطوة صغيرة: Extract Method، Extract Class، Introduce Interface عند boundary، Replace Conditional with Polymorphism عند variation حقيقي، أو Compose methods. شغل tests بعد كل خطوة. لا تغير behavior و structure في commit واحد كبير إلا مع سبب واضح.

Overengineering يظهر عندما interfaces أكثر من implementations/requirements، أو pattern يحتاج شرحًا أطول من المشكلة، أو إضافة feature بسيطة تتطلب تعديل عشر طبقات. Underengineering يظهر عندما كل شيء في controller واحد، أو business rules duplicated، أو tests مستحيلة. SOLID يساعدك توازن بين الطرفين.

اختبار SOLID و Architecture Boundaries

اختبر SRP عمليًا عبر change scenarios: هل تعديل tax policy يجبرك تعدل email sender؟ اختبر OCP بإضافة strategy جديدة من غير تعديل core flow. اختبر LSP بتشغيل contract tests على كل subtype. اختبر ISP بأن clients لا تعتمد على methods لا تحتاجها. اختبر DIP عبر architecture rules تمنع Application من referencing vendor SDK/Infrastructure.

لا تقيس SOLID بعدد interfaces أو classes. قِس change impact، test friction، dependency direction، defect rate، ووضوح code review. أحيانًا switch expression صغيرة أفضل من Strategy pattern، وأحيانًا abstraction واحدة تمنع عشرات التعديلات المتكررة.

Refactoring Case: Notification Sender

تخيل class واحدة تختار channel، تبني template، تتحقق من preferences، ترسل HTTP، وتعمل retry. SRP يفصل template/preferences/delivery orchestration. OCP يسمح بإضافة channel جديدة عبر contract. LSP يضمن كل channel تحترم نفس semantics. ISP يفصل send capability عن administration. DIP يجعل application تعتمد على INotificationChannel لا على Twilio/SMTP SDK.

لكن لا تبالغ: لو التطبيق يرسل Email فقط ولا توجد channel variation متوقعة، يمكن EmailSender مباشرة. ابدأ بالـ simplest implementation ثم استخرج abstraction عند ظهور second channel أو integration boundary مهم. Refactor تدريجي مع tests أفضل من تصميم عام مسبقًا.

SOLID في Refactoring واحد: من Service متضخمة إلى Policy Composition

تخيّل خدمة Checkout تحتوي على حساب الخصم، واختيار بوابة الدفع، وحساب الشحن، وإرسال البريد، وكتابة سجل التدقيق. إضافة payment provider جديد تتطلب تعديل switch كبير، واختبار البريد يحتاج قاعدة بيانات، وتغيير الشحن يكسر checkout. هنا عندك أكثر من سبب للتغيير داخل class واحدة (SRP)، وتوسعة كل سياسة تتطلب تعديلها (OCP)، والاعتماد على concrete SDKs (DIP).

C#Policy interfaces represent independent variation
public interface IDiscountPolicy
{
    Money Calculate(Order order);
}
public interface IShippingQuote
{
    Money Calculate(Order order, Address destination);
}
public interface IPaymentGateway
{
    Task<PaymentResult> ChargeAsync(
        Money amount, string idempotencyKey, CancellationToken ct);
}

public sealed class CheckoutHandler(
    IDiscountPolicy discount,
    IShippingQuote shipping,
    IPaymentGateway payment,
    IOrderRepository orders)
{
    public async Task Handle(Checkout command, CancellationToken ct)
    {
        var order = await orders.GetForCheckout(command.OrderId, ct);
        var total = order.Subtotal - discount.Calculate(order)
                    + shipping.Calculate(order, command.Address);
        var result = await payment.ChargeAsync(
            total, command.IdempotencyKey, ct);
        if (!result.Succeeded) throw new PaymentFailedException();
        order.MarkPaid(result.Reference);
        await orders.SaveChangesAsync(ct);
    }
}

الـ interface هنا ليس هدفًا بذاته؛ كل واحدة تمثل policy لها سبب تغيير مستقل. لو كل implementation لا يختلف إلا بسطر أو لا يوجد احتمال واقعي لتبديله، concrete class قد تكون أبسط. OCP لا تعني أن الكود لا يتغير أبدًا؛ تعني أن التغيير المتوقع يمكن استيعابه في extension point مناسب دون تعديل core في كل مرة.

LSP: أي implementation لـ IPaymentGateway يجب أن تحترم نفس العقد: لا تعتبر timeout نجاحًا، ولا تعِد نتيجة غير متوافقة، ولا تتجاهل CancellationToken بصمت. ISP: لا تجبر خدمة الشحن على تنفيذ RefundAsync إن لم تكن مسؤولة عن refund. DIP: الواجهة يجب أن تصف احتياج الـ policy، لا أن تكون نسخة طبق الأصل من SDK الخارجي.

خطة Refactoring آمنة لتطبيق SOLID

ابدأ باختبار characterization للسلوك الحالي، ثم حدد سبب التغيير المتكرر، ثم استخرج pure calculation أو policy، ثم قدم interface فقط عند boundary مفيدة، ثم حقن dependency عبر constructor، ثم أضف contract tests لكل implementation. لا تعِد كتابة النظام كله دفعة واحدة. بعد كل خطوة شغّل tests وراجع diff.

قِس النتيجة عمليًا: هل اختبار discount أصبح بدون database؟ هل إضافة provider جديدة لا تحتاج تعديل core checkout؟ هل dependency graph بقي acyclic؟ هل عدد abstractions زاد أكثر من القيمة؟ إذا أصبح كل method وراء interface و factory و mediator بلا variation واقعية، تراجع عن بعض الطبقات. SOLID أداة للحفاظ على changeability، لا هدفًا شكليًا.

قياس أثر SOLID: Coupling و Cohesion و Change Cost

قبل refactoring سجل التغيير المتوقع: عدد الملفات المتأثرة، هل تحتاج قاعدة بيانات لاختبار pure rule، هل إضافة provider تغير core، وهل dependencies تتجه في دائرة. بعد refactoring قارن. لا تستخدم عدد interfaces أو classes مقياسًا للجودة؛ زيادة abstractions قد تزيد navigation و DI registration وتخفي flow.

علامات الإفراط: interface لها implementation واحدة ثابتة بلا seam مفيدة؛ factory تنشئ object واحدًا بلا قرار؛ mediator لكل method؛ repository يمرر DbSet كما هو؛ base class بها عشر hooks؛ و decorators متداخلة لا يعرف أحد ترتيبها. SOLID لا يمنع كل coupling؛ هو يساعد على جعل coupling في الاتجاه الصحيح وعند نقاط التغيير المهمة.

متى يكون عدم تطبيق SOLID هو القرار الأبسط؟

لو عندك دالة تحويل واحدة ثابتة لا تتوقع لها variants، interface و factory قد يكونان ضوضاء. لو class صغيرة لها سبب تغيير واحد، لا تفصلها لمجرد SRP. لو switch على enum مغلق أو protocol داخلي واضح، قد يكون أوضح من polymorphism. لو inheritance hierarchy مستقرة وتفي بالعقد، لا تستبدلها composition آليًا. SOLID مبادئ لتقليل تكلفة التغيير، وليست قوانين تمنع البساطة.

استخدم abstraction عندما تحتاج test seam حقيقية أو variation متوقعة أو boundary مع external system. اكتب test أولًا إذا كان سبب abstraction هو testability، وتأكد أن abstraction تعبر عن intent consumer. راجع تكلفة كل indirection في debugging، onboarding، و runtime DI graph.

SOLID Workshop: refactor خدمة خصومات من God Class إلى Composition

تخيل OrderService تحسب السعر، تختار الخصم، تتصل ببوابة الدفع، ترسل email، وتسجل audit. إضافة نوع خصم جديد تجبرك على تعديل class كبيرة، واختبار حساب السعر يتطلب mock لكل integrations. المشكلة ليست أن class طويلة فقط؛ المشكلة أن أسباب التغيير ومحاورها متجمعة في مكان واحد.

C#A focused policy contract
public interface IDiscountPolicy
{
    decimal Calculate(decimal subtotal, CustomerSegment segment);
}

public sealed class RegularDiscount : IDiscountPolicy
{
    public decimal Calculate(decimal subtotal, CustomerSegment segment)
        => segment == CustomerSegment.Member ? subtotal * 0.05m : 0m;
}

public sealed class VipDiscount : IDiscountPolicy
{
    public decimal Calculate(decimal subtotal, CustomerSegment segment)
        => segment == CustomerSegment.Vip ? subtotal * 0.15m : 0m;
}
C#Orchestrator depends on contracts, not concrete providers
public sealed class CheckoutService(
    IDiscountPolicy discount,
    IPaymentGateway payment,
    IOrderRepository orders)
{
    public async Task<CheckoutResult> CheckoutAsync(
        Order order, CustomerSegment segment, CancellationToken ct)
    {
        var discountValue = discount.Calculate(order.Subtotal, segment);
        var total = order.Subtotal - discountValue;
        var paymentResult = await payment.ChargeAsync(total, ct);
        if (!paymentResult.Succeeded)
            return CheckoutResult.PaymentFailed(paymentResult.Code);

        order.MarkPaid(paymentResult.TransactionId);
        await orders.SaveAsync(order, ct);
        return CheckoutResult.Success(order.Id, total);
    }
}

هذا مثال يوضح SRP/DIP وفتح نقطة variation؛ لكنه لا يحل وحده transaction/distributed consistency. في نظام حقيقي لا تنفذ charge ثم تحفظ order دون idempotency/compensation strategy؛ الدفع external side effect. قد تحتاج PaymentIntent state machine و outbox أو saga حسب provider guarantees.

مراجعة المبادئ هنا: SRP فصلت pricing policy عن orchestration و payment adapter. OCP تسمح بإضافة policy دون تعديل checkout orchestration، لكن اختيار policy يحتاج factory/DI registry أو resolver. LSP تعني أن كل payment gateway يحترم نفس semantics: timeout/failure/refund/idempotency. ISP تمنع interface واحدة ضخمة تجمع charge/refund/webhooks/reconciliation لكل consumer. DIP تجعل high-level checkout لا تعتمد على SDK vendor.

لا تفرط في abstraction: لو نوع الخصم واحد ولا يوجد تغير متوقع، function واحدة أو switch صغير قد يكون أوضح. اعمل refactor بناءً على change scenario حقيقي، ثم اكتب tests للـ policy والـ orchestration والـ failure paths.

12

اختبر فهمك

Knowledge check
Practical
هل SRP تعني method واحدة لكل class؟
لا؛ تعني responsibility متماسكة وسبب تغيير واضح، وليس عدد methods.
هل OCP يمنع تعديل الكود؟
لا؛ يوجهك لعزل variation المتكرر حتى يمكن إضافة behavior بأقل تعديل على stable code.
ما جوهر LSP؟
أي subtype يجب أن يحترم contract المتوقع من base type دون مفاجآت تكسر caller assumptions.
هل DI container يساوي DIP؟
لا؛ DI وسيلة wiring، أما DIP مبدأ اتجاه اعتماد source code على abstractions.
هل DRY يعني إزالة كل تكرار؟
لا؛ لا تدمج code متشابهًا إذا كان يمثل knowledge أو أسباب تغيير مختلفة.
↗

المراجع والقراءة الإضافية

References & further reading

الدرس بيشرح الفكرة نفسها؛ الروابط دي للتحقق والتعمق والرجوع لتفاصيل الـ API. (محتاجة إنترنت.)

التوثيق الرسمي — Official documentation

خريطة التغطية: 13 عنصر من الـ Roadmap ومكان شرحه في الدرس
RoadmapSingle Responsibility Principle§01
RoadmapOpen/Closed Principle§01
RoadmapLiskov Substitution Principle§01
RoadmapInterface Segregation Principle§01
RoadmapDependency Inversion Principle§01
RoadmapCommon Violations§01
RoadmapRefactoring Examples§01
RoadmapTrade-Offs§01
RoadmapOverengineering§01
SuggestedCode smells that reveal each violation§03
SuggestedDRY, KISS, YAGNI§01
SuggestedComposition over inheritance§01
SuggestedLaw of Demeter and Tell-Don't-Ask§01

خلصت الدرس وحليت الأسئلة؟ علّم عليه عشان يتحسب في تقدّمك.

محتويات الدرس