Úklid kódu — moduly, jmenné prostory a vlastní knihovna

Zatím jsi psal všechno do jednoho kusu kódu. To funguje, dokud je program malý. Jakmile má pár set řádků, začne se dít tohle:

• hledáš jednu metodu a scrolluješ minutu,
• omylem máš dvě věci se stejným jménem,
• bojíš se cokoli změnit, protože nevíš, co se rozbije.

Modul je pojmenovaná část programu, která má na starosti jednu věc. V C# je modul v podstatě jeden soubor .cs a v něm jedna třída.

Pravidlo, které se vyplatí: jeden soubor = jedna třída = jedno téma. Když se soubor jmenuje Data.cs, nesmí v něm být souboj.

// ===== soubor Data.cs =====
static class Data { ... }
// ===== konec Data.cs =====

Modul s daty a pomocnými metodami nechceš „vyrábět" přes new. Potřebuješ ho jen jednou a pořád stejný. Přesně na to je static class:

Console.WriteLine($"Míst na mapě: {Data.Mista.Count}");
Console.WriteLine($"První místo:  {Data.Mista[0]}");
Console.WriteLine($"Cena lektvaru: {Data.CenaLektvaru} zl.");

static class Data
{
    public const int CenaLektvaru = 25;

    public static List<string> Mista = new List<string>
    {
        "Mlžný hvozd",
        "Skřetí tábor",
        "Zřícenina Vraního hradu"
    };
}

Všimni si tří věcí:

• před class je static — třída se nedá vyrobit přes new,
• před každou položkou je taky static (nebo const),
• k obsahu se dostaneš přes jméno třídy s tečkou: Data.Mista.

To poslední je přesně to, co dělá modul modulem. Když někde v kódu uvidíš Data.Mista, hned víš, odkud to je.

Do modulu nepatří jen data, ale hlavně pomocné metody, které používáš pořád dokola. Dej je na jedno místo a napiš je jenom jednou:

Random kostka = new Random(7);

Console.WriteLine($"Hod k6:  {Nastroje.HodKostkou(kostka, 6)}");
Console.WriteLine($"Hod k20: {Nastroje.HodKostkou(kostka, 20)}");
Console.WriteLine($"Procenta: {Nastroje.Procenta(30, 120)} %");
Console.WriteLine(Nastroje.PruhZivotu(75, 120));

static class Nastroje
{
    public static int HodKostkou(Random kostka, int sten)
    {
        return kostka.Next(1, sten + 1);
    }

    public static int Procenta(int cast, int celek)
    {
        if (celek == 0)
        {
            return 0;
        }

        return cast * 100 / celek;
    }

    public static string PruhZivotu(int zivoty, int max)
    {
        int delka = zivoty * 20 / max;
        return $"│{new string('█', delka).PadRight(20, '░')}│ {zivoty}/{max}";
    }
}

Zkus si představit, kolikrát bys PruhZivotu psal bez modulu. Teď ho máš jednou — a když se ti nelíbí, opravíš ho na jednom místě.

Na začátku skoro každého C# programu jsou řádky jako using System;. Znamenají: „budu používat věci z téhle skupiny, nechci psát jejich celé jméno."

Celé jméno třídy Console je totiž System.Console. Bez using bys musel psát:

System.Console.WriteLine("Ahoj");

S using System; stačí Console.WriteLine("Ahoj"). Nic víc v tom není — using nic nenačítá ani nestahuje, jen zkracuje psaní.

Dvě méně známé podoby using, které se hodí znát, až budeš číst cizí kód:

// alias = přezdívka pro dlouhý název; patří vždy úplně nahoru
using Kostky = Nastroje;

Console.WriteLine($"Vetší z čísel: {Math.Max(12, 30)}");
Console.WriteLine($"Odmocnina:     {Math.Sqrt(81)}");
Console.WriteLine($"Přes přezdívku: {Kostky.HodKostkou(new Random(3), 6)}");

static class Nastroje
{
    public static int HodKostkou(Random kostka, int sten)
    {
        return kostka.Next(1, sten + 1);
    }
}

Všimni si, že using Kostky = Nastroje; je na prvním řádku. Všechny using musí být nad příkazy — jinak překladač zahlásí chybu.

Kdy alias použít: když máš dvě třídy se stejným krátkým jménem z různých knihoven. Jinak ho nepoužívej — kód se tím hůř čte.

