Vývoj v C# a .NET

Python a JS (Dynamické)

Nepíšeme datové typy. Program si je odhadne. Bloky děláme odsazením.

# Nepíšeme datové typy
jmeno = "David"

# Odsazení dělá blok
if jmeno == "David":
    print("Ahoj!")

C# (Statický)

Musíme přesně určit datový typ předem, bloky děláme závorkami {}.

// Typ musíme deklarovat
string jmeno = "David";

// Bloky dělají závorky {}
if (jmeno == "David")
{
    Console.WriteLine("Ahoj!");
} // Nezapomenout středník!

Jak se kód čte?

Kód se vykonává odshora dolů, úplně stejně jako v Pythonu.

Každý příkaz (akce), který má program provést, musí být na konci ukončen středníkem ;.

Ukázka kódu

// Vypíše text do konzole a odřádkuje
Console.WriteLine("Hello, World!");

// Můžeme rovnou psát další logiku
int pocet = 10;
Console.WriteLine(pocet);

Základní datové typy

V C# musíme na každý "šuplík" v paměti nalepit štítek s datovým typem:

• int pro celá čísla (15, -5)

• string pro text (do dvojitých uvozovek: "Ahoj")

• char pro jeden jediný znak (do apostrofů: 'A')

• double pro desetinná čísla (výchozí v C#, vysoká přesnost)

• float pro desetinná čísla (šetří paměť, nutné 'f': 15.5f)

• bool pro pravdu/nepravdu (true)

Interpolace (Spojování)

Znak $ před uvozovkami nám dovolí vložit proměnnou přímo do textu pomocí {}.

int vek = 20;
string jmeno = "David";

Console.WriteLine($"Jmenuje se {jmeno} a je mu {vek} let.");

Celá čísla: int vs byte

int (4 byty) je standard na počítání. Vejde se do něj až 2 miliardy.

byte (1 byte) umí jen čísla od 0 do 255. Nevyplatí se ho běžně používat k počítání, ale celý svět ho používá na barvy (RGB) nebo síťovou komunikaci!

Desetinná čísla: double vs float

double (8 bytů) je ultra-přesný (na 15 míst). Je to výchozí volba v C# pro výpočty.

float (4 byty) je poloviční. Milují ho 3D Hry (Unity) a grafické karty! Milion pozic objektů (X,Y,Z) jako float zabere polovinu paměti a hra běží rychleji.

Čtení textu

Console.ReadLine() čeká na uživatele. Vždy ale vrací text (string).

Console.WriteLine("Jak se jmenuješ?");
string jmeno = Console.ReadLine();

Překlad na číslo (Parse)

Text "20" se musí přeložit na matematické číslo 20 pomocí int.Parse().

Console.WriteLine("Zadej věk:");
string textVek = Console.ReadLine();

// Překlad textu na číslo!
int cisloVek = int.Parse(textVek);

Jak to funguje?

Podmínka musí být vždy v kulatých závorkách (). Blok kódu k vykonání je ve složených {}.

Na rozdíl od Pythonu (kde je elif), v C# používáme celá slova else if.

Ukázka kódu

int vek = 16;

if (vek >= 18) 
{
    Console.WriteLine("Vstup povolen.");
}
else if (vek == 17) 
{
    Console.WriteLine("Ještě jeden rok!");
}
else 
{
    Console.WriteLine("Vstup odepřen.");
}

Seznam hodnot

Když potřebujeme uložit více věcí stejného typu, nepíšeme proměnnou pro každou zvlášť. Vytvoříme pole pomocí hranatých závorek [].

Důležité: Počítáme vždy od nuly! První prvek má index 0.

Práce s polem

// Vytvoření pole s konkrétními daty
string[] batoh = { "Meč", "Lektvar", "Klíč" };

// Přečtení prvního prvku
Console.WriteLine(batoh[0]); // Vypíše Meč

// Změna druhého prvku
batoh[1] = "Zlato";

Zkusíme vypsat vše najednou?

Pokud do výpisu vložíme přímo naši proměnnou batoh, neuvidíme její obsah.

string[] batoh = { "Meč", "Lektvar" };
Console.WriteLine(batoh);

Výsledek: System.String[]

Počítač nám tím říká: "Vím, že je to pole textů, ale neřekl jsi mi, abych ho otevřel a přečetl položky uvnitř."

Abychom vypsali jednotlivé věci, musíme pole projít cyklem!

Foreach (Čtecí cyklus)

Kratší, přehlednější a bezpečný. Slouží k pouhému čtení a výpisu položek z pole. Položky pomocí něj nelze upravovat.

foreach (string vec in batoh) 
{
    Console.WriteLine(vec);
}

For (Pracovní cyklus)

Máme v ruce počítadlo i (pozici v poli). Můžeme tak vypsat pořadová čísla, nebo položky uvnitř pole měnit a přepisovat.

for (int i = 0; i < 2; i++) 
{
    batoh[i] = "Zlato"; // Změna prvku
}

Operátor %

Kromě dělení (/) máme v programování i operátor % (modulo). Ten vrací zbytek po celočíselném dělení.

Nejčastěji ho používáme ke zjištění, zda je číslo sudé nebo liché.

Ukázka: Sudá a lichá

// 5 děleno 2 je 2, zbytek je 1
int zbytek = 5 % 2; 

if (cislo % 2 == 0) 
{
    Console.WriteLine("Číslo je sudé!");
}
else 
{
    Console.WriteLine("Číslo je liché!");
}

Když neznáme data předem

Zatím jsme pole plnili hned při vytvoření. Co když ale chceme, aby si uživatel sám určil, kolik hodnot bude zadávat?

Musíme vytvořit prázdné pole o určité délce. Paměť se připraví, ale šuplíky budou zatím prázdné.

Ukázka v kódu

Console.WriteLine("Kolik chceš čísel?");
int delka = int.Parse(Console.ReadLine());

// Vytvoření prázdného pole o zadané velikosti
int[] cisla = new int[delka];

// První prvek můžeme rovnou naplnit
cisla[0] = 42;

Jak generovat náhodná čísla?

Ve hrách i aplikacích často potřebujeme náhodu (hod kostkou, poškození nepřítele, loot).

V C# si vytvoříme "generátor" pomocí new Random() a pak z něj taháme čísla metodou Next(min, max).

Ukázka: Hod kostkou

// Vytvoříme si generátor náhody (stačí jednou)
Random kostka = new Random();

// Chceme číslo od 1 do 6
// POZOR: Horní hranice tam už NEPATŘÍ! 
// Proto musíme napsat 7.
int hod = kostka.Next(1, 7);

Console.WriteLine($"Padlo ti: {hod}");

Princip DRY

Don't Repeat Yourself (Neopakuj se). Pokud kopírujete stejný kód na více míst, děláte to špatně.

Když v kopírovaném kódu najdete chybu, musíte ji opravovat na deseti místech. To nikdo nechce.

Lego kostky (Metody)

Kód, který dělá jednu logickou věc (např. Vypíše menu nebo Spočítá daň), zabalíme do vlastního pojmenovaného bloku.

Tento blok (Metodu) pak můžeme "zavolat" kolikrát chceme jediným slovem.

Python

V Pythonu se funkce definuje klíčovým slovem def.

# Definice funkce
def pozdrav():
    print("Ahoj z funkce!")

# Zavolání funkce
pozdrav()

C#

V C# musíme říct, co metoda vrací. Pokud nevrací nic (jen něco např. vypíše), používáme slovo void (prázdnota).

// Definice metody
void Pozdrav()
{
    Console.WriteLine("Ahoj z metody!");
}

// Zavolání metody
Pozdrav();

Jak přijmout data?

Metoda může do kulatých závorek () dostat proměnné, se kterými pak bude uvnitř pracovat.

Zásadní: I v závorkách musíme striktně definovat datový typ (zda jde o string nebo int)!

Ukázka v kódu

// Metoda přijímá dvě hodnoty (text a číslo)
void Uvitani(string jmeno, int vek)
{
    Console.WriteLine($"Ahoj {jmeno}!");
    Console.WriteLine($"Je ti {vek} let.");
}

// Zavolání s konkrétními hodnotami (Argumenty)
Uvitani("Martin", 25);
Uvitani("Jana", 30);

Vracení hodnot

Pokud chceme, aby metoda něco spočítala a vrátila výsledek (abychom si ho uložili), přestaneme psát void.

Před jméno metody napíšeme, jaký typ vracíme (např. int nebo string) a uvnitř použijeme return.

Kalkulačka

// Metoda vrací int (celé číslo)
int SectiCisla(int a, int b)
{
    int vysledek = a + b;
    return vysledek; // Předá data ven!
}

// Voláme metodu a výsledek si ULOŽÍME do šuplíku
int mojeCislo = SectiCisla(10, 5);
Console.WriteLine(mojeCislo);

Dlouhý a nepřehledný if-else

Když máte v menu 5 a více možností, neustálé opakování else if (volba == X) dělá kód špatně čitelný.

Ztrácíme přehled o tom, co přesně testujeme.

Příklad z kalkulačky

if (volba == 1) {
    vysledek = Secti(a, b);
}
else if (volba == 2) {
    vysledek = Odecti(a, b);
}
else if (volba == 3) {
    // ... a tak dále
}
else {
    Console.WriteLine("Špatná volba.");
}

Jak Switch funguje?

Dáme mu proměnnou (např. volba) a pak definujeme jednotlivé "případy" (case).

Dvě klíčová pravidla:

• Každý case musí končit slovem break; (jinak kód spadne).
• Na konci je default: (funguje jako závěrečné else).

Čistý kód

switch (volba)
{
    case 1:
        vysledek = Secti(a, b);
        break;
    case 2:
        vysledek = Odecti(a, b);
        break;
    default:
        Console.WriteLine("Špatná volba.");
        break;
}

Zavři oči a běž

Náš program zatím funguje tak, že se zeptá, vezme odpověď a hned skončí. Ať už uživatel zadá 1, nebo nesmysl jako 99.

Co když chceme, aby se po dokončení výpočtu vrátil zpět do menu? Nebo aby se ptal znovu, když uživatel zadá neplatnou volbu?

Cyklus While (Zatímco)

Cyklus while se opakuje neustále dokola, dokud platí zadaná podmínka.

Je to vlastně if, který se opakuje, dokud nepřestane platit.

Počítadlo (podobně jako for)

Můžeme ho použít jako jednodušší verzi for cyklu. Vytvoříme si proměnnou, v cyklu ji zvyšujeme a testujeme, jestli už je dost velká.

Ukázka: Odpočet

int pocetPokusu = 3;

while (pocetPokusu > 0)
{
    Console.WriteLine($"Zbývá pokusů: {pocetPokusu}");
    pocetPokusu--; // Zmenšíme o 1
}
Console.WriteLine("Konec!");

Obrana proti zlým uživatelům

Uživatelé zadávají hlouposti. Můžeme cyklus while použít k tomu, abychom je drželi "v pasti", dokud nezadají to, co chceme.

Využijeme zde operátor "nerovná se" != a logické "nebo" ||.

Menu, ze kterého neutečeš

int volba = 0; // Musíme nastavit na něco neplatného

// Dokud je volba jiná než 1 A ZÁROVEŇ jiná než 2
while (volba != 1 && volba != 2)
{
    Console.WriteLine("Zadej 1 (Hraj) nebo 2 (Konec):");
    volba = int.Parse(Console.ReadLine());
}

Console.WriteLine($"Díky, zadal jsi platnou volbu: {volba}");

Nikdy nekončící program

Téměř všechny hry a aplikace běží v nekonečném cyklu, dokud je uživatel sám neukončí (např. volbou v menu).

Můžeme využít cyklus, který běží pořád (while (true)), a ukončit ho ručně příkazem break;.

Základ herní smyčky

while (true) // Běží do nekonečna
{
    Console.WriteLine("Ahoj. Napiš 'konec' pro odchod:");
    string vstup = Console.ReadLine();
    
    if (vstup == "konec")
    {
        Console.WriteLine("Ukončuji aplikaci...");
        break; // Vyskočí z cyklu while!
    }
}