added solid

adatstrukturak

@@ -380,4 +380,13 @@ Beszúrásos rendezés
     Továbbá akkor igen hatékony, ha egy rendezett sorozatot bővítünk és a bővítés után is szeretnénk,
     hogy a sorozat rendezett maradjon.
 
-    Az algoritmus futási ideje legjobb esetben konstans, legrosszabb esetben négyzetes.
+    Az algoritmus futási ideje legjobb esetben konstans, legrosszabb esetben négyzetes.
+    Pszeudokód:
+            Ciklus i = 6 -tól 1-ig
+                j = i - 1
+                tmp = a[i]
+                AMÍG (j >= 0) és (a[j] > tmp)
+                    a[j+1] = a[j]
+                    j = j - 1
+                a[j+1] = tmp
+

cleancode

@@ -0,0 +1,178 @@
+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.
+    
+