Když roste projekt, nestačí jména tříd — dvě knihovny můžou mít obě třídu Hrac. Proto se třídy zabalují do jmenných prostorů:

// soubor Data.cs
namespace CsQuest.Herni;

static class Data
{
    public const int CenaLektvaru = 25;
}

// soubor Program.cs
using CsQuest.Herni;

Console.WriteLine(Data.CenaLektvaru);

Čti to takhle: namespace je příjmení třídy. Celé jméno naší třídy je CsQuest.Herni.Data. Řádek using CsQuest.Herni; znamená „v tomhle souboru můžu říkat jen Data".

A tady je ten most, který si zapamatuj:

U modulů je důležité rozhodnout, co je „vývěsní štít" a co je vnitřní šuplík:

Pravidlo pro dnešek: public jen to, co má někdo zvenku opravdu volat. Zbytek nech private. Modul se pak dá měnit zevnitř bez strachu, že tím něco rozbiješ jinde.

Console.WriteLine(Nastroje.PruhZivotu(60, 120));
Console.WriteLine(Nastroje.PruhZivotu(15, 120));

static class Nastroje
{
    private const int SirkaPruhu = 20;

    private static int Delka(int zivoty, int max)
    {
        return zivoty * SirkaPruhu / max;
    }

    public static string PruhZivotu(int zivoty, int max)
    {
        return $"│{new string('█', Delka(zivoty, max)).PadRight(SirkaPruhu, '░')}│ {zivoty}/{max}";
    }
}

Zvenku existuje jediná metoda PruhZivotu. Jak se počítá délka je vnitřní věc modulu — a to je přesně správně.

Poslední dnešní kousek. Když chceš postavu uložit, musíš z ní udělat text. A když ji chceš načíst, musíš text zase rozebrat. Dvě metody, které to řeší:

• NaRadek() — objekt → text (je to metoda objektu, ví o sobě všechno),
• ZRadku(...) — text → objekt (je static, protože objekt teprve vznikne).

Postava hrdina = new Postava("Elrik", 120, 13);
string radek = hrdina.NaRadek();

Console.WriteLine($"Uloženo jako: {radek}");

Postava nactena = Postava.ZRadku(radek);
Console.WriteLine($"Načteno zpět: {nactena.Jmeno}, {nactena.Zivoty} HP, síla {nactena.Sila}");

class Postava
{
    public string Jmeno { get; set; }
    public int Zivoty { get; set; }
    public int Sila { get; set; }

    public Postava(string jmeno, int zivoty, int sila)
    {
        Jmeno = jmeno;
        Zivoty = zivoty;
        Sila = sila;
    }

    public string NaRadek()
    {
        return $"{Jmeno};{Zivoty};{Sila}";
    }

    public static Postava ZRadku(string radek)
    {
        string[] casti = radek.Split(';');
        return new Postava(casti[0], int.Parse(casti[1]), int.Parse(casti[2]));
    }
}

Tenhle pár metod je základ každého ukládání hry. Na disk se to zapíše až doma (File.WriteAllLines), ale převod objektu na text je ta zajímavá část — a tu už umíš.

Napřed to, co většina z vás má teď: všechno v jednom. Pak to samé, jen rozdělené. Program dělá přesně totéž.

Co si z toho odnést: modul není o tom, že program umí víc. Je o tom, že se v něm dá orientovat.

Dobrý modul ukazuje ven jen pár metod a zbytek schová. Tahle ukázka má sedm metod, ale zvenku se volají jen tři.

Co si z toho odnést: private není omezení, ale svoboda. Co je uvnitř, můžeš kdykoli přepsat — zvenku to nikdo nepozná.

Všechna čísla a texty hry na jednom místě. Když chceš hru vyladit, otevřeš jediný soubor a neriskuješ, že rozbiješ pravidla.

Co si z toho odnést: vyvažování hry (jestli je moc lehká, nebo těžká) je pak otázka pár čísel v jednom souboru.

Objekt převedený na řádek textu a zase zpátky. To je celý základ ukládání hry.

Co si z toho odnést: NaRadek() a ZRadku() musí vždycky sedět k sobě. Když do jednoho něco přidáš, musíš to přidat i do druhého.

Finální podoba: čtyři moduly a hlavní část, která se dá přečíst nahlas. Přesně takhle by měl tvůj projekt vypadat po dnešní hodině.

