C# / .NET Kompendium PLEN
.NET / C# / SOLID, Clean Code, DI

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.

Postaw mi kawę