SOLID: Päť princípov kvalitného objektového návrhu

Ako písať kód, ktorý je prehľadný, udržateľný a ľahko rozširovateľný

SOLID je súbor piatich princípov objektovo orientovaného návrhu, ktoré pomáhajú vytvárať čitateľný, flexibilný, testovateľný a udržateľný kód. Tieto princípy sú základom modernej architektúry vo väčšine objektovo orientovaných jazykov ako C#, Java, Python či C++.

---

Čo znamená SOLID?

• S – Single Responsibility Principle
• O – Open/Closed Principle
• L – Liskov Substitution Principle
• I – Interface Segregation Principle
• D – Dependency Inversion Principle

---

1. Single Responsibility Principle (SRP)

Trieda by mala mať len jeden dôvod na zmenu.
Každá trieda má vykonávať jednu jedinú zodpovednosť.

Príklad – nesprávny dizajn:

public class ReportService
{
    public void GenerateReport() { }
    public void SaveToFile() { }
    public void SendEmail() { }
}

Príklad – správny dizajn:

public class ReportGenerator { }
public class FileSaver { }
public class EmailSender { }

---

2. Open/Closed Principle (OCP)

Softvér má byť otvorený pre rozšírenie, ale uzavretý pre zmenu.
Nové funkcionality sa majú pridávať bez zmien v existujúcom kóde.

Príklad – nesprávny dizajn:

public class DiscountService
{
    public decimal GetDiscount(Customer c)
    {
        if (c.Type == "Regular") return 0.05m;
        if (c.Type == "Vip") return 0.20m;
        return 0;
    }
}

Príklad – správny dizajn:

public interface IDiscountStrategy
{
    decimal GetDiscount();
}

public class RegularCustomerDiscount : IDiscountStrategy
{
    public decimal GetDiscount() => 0.05m;
}

public class VipCustomerDiscount : IDiscountStrategy
{
    public decimal GetDiscount() => 0.20m;
}

---

3. Liskov Substitution Principle (LSP)

Potomok musí byť plnohodnotnou náhradou svojho predka.
Triedy odvodené od iných tried sa musia dať používať bez porušenia logiky aplikácie.

Príklad – nesprávny dizajn:

public class Bird
{
    public virtual void Fly() { }
}

public class Ostrich : Bird
{
    public override void Fly()
    {
        throw new NotSupportedException();
    }
}

Príklad – správny dizajn:

public abstract class Bird { }

public class FlyingBird : Bird
{
    public void Fly() { }
}

public class Ostrich : Bird { }

---

4. Interface Segregation Principle (ISP)

Klienti nemajú byť nútení implementovať metódy, ktoré nevyužívajú.
Rozhrania majú byť malé, špecializované a presné.

Príklad – nesprávny dizajn:

public interface IWorker
{
    void Work();
    void Eat();
}

Príklad – správny dizajn:

public interface IWorkable
{
    void Work();
}

public interface IEatable
{
    void Eat();
}

---

5. Dependency Inversion Principle (DIP)

Závislosti majú smerovať od detailov ku abstrakciám.
Triedy nemajú závisieť od konkrétnych implementácií, ale od rozhraní.

Príklad – nesprávny dizajn:

public class NotificationService
{
    private EmailSender _sender = new EmailSender();

    public void Notify(string message)
    {
        _sender.Send(message);
    }
}

Príklad – správny dizajn:

public interface IMessageSender
{
    void Send(string message);
}

public class EmailSender : IMessageSender
{
    public void Send(string message) { }
}

public class NotificationService
{
    private readonly IMessageSender _sender;

    public NotificationService(IMessageSender sender)
    {
        _sender = sender;
    }
}

---

Zhrnutie SOLID

Princíp	Význam
S	Jedna trieda = jedna zodpovednosť
O	Možnosť rozšírenia bez úprav existujúceho kódu
L	Deti musia plne nahradiť rodičov
I	Malé, presné rozhrania
D	Závislosť na abstrakciách, nie detailoch

---

Záver

SOLID je základ profesionálneho objektovo orientovaného návrhu. Dodržiavaním týchto piatich princípov získate kód, ktorý je flexibilný, ľahko rozšíriteľný a dlhodobo udržateľný. Tieto princípy prirodzene vedú ku kvalitnej architektúre a znižujú množstvo chýb v projekte.