Co si z toho odnést: hlavní část programu má teď třicet řádků a čte se skoro jako popis hry. To je cíl.

Chyby kolem modulů vypadají divoce, ale je jich jen pár druhů.

Zadání:

Vytáhni všechna data hry z hlavní části programu do vlastního modulu Data.

1. Založ static class Data a dej do ní seznam míst
   💡 Poradit

   Statická třída patří — jako každá třída — pod příkazy:
   static class Data
{
public static List<string> Mista = new List<string> { "Mlžný hvozd" };
}
   Nezapomeň na public i na static u položky.
2. Vypiš místa přes Data.Mista
   💡 Poradit

   K obsahu modulu se chodí vždycky přes jméno třídy a tečku:
   foreach (string m in Data.Mista)
   Kdybys napsal jen Mista, dostaneš CS0103.
3. Přidej konstanty NazevHry a CenaLektvaru
   💡 Poradit

   public const string NazevHry = "CsQuest";
public const int CenaLektvaru = 25;
   U const se static nepíše — je statická automaticky.
4. Přidej seznam předmětů a jejich cen
   💡 Poradit

   Dva seznamy vedle sebe (stejné pořadí), nebo rovnou slovník:
   public static Dictionary<string, int> Ceny = new Dictionary<string, int>
{
{ "Lektvar", 25 },
{ "Meč", 90 }
};
5. Přidej nové místo a ověř, že se objeví samo
   💡 Poradit

   Dopiš řádek jen do Data.Mista a hlavní část nech úplně beze změny. Pokud se nové místo objevilo, modul funguje přesně tak, jak má.

Zadání:

Postav modul Nastroje s pomocnými metodami, které používáš pořád dokola.

1. Vytvoř static class Nastroje s metodou HodKostkou(Random, int)
   💡 Poradit

   Metoda ve statické třídě musí být taky static:
   public static int HodKostkou(Random kostka, int sten)
{
return kostka.Next(1, sten + 1);
}
   Pozor na sten + 1 — horní mez u Next se nikdy netrefí.
2. Přidej Procenta(int cast, int celek)
   💡 Poradit

   Hlídej dělení nulou:
   if (celek == 0) { return 0; }
return cast * 100 / celek;
   Násob nejdřív stem, jinak ti celočíselné dělení sežere výsledek.
3. Přidej PruhZivotu(int zivoty, int max)
   💡 Poradit

   Spočítej délku plné části a zbytek dopadni tečkami:
   int delka = zivoty * 20 / max;
return new string('█', delka).PadRight(20, '░');
4. Schovej pomocné výpočty jako private
   💡 Poradit

   Konstantu šířky i výpočet délky nikdo zvenku nepotřebuje:
   private const int SirkaPruhu = 20;
private static int Delka(int zivoty, int max) { ... }
   Zvenku zůstane viditelná jen PruhZivotu.
5. Použij modul v malé simulaci tří kol
   💡 Poradit

   Založ Random kostka = new Random(4);, v cyklu ubírej životy o Nastroje.HodKostkou(kostka, 10) a po každém kole vypiš Nastroje.PruhZivotu(...). Seed 4 zajistí, že výsledek bude pokaždé stejný.

Zadání:

Rozděl program na tři „soubory": třídu Postava, modul Vypis a hlavní část.

1. Napiš třídu Postava s konstruktorem a ToString()
   💡 Poradit

   Obyčejná třída, tedy bez static — postav chceš víc:
   class Postava
{
public string Jmeno { get; set; }
public Postava(string jmeno, int zivoty) { ... }
}
2. Přidej modul Vypis s metodou Radek(Postava p)
   💡 Poradit

   Modul dostane celou postavu jako parametr:
   public static string Radek(Postava p)
{
return $"{p.Jmeno,-8} {p.Zivoty,4} HP";
}
   Musí být static, protože Vypis je statická třída.
3. Přidej Vypis.Nadpis() a Vypis.Cara()
   💡 Poradit

   Čáru sestavíš z opakovaného znaku:
   public static string Cara() => new string('═', 46);
   Nadpis pak vypadá jako čára, text, čára.
4. Ohranič každou část komentářem „souboru"
   💡 Poradit

   Před třídu napiš // ===== soubor Postava.cs ===== a za ni // ===== konec Postava.cs =====. Doma ve VS Code to bude opravdový soubor a tyhle komentáře zmizí.
5. Vypiš celou družinu jednou smyčkou
   💡 Poradit

   List<Postava> druzina = new List<Postava>();
   Naplň ji a pak:
   foreach (Postava p in druzina) { Console.WriteLine(Vypis.Radek(p)); }
   Hlavní část má tak jen pár řádků.

Zadání:

Nauč postavu převést se na řádek textu a zase se z něj složit.

1. Přidej Postava metodu NaRadek()
   💡 Poradit

   Obyčejná metoda objektu — ví o sobě všechno:
   public string NaRadek()
{
return $"{Jmeno};{Zivoty};{Sila}";
}
   Středník jako oddělovač se hodí, protože se v jménech nevyskytuje.
2. Přidej statickou metodu ZRadku(string)
   💡 Poradit

   Musí být static — objekt teprve vznikne:
   public static Postava ZRadku(string radek)
{
string[] casti = radek.Split(';');
return new Postava(casti[0], int.Parse(casti[1]), int.Parse(casti[2]));
}
3. Ulož celou družinu do List<string>
   💡 Poradit

   Simulujeme soubor seznamem řádků:
   List<string> soubor = new List<string>();
foreach (Postava p in druzina) { soubor.Add(p.NaRadek()); }
   Doma z toho bude File.WriteAllLines("hra.txt", soubor).
4. Načti družinu zpátky a ověř, že sedí
   💡 Poradit

   Projdi řádky a skládej nové objekty:
   foreach (string r in soubor) { nactena.Add(Postava.ZRadku(r)); }
   Potom porovnej Sum nebo Count původní a načtené družiny.
5. Ošetři poškozený řádek
   💡 Poradit

   Před rozebráním zkontroluj počet částí a použij int.TryParse:
   if (casti.Length != 3) { return null; }
if (!int.TryParse(casti[1], out int z)) { return null; }
   Návratový typ pak bude Postava? a při načítání null přeskočíš.

Zadání:

Rozděl celý CsQuest na čtyři moduly. Hlavní část má zůstat krátká a čitelná.

1. Založ modul Data se všemi čísly a texty hry
   💡 Poradit

   Do Data patří všechno, co bys chtěl ladit: názvy míst, obtížnosti, startovní zlato, ceny. Pravidlo: když je v hlavní části číslo, patří do Data.
2. Přidej modul Nastroje s kostkou a pruhem
   💡 Poradit

   Vezmi metody z cvičení 2 — HodKostkou a PruhZivotu. Nic nevymýšlej znovu, jen je zkopíruj do nové statické třídy.
3. Přesuň Postava do vlastního „souboru"
   💡 Poradit

   Třída Postava ať umí Utoc, Zranit a Zije. Pravidla postavy patří do postavy, ne do hlavní části.
4. Přidej modul Hra s metodou Souboj(...)
   💡 Poradit

   public static bool Souboj(Postava hrdina, string nepritel, int obtiznost, Random r)
   Vrať true při vítězství. Uvnitř nech cyklus, ale vždy s pojistkou kolo <= 20, ať se nezacyklí.
5. Nech v hlavní části jen průběh výpravy
   💡 Poradit

   Hlavní část má být skoro jako scénář:
   foreach místo → Hra.Souboj(...) → výpis → když padne, break
   Spočítej si řádky. Míň než 30 je výborné.

Ukliď svůj CsQuest do modulů a přines ho na příští hodinu — bude to základ finále.

• modul Data se všemi čísly a texty hry (žádné číslo v hlavní části),
• modul Nastroje s alespoň třemi pomocnými metodami,
• třídy Postava a Prisera v jasně oddělených „souborech",
• modul Hra s aspoň jednou metodou, která řídí souboj nebo výpravu,
• v hlavní části méně než 40 řádků — jen průběh hry.

Bonus: přidej NaRadek() a ZRadku(), aby se postava dala uložit a načíst.

Oficiální dokumentace je místo, kam se programátoři chodí podívat, když si chtějí něco ověřit nebo zjistit víc detailů. Je většinou v angličtině, ale to nevadí — zkus se orientovat podle názvu příkazu a podle ukázek kódu.

Pro rychlejší studenty, kteří dokončí cvičení dřív, nebo na posledních 10–15 minut.

Sekce o funkcích je dnes nejvhodnější, protože modul není nic jiného než dobře pojmenovaná sbírka funkcí.