SOLID principles

Five principles that make object-oriented designs easier to understand, change and maintain. The text is adapted from the training-algorithms repositories' README.

S Single Responsibility principle

“There should never be more than one reason for a class to change.”

A class should only have one reason to change
Separation of concerns
Different classes handle different, independent tasks

Diary

addNote(note)
removeNote(pos)
saveToFile(name)
loadFromFile(name)

PersistenceManager

saveToFile(diary, name)
loadFromFile(name)

Two reasons to change: note rules and file storage live in one class.

The repository splits a Diary (manages notes) from a PersistenceManager (saves and loads them):

training-algorithms-c_sharp/SOLID/SingleResponsibilityPrinciple.cs (excerpt)

/// Diary: manages notes only.
class Diary
{
    private List<string> notes = new List<string>();
    private int count = 0;

    public void AddNote(string note)
    {
        count++;
        notes.Add(quot;{count}: {note}");
    }
    public void RemoveNote(int pos) { /* validates and removes */ }
    public override string ToString() => string.Join("\n", notes);
}

/// PersistenceManager: saving and loading only.
class PersistenceManager
{
    public static void SaveToFile(Diary diary, string filename) { /* StreamWriter */ }
    public static Diary LoadFromFile(string filename) { /* StreamReader */ }
}

O Open–Closed principle

“Software entities should be open for extension, but closed for modification.”

Add behaviour by adding new code (subclasses, strategies), not by editing tested code

A code example for this principle is coming soon.

L Liskov Substitution principle

“Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.”

You should be able to substitute a base type with a subtype

A code example for this principle is coming soon.

I Interface Segregation principle

“Clients should not be forced to depend upon interfaces that they do not use.”

Don't put too much into an interface; split it into separate interfaces
YAGNI: You Aren't Gonna Need It

A code example for this principle is coming soon.

D Dependency Inversion principle

“Depend upon abstractions, not concretions.”

High-level modules should not depend on low-level ones; both use abstractions

A code example for this principle is coming soon.

Saved in this browser only. Part of Clean code foundations (0/5).