SOLID - zasady projektowania obiektowego
SOLID to akronim pięciu zasad programowania obiektowego, sformułowanych głównie przez Roberta C. Martina ("Uncle Bob"), które pomagają pisać kod łatwiejszy w utrzymaniu, testowaniu i rozszerzaniu.
S - Single Responsibility Principle (Zasada pojedynczej odpowiedzialności)
Klasa powinna mieć tylko jeden powód do zmiany - czyli odpowiadać tylko za jedną rzecz.
// Źle - klasa robi za dużo
public class User
{
public void SaveToDatabase() { /* ... */ }
public void SendEmail() { /* ... */ }
public void ValidateData() { /* ... */ }
}
// Dobrze - rozdzielone odpowiedzialności
public class User { /* tylko dane użytkownika */ }
public class UserRepository { public void SaveToDatabase(User user) { /* ... */ } }
public class EmailService { public void SendEmail(User user) { /* ... */ } }
public class UserValidator { public void Validate(User user) { /* ... */ } }
O - Open/Closed Principle (Zasada otwarte-zamknięte)
Kod powinien być otwarty na rozszerzenie, ale zamknięty na modyfikację. Zamiast zmieniać istniejący kod, dodajesz nowy.
// Źle - trzeba modyfikować przy każdym nowym typie
public class PaymentProcessor
{
public void Process(string type)
{
if (type == "card") { /* ... */ }
else if (type == "blik") { /* ... */ }
}
}
// Dobrze - dodajesz nową klasę zamiast modyfikować istniejący kod
public interface IPaymentMethod { void Process(); }
public class CardPayment : IPaymentMethod { public void Process() { /* ... */ } }
public class BlikPayment : IPaymentMethod { public void Process() { /* ... */ } }
L - Liskov Substitution Principle (Zasada podstawienia Liskov)
Obiekty klasy pochodnej muszą dać się podstawić w miejsce obiektów klasy bazowej bez zaburzenia poprawności programu.
// Źle - narusza LSP, bo Ostrich "łamie" zachowanie Bird
public class Bird { public virtual void Fly() { /* ... */ } }
public class Ostrich : Bird
{
public override void Fly() { throw new Exception("Struś nie lata!"); }
}
// Dobrze - osobna hierarchia dla ptaków nielatających
public class Bird { public virtual void Move() { /* ... */ } }
public class FlyingBird : Bird { public virtual void Fly() { /* ... */ } }
public class Ostrich : Bird { /* nie ma Fly() */ }
I - Interface Segregation Principle (Zasada segregacji interfejsów)
Lepiej mieć wiele małych, wyspecjalizowanych interfejsów niż jeden duży - klient nie powinien być zmuszany do implementowania metod, których nie potrzebuje.
// Źle - jeden "gruby" interfejs
public interface IWorker
{
void Work();
void Eat();
}
// Dobrze - rozdzielone interfejsy
public interface IWorkable { void Work(); }
public interface IEatable { void Eat(); }
public class Robot : IWorkable { public void Work() { /* ... */ } } // nie musi implementować Eat()
D - Dependency Inversion Principle (Zasada odwrócenia zależności)
Moduły wysokiego poziomu nie powinny zależeć od modułów niskiego poziomu - obie strony powinny zależeć od abstrakcji (interfejsów), nie od konkretnych implementacji.
// Źle - bezpośrednia zależność od konkretnej implementacji
public class OrderService
{
private MySqlDatabase _db = new MySqlDatabase();
}
// Dobrze - zależność od abstrakcji, wstrzykiwana z zewnątrz
public interface IDatabase { void Save(object data); }
public class OrderService
{
private readonly IDatabase _db;
public OrderService(IDatabase db) { _db = db; } // MySQL, Postgres, cokolwiek
}
Praktyczny sens SOLID nie polega na stosowaniu tego dogmatycznie w każdej linijce kodu (łatwo popaść w przesadny abstrakcjonizm), ale na tym, żeby mieć te zasady z tyłu głowy, gdy kod zaczyna być trudny w testowaniu, sztywny na zmiany albo gdy jedna zmiana w jednym miejscu psuje coś w drugim - to zwykle sygnał, że któraś z tych zasad jest łamana.