Tiszta kód

A tiszta kód olyan programkód, amely olvasható, könnyen érthető és karbantartható.
Ennek elérése érdekében a tiszta kód az egyszerűség, átláthatóság és megfelelő struktúra elveit követi.

A tiszta kód elengedhetetlen a hosszú távú karbantartás és fejlesztás szempontjából.
Egy tiszta kódbázis segít a csapatot a hatékony együttműködésében, és csökkenti a hibák ekletkezésének esélyét.

Olvashatóság     A kódot más fejlesztők könnyen megérthetik.
egyszerűség     A bonyolultság csökkentése gyorsabb hibajavítást és fejlesztést tesz lehetővé.
karbantarthatóság   A kód hosszú távon fenntartható és módosítható marad.

Olvashatóság
    Azt jelenti, hogy a kód könnyen érthető mind a fejlesztők, mind a tesztelők számára.
    Ennek érdekében:
        használjunk értelmes változó és függvényneveket.
        struktruáljuk a kódot logikus blokkokra.
        használjunk megfelelő indentálást és sorhosszúságot.

egyszerűség:
    Az egyszerűség elve szerint a kódot a lehető legegyszerűbben kell megírni, miközben minden szükséges funkcionalitást megvalósít.
    Kerüljük:
        A felesleges bonyolultságot,
        A fölösleges vagy redundáns kódrészeket

karbantarthatóság
    A karbantarthatóság érdekében a kódnak modulárisnak kell lennie, és megfelelően dokumentáltnak.
    Ez azt jelenti, hogy a kódrészleteket könnyen újra lehet használni és módosítani.

Kódolási szokások kialakítása
    Kód átalakítása olvashatóbbá
    Eredeti:
    public int Szamol(int x, int y){
        return x * y + 10;
    }

    átalakított:
    public int TeljesArSzamitas(int mennyiseg, int egysegar){
        const int ado = 10;
        return mennyiseg * egysegar + ado;
    }

indentálás és sorhosszúság
    Indentálás:
        Kövessük a nyelv által javasolt szabványokat
        (C# esetáben 4 szóközel vagy tab karakterrel igazítjuk a sor elejét)
    Sorhosszúság:
        Tartsuk a sorokat 80 - 100 karakter között,
        hogy a kód olvasható maradjon minden eszközön.

Fehérterek XDDDD
Whitespace-ek és kommentek helyes használata
    Hagyjunk üres sorokat a logikai blokkok között a kód strukturájának kiemelésére.
    Használjunk szóközöket az operátorok körül a kód olvashatóságának javítása éredkében.

Kommentek
    A kommentek a kód megértését segítik, de csak akkor használjuk őket, ha valóban szükséges.
    A fölösleges kommentek zavaróak lehetnek, és csökkentik az olvashatóságot.
    
    //A termék árának kiszámítása adóval
    public int TeljesArSzamitas(int mennyiseg, int egysegar){
        const int ado = 10;
        return mennyiseg * egysegar + ado;
    }

Megnevezési konvenciók és kódstruktúra
    Változók és metódusok elnevezése
        Válasszunk beszédes neveket, amelyek egyértelműen leírják a változó vagy metódus célját
        Kerüljük a rövidítéseket és az érthetetlen neveket 
        rossz:
            int c = 100;
        jó:
            int tetelszam = 100;

Projekt struktúrája
    Osztályokat és metódusokat rendezzünk logikus modulokba és csomagokba.
    Egy fájl egyetlen felelősséget lásson el.

Függvények és metódusok tisztasága
    Az egyetlen felelősség elve
        Egy függvény vagy metódus csak egy dolgot végezzen, és azt jól végezze el.
    Rövidség és egyszerűség
        A függvények legyenek rövidek, és kerüljük a túlzott összetettséget.
        Ha egy függvény túl hosszú, osszuk fel kisebb részekre.
    
    Rossz:
        public void ProcessData(string data){
            LoadData(data);
            ValidateData(data);
            SaveData(data);
        }

    Jó:
        public void LoadData(string data){

        }

        public void ValidateData(string data){

        }

        public void SaveData(string data){

        }

        public void ProcessData(string data){
            LoadData(data);
            ValidateData(data);
            SaveData(data);
        }

Hibakezelés alapelvei
    Try-catch blokkok helyes használata
        Csak ott használjunk hibakezelést, ahol szükséges.
        Adjunk pontos és érthető hibaüzeneteket.

    Rossz:
        try {
            int eredmeny = 10 / 0;
        } catch {
            Console.WriteLine("hiba");
        }

    Jó:
        try {
            int eredmeny = 10 / 0;
        } catch (DivideByZeroException ex){
            Console.WriteLine($"Hiba történt: {ex.Message}");
        }

    Rossz:
    try {
        streamreader ...
        file.Close();
    } catch (FileNotFoundException){
        CW("A fájl nem található")
    }

    Jó:
    try {
        using(streamreader file = new streamreader("data.txt")){
            string tartalom = file.ReadToEnd();
        }
    } catch (FileNotFoundException){
        CW("A fájl nem található")
    }

Refaktorálás
    A refaktorálás célja a kód minőségének javítása anélkül, hogy megváltoztatnánk annak viselkedését.
    Ez segít az olvashatóság és karbantarthatóság növelésében.

    Gyakori refaktoráláso lépések
        Változók és függvények átnevezése
        Redundáns kód eltávolítása
        Hosszú függvények felosztása kisebbekre
    
Kódszagok felismerése és javítása
    Kódszagok definíciója
        A kódszag olyan kódrészlet, amely potenciális problémára utal.
        Ezek közé tartozik:
            Hosszú függvények
            Redundancia
            Túl sok paraméter

Solid alapelvek alkalmazása
    S: Egyszeri felelősség elve (Single Responsibility Principle)
        Egy osztály csak egy dolgot csináljon, és annak felelőssége jól körülhatárolható legyen.
    O: Nyitott/zárt elv (open/closed Principle)
        Egy osztály legyen nyitott a bővítésre, de zárt a módosításra
    L: Liskov-helyettesítési elv (Liskov Substitution Principle)
        Egy származtatott osztály heléyettesíthető legyen az alaposztályával anélkül, hogy a program helytelenül működne.
    I: Interfész-szegregációs elv (Interface Segregation  Principle)
        Az interfészek legyenek kisebbel és specifikusabbak, hogy az implementáló osztályok ne legyenek
        kénytelenek fölösleges metódusokat megvalósítani.
    D: Függőség-inverzió elve (Dependency Inversion Principle)
        A magas szintű modulok ne függjenek alacsony szintű moduloktól, mindkettő absztrakciótól függjön.