Add a C# course with a side-by-side code runner.

Each lesson explains a topic and runs the edited program next to the text through the local .NET SDK.

Co-authored-by: Cursor <cursoragent@cursor.com>

content/README.md

@@ -18,7 +18,7 @@ Skript vypíše počet lekcí, nebo chyby s cestou a číslem řádku
 
 | Složka | Obsah |
 |---|---|
-| `pocitacove-site/`, `technicke-vybaveni/`, `technicka-grafika/`, `obcanska-nauka/`, `fyzika/` | `N-rocnik/`, v nich lekce |
+| `pocitacove-site/`, `technicke-vybaveni/`, `technicka-grafika/`, `programovani/`, `obcanska-nauka/`, `fyzika/` | `N-rocnik/`, v nich lekce |
 | `prirodni-vedy/chemie`, `prirodni-vedy/biologie` | lekce |
 | `cestina/literatura/N-rocnik` | lekce literatury |
 | `cestina/mluvnice` | cvičení z mluvnice |

content/aplikace/novinky.txt

@@ -5,6 +5,12 @@
 # cs: bullet
 # en: bullet
 
+--- 2026-10-11
+cs: Programování: čtyři ročníky C#, od výpisu po LINQ a async
+cs: Kód se píše v lekci a hned vedle se spustí
+en: Programming: four years of C#, from output to LINQ and async
+en: You write the code in the lesson and run it right beside the text
+
 --- 2026-10-11
 cs: Technická grafika: čtyři ročníky AutoCADu, od výkresu po 3D
 cs: V každé lekci je postup, zadání s rozměry a kvíz

content/aplikace/predmety.md

@@ -13,5 +13,5 @@
 | Základy přírodních věd | Základy přírodních věd | Fundamentals of Natural Sciences | flask | scimap | ano |
 | Technická grafika | Technická grafika | Technical Graphics | ruler | tgyears | ano |
 | Prezentační grafika | Prezentační grafika | Presentation Graphics | lock |  | ne |
-| Programování | Programování | Programming | lock |  | ne |
+| Programování | Programování | Programming | code | csyears | ano |
 | Programové vybavení | Programové vybavení | Software | lock |  | ne |

content/aplikace/texty.md

@@ -243,6 +243,29 @@
 | tg3_sub | Pohledy, řezy, bloky a tisk. | Views, sections, blocks and plotting. |
 | tg4_sub | 3D model a výkres k maturitě. | A 3D model and the exam drawing. |
 
+# Programování
+
+| Klíč | Česky | Anglicky |
+|---|---|---|
+| cs_years_sub | C# od prvního výpisu po pokročilejší nástroje. Kód se píše a spouští vedle výkladu. | C# from the first line of output to the later tools. You write the code and run it beside the lesson. |
+| cs_year1 | 1. ročník | Year 1 |
+| cs_year2 | 2. ročník | Year 2 |
+| cs_year3 | 3. ročník | Year 3 |
+| cs_year4 | 4. ročník | Year 4 |
+| cs_sub | Výpis, proměnné, typy, operátory a řetězce. | Output, variables, types, operators and strings. |
+| cs2_sub | Podmínky, cykly, pole a metody. | Conditions, loops, arrays and methods. |
+| cs3_sub | Třídy, dědičnost, rozhraní a výčty. | Classes, inheritance, interfaces and enums. |
+| cs4_sub | Výjimky, kolekce, LINQ, soubory a async. | Exceptions, collections, LINQ, files and async. |
+| cs_code | Kód | Code |
+| cs_output | Výstup | Output |
+| cs_stdin | Vstup pro Console.ReadLine | Input for Console.ReadLine |
+| cs_run | Spustit | Run |
+| cs_reset | Obnovit ukázku | Reset example |
+| cs_running | Překládám… | Compiling… |
+| cs_empty | Zatím nic. Upravte kód a spusťte ho. | Nothing yet. Edit the code and run it. |
+| cs_timeout | Program běžel příliš dlouho a byl zastaven. | The program ran too long and was stopped. |
+| cs_unavailable | Tady C# nespustíte. Na počítači s nainstalovaným .NET se výstup objeví vedle kódu. | C# cannot run here. On a computer with .NET installed the output appears beside the code. |
+
 # Angličtina a němčina
 
 | Klíč | Česky | Anglicky |

content/programovani/1-rocnik/01-ahoj-svete.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Hello, world
+popis: The first program: writing to the console.
+---

content/programovani/1-rocnik/01-ahoj-svete.md

@@ -0,0 +1,42 @@
+---
+id: cs-1-ahoj-svete
+nazev: Ahoj světe
+popis: První program: výpis na konzoli.
+---
+
+# Výklad
+
+## Výpis
+*WriteLine*
+
+- Console.WriteLine vypíše text a odřádkuje.
+- Console.Write vypíše text a zůstane na stejném řádku.
+- Text se píše do uvozovek. Středník ukončuje příkaz.
+
+> Tip: Bez středníku se program nepřeloží.
+
+## Krátký a dlouhý zápis
+*Main*
+
+- Starší učebnice mají třídu Program a metodu Main.
+- Nový projekt stejný program zapíše několika řádky bez třídy.
+- Obojí spustí stejný výpis. V lekcích používáme krátký zápis.
+
+> Tip: Krátký zápis je pořád C#. Není to jiný jazyk.
+
+## Vyzkoušejte
+*Editor*
+
+- Vpravo je kód. Upravte ho a stiskněte Spustit.
+- Výstup se objeví hned vedle.
+- Obnovit ukázku vrátí původní program.
+
+> Tip: Změňte text v uvozovkách a spusťte znovu.
+
+# Kód
+
+```
+Console.WriteLine("Ahoj světe");
+Console.Write("Toto je ");
+Console.WriteLine("C#");
+```

content/programovani/1-rocnik/02-komentare.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Comments
+popis: Notes the program does not run.
+---

content/programovani/1-rocnik/02-komentare.md

@@ -0,0 +1,35 @@
+---
+id: cs-1-komentare
+nazev: Komentáře
+popis: Poznámky, které se nespouštějí.
+---
+
+# Výklad
+
+## Jednořádkový
+*//*
+
+- Vše za // na stejném řádku počítač přeskočí.
+- Komentář vysvětluje, proč tam řádek je, ne co je vidět.
+- Kód bez komentáře pořád běží stejně.
+
+> Tip: Komentář není výpis. Na konzoli se neobjeví.
+
+## Více řádků
+*/* */*
+
+- Blok začíná /* a končí */.
+- Hodí se, když chcete dočasně vypnout několik řádků.
+- Zapomenuté */ rozbije zbytek souboru.
+
+> Tip: Nevnořujte blokové komentáře do sebe.
+
+# Kód
+
+```
+// Tohle se nespustí.
+Console.WriteLine("Tento řádek ano");
+/*
+Console.WriteLine("A tento ne");
+*/
+```

content/programovani/1-rocnik/03-promenne.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Variables
+popis: A named value you can change.
+---

content/programovani/1-rocnik/03-promenne.md

@@ -0,0 +1,36 @@
+---
+id: cs-1-promenne
+nazev: Proměnné
+popis: Pojmenovaná hodnota, kterou lze změnit.
+---
+
+# Výklad
+
+## Deklarace
+*typ jméno*
+
+- Nejdřív typ, pak jméno, pak hodnota: int vek = 17;
+- Jméno začíná písmenem. Mezery v něm být nesmí.
+- Do stejné proměnné lze později uložit novou hodnotu stejného typu.
+
+> Tip: int drží celé číslo. string drží text.
+
+## Čtení
+*jméno*
+
+- Jméno bez uvozovek je proměnná. Uvozovky by z něj udělaly text.
+- WriteLine umí vypsat proměnnou i text spojený plusem.
+- Hodnota se dosadí až při běhu, ne při psaní.
+
+> Tip: Změňte vek na 18 a spusťte znovu.
+
+# Kód
+
+```
+string jmeno = "Anna";
+int vek = 17;
+jmeno = "Eva";
+Console.WriteLine(jmeno);
+Console.WriteLine(vek);
+Console.WriteLine(jmeno + " má " + vek + " let");
+```

content/programovani/1-rocnik/04-typy.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Data types
+popis: int, double, bool, char and string.
+---

content/programovani/1-rocnik/04-typy.md

@@ -0,0 +1,40 @@
+---
+id: cs-1-typy
+nazev: Datové typy
+popis: int, double, bool, char a string.
+---
+
+# Výklad
+
+## Čísla
+*int a double*
+
+- int je celé číslo: 42.
+- double je číslo s desetinnou tečkou: 3.14.
+- V kódu je desetinná tečka, ne čárka.
+
+> Tip: 3,14 by C# přečetl jako dva údaje oddělené čárkou.
+
+## Text a ano/ne
+*string, char, bool*
+
+- string je text v uvozovkách.
+- char je jeden znak v apostrofech: 'A'.
+- bool je jen true nebo false.
+
+> Tip: Apostrof a uvozovky nejsou totéž. 'A' je znak, "A" je text.
+
+# Kód
+
+```
+int cele = 42;
+double desetinne = 3.14;
+bool prsi = false;
+char pismeno = 'A';
+string text = "ahoj";
+Console.WriteLine(cele);
+Console.WriteLine(desetinne);
+Console.WriteLine(prsi);
+Console.WriteLine(pismeno);
+Console.WriteLine(text);
+```

content/programovani/1-rocnik/05-prevody.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Type conversion
+popis: From double to int and from text to a number.
+---

content/programovani/1-rocnik/05-prevody.md

@@ -0,0 +1,36 @@
+---
+id: cs-1-prevody
+nazev: Převody typů
+popis: Z double na int a z textu na číslo.
+---
+
+# Výklad
+
+## Ořez desetin
+*(int)*
+
+- (int)3.9 je 3. Desetinná část se odřízne, nezaokrouhlí.
+- Opačně int do double ztrátu nemá: 3 se stane 3.0.
+- Převod napište před hodnotu do závorky.
+
+> Tip: Když potřebujete zaokrouhlit, (int) na to není.
+
+## Text na číslo
+*Parse*
+
+- int.Parse("20") udělá z textu číslo 20.
+- Když text číslo není, program spadne. To později chytíme výjimkou.
+- Číslo na text udělá ToString nebo zápis do řetězce.
+
+> Tip: Vstup z konzole je vždy text, i když uživatel napíše číslici.
+
+# Kód
+
+```
+double cena = 19.9;
+int cele = (int)cena;
+Console.WriteLine(cele);
+string vstup = "20";
+int cislo = int.Parse(vstup);
+Console.WriteLine(cislo + 1);
+```

content/programovani/1-rocnik/06-operatory.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Operators
+popis: Arithmetic, remainder, comparison and logic.
+---

content/programovani/1-rocnik/06-operatory.md

@@ -0,0 +1,37 @@
+---
+id: cs-1-operatory
+nazev: Operátory
+popis: Počítání, zbytek, porovnání a a zároveň.
+---
+
+# Výklad
+
+## Počet
+*+ - * / %*
+
+- Sčítání, odčítání a násobení fungují, jak čekáte.
+- Dělení dvou int je celočíselné: 17 / 5 je 3.
+- % je zbytek po dělení: 17 % 5 je 2.
+
+> Tip: Když chcete desetinný podíl, jedno číslo udělejte double: 17 / 5.0.
+
+## Porovnání
+*true a false*
+
+- == je rovnost. = je uložení. Nejsou totéž.
+- && znamená a zároveň. || znamená nebo.
+- ! otočí bool: !true je false.
+
+> Tip: Jedno = v podmínce je častá chyba. Podmínka chce ==.
+
+# Kód
+
+```
+int a = 17;
+int b = 5;
+Console.WriteLine(a + b);
+Console.WriteLine(a / b);
+Console.WriteLine(a % b);
+Console.WriteLine(a > b);
+Console.WriteLine(a > 10 && b < 10);
+```

content/programovani/1-rocnik/07-retezce.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Strings
+popis: Joining text, length and a slice.
+---

content/programovani/1-rocnik/07-retezce.md

@@ -0,0 +1,36 @@
+---
+id: cs-1-retezce
+nazev: Řetězce
+popis: Skládání textu, délka a výřez.
+---
+
+# Výklad
+
+## Interpolace
+*$*
+
+- $"Ahoj, {jmeno}" dosadí hodnotu do složených závorek.
+- Je přehlednější než spojování plusem.
+- Do závorek může i výpočet: {vek + 1}.
+
+> Tip: Bez dolaru před uvozovkami se {jmeno} vypíše doslova.
+
+## Metody textu
+*Length*
+
+- Length je počet znaků.
+- ToUpper vrátí velká písmena a původní text nezmění.
+- Substring(0, 2) vezme dva znaky od začátku.
+
+> Tip: První znak má index 0, ne 1.
+
+# Kód
+
+```
+string jmeno = "Anna";
+int vek = 17;
+Console.WriteLine($"Ahoj, {jmeno}. Za rok ti bude {vek + 1}.");
+Console.WriteLine(jmeno.Length);
+Console.WriteLine(jmeno.ToUpper());
+Console.WriteLine(jmeno.Substring(0, 2));
+```

content/programovani/1-rocnik/08-vstup.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Console input
+popis: Console.ReadLine reads a line.
+---

content/programovani/1-rocnik/08-vstup.md

@@ -0,0 +1,34 @@
+---
+id: cs-1-vstup
+nazev: Vstup z konzole
+popis: Console.ReadLine přečte řádek.
+---
+
+# Výklad
+
+## ReadLine
+*text*
+
+- ReadLine počká na řádek a vrátí ho jako string.
+- V této lekci řádek napište do pole Vstup a pak Spustit.
+- Každé další ReadLine vezme další řádek vstupu.
+
+> Tip: Když vstup necháte prázdný, ReadLine dostane konec a program může spadnout.
+
+## Číslo ze vstupu
+*Parse*
+
+- ReadLine nikdy nevrací int. Vrací text.
+- int.Parse z něj číslo udělá.
+- Napište do vstupu třeba 17.
+
+> Tip: Zkuste ve vstupu Anna a uvidíte chybu. Parse čeká číslo.
+
+# Kód
+
+```
+Console.WriteLine("Kolik ti je?");
+string radek = Console.ReadLine();
+int vek = int.Parse(radek);
+Console.WriteLine($"Za rok ti bude {vek + 1}.");
+```

content/programovani/2-rocnik/01-if.en.md

@@ -0,0 +1,4 @@
+---
+nazev: If and else
+popis: A branch that runs only sometimes.
+---

content/programovani/2-rocnik/01-if.md

@@ -0,0 +1,43 @@
+---
+id: cs-2-if
+nazev: If a else
+popis: Větev, která se spustí jen někdy.
+---
+
+# Výklad
+
+## Podmínka
+*if*
+
+- if (vek >= 18) spustí blok ve složených závorkách, jen když je podmínka true.
+- else je větev pro opačný případ.
+- else if přidá další podmínku mezi ně.
+
+> Tip: Za if není středník. Středník by podmínku oddělil od bloku.
+
+## Porovnání
+*==*
+
+- Čísla porovnávejte >, <, >=, <=, == a !=.
+- Text se porovnává ==. "Anna" == "anna" je false.
+- Do podmínky patří bool, ne přiřazení.
+
+> Tip: Změňte vek a sledujte, která věta se vypíše.
+
+# Kód
+
+```
+int vek = 17;
+if (vek >= 18)
+{
+    Console.WriteLine("plnoletý");
+}
+else if (vek >= 15)
+{
+    Console.WriteLine("téměř");
+}
+else
+{
+    Console.WriteLine("ještě ne");
+}
+```

content/programovani/2-rocnik/02-switch.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Switch
+popis: Several branches for one value.
+---

content/programovani/2-rocnik/02-switch.md

@@ -0,0 +1,43 @@
+---
+id: cs-2-switch
+nazev: Switch
+popis: Víc větví podle jedné hodnoty.
+---
+
+# Výklad
+
+## Větve
+*case*
+
+- switch vybere case, který se rovná hodnotě.
+- break ukončí větev. Bez něj se překlad v klasickém zápisu zastaví.
+- default je větev, když nesedí žádný case.
+
+> Tip: Na známku 1 až 5 se switch hodí víc než řada else if.
+
+## Nový zápis
+*šipka*
+
+- case 1 => "výborně" je krátká větev bez break.
+- Výraz switch umí hodnotu rovnou vrátit.
+- V lekci je klasický zápis, ať je vidět break.
+
+> Tip: Přidejte case 5 a spusťte se znamkou 5.
+
+# Kód
+
+```
+int znamka = 2;
+switch (znamka)
+{
+    case 1:
+        Console.WriteLine("výborně");
+        break;
+    case 2:
+        Console.WriteLine("chvalitebně");
+        break;
+    default:
+        Console.WriteLine("jiná známka");
+        break;
+}
+```

content/programovani/2-rocnik/03-while.en.md

@@ -0,0 +1,4 @@
+---
+nazev: While
+popis: Repeat while a condition holds.
+---

content/programovani/2-rocnik/03-while.md

@@ -0,0 +1,38 @@
+---
+id: cs-2-while
+nazev: While
+popis: Opakování, dokud podmínka platí.
+---
+
+# Výklad
+
+## Smyčka
+*while*
+
+- Tělo se opakuje, dokud je podmínka true.
+- Když podmínku nikdy nezměníte, smyčka neskončí.
+- Aplikace dlouhý běh po chvíli zastaví.
+
+> Tip: i = i + 1 nebo i++ posune čítač. Bez toho se i nemění.
+
+## Součet
+*1 až 4*
+
+- Začněte součtem 0 a přičítejte i.
+- 1+2+3+4 je 10.
+- Podmínka i <= 4 pustí i číslo 4 dovnitř.
+
+> Tip: Změňte 4 na 10. Součet 1 až 10 je 55.
+
+# Kód
+
+```
+int i = 1;
+int soucet = 0;
+while (i <= 4)
+{
+    soucet = soucet + i;
+    i++;
+}
+Console.WriteLine(soucet);
+```

content/programovani/2-rocnik/04-for.en.md

@@ -0,0 +1,4 @@
+---
+nazev: For
+popis: A loop with its counter in one place.
+---

content/programovani/2-rocnik/04-for.md

@@ -0,0 +1,34 @@
+---
+id: cs-2-for
+nazev: For
+popis: Smyčka s čítačem na jednom místě.
+---
+
+# Výklad
+
+## Tři části
+*start; podmínka; krok*
+
+- for (int i = 0; i < 3; i++) má začátek, podmínku a krok.
+- i < 3 pustí 0, 1 a 2. Trojku už ne.
+- Krok i++ se provede až po těle.
+
+> Tip: Když potřebujete přesný počet opakování, for je přehlednější než while.
+
+## Násobilka
+*výpis*
+
+- V těle můžete počítat i * 2.
+- WriteLine v těle vypíše jeden řádek na každé opakování.
+- Čítač nemusí začínat nulou.
+
+> Tip: Přepište podmínku na i <= 5 a sledujte další řádek.
+
+# Kód
+
+```
+for (int i = 1; i <= 3; i++)
+{
+    Console.WriteLine($"{i} krát 2 je {i * 2}");
+}
+```

content/programovani/2-rocnik/05-pole.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Arrays
+popis: Several values of one type under one name.
+---

content/programovani/2-rocnik/05-pole.md

@@ -0,0 +1,35 @@
+---
+id: cs-2-pole
+nazev: Pole
+popis: Víc hodnot stejného typu pod jedním jménem.
+---
+
+# Výklad
+
+## Index
+*od nuly*
+
+- new int[] { 2, 4, 6 } je pole tří čísel.
+- První prvek je znamky[0], poslední znamky[2].
+- Length je počet prvků, ne index posledního.
+
+> Tip: znamky[3] u pole délky 3 spadne. Poslední index je 2.
+
+## Zápis
+*prvku*
+
+- Do prvku se dá uložit nová hodnota: znamky[1] = 5.
+- Ostatní prvky zůstanou.
+- Pole má pevnou délku. Přidat čtvrtý prvek nejde, na to je později List.
+
+> Tip: Vyměňte první známku a spusťte znovu.
+
+# Kód
+
+```
+int[] znamky = { 1, 3, 2 };
+Console.WriteLine(znamky[0]);
+Console.WriteLine(znamky.Length);
+znamky[1] = 5;
+Console.WriteLine(znamky[1]);
+```

content/programovani/2-rocnik/06-foreach.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Foreach
+popis: Visit every item without an index.
+---

content/programovani/2-rocnik/06-foreach.md

@@ -0,0 +1,35 @@
+---
+id: cs-2-foreach
+nazev: Foreach
+popis: Projít každý prvek bez indexu.
+---
+
+# Výklad
+
+## Projítí
+*foreach*
+
+- foreach (int z in znamky) vezme prvky od prvního po poslední.
+- z je kopie hodnoty. U int se zápisem do z pole nezmění.
+- Když index nepotřebujete, foreach je kratší než for.
+
+> Tip: Součet ve smyčce přičítá aktuální z.
+
+## Texty
+*string[]*
+
+- Pole může být i ze stringů.
+- Stejný foreach funguje pro oba typy, jen se liší typ prvku.
+- Pořadí je pořadí v závorce při vytvoření.
+
+> Tip: Přidejte do pole třetí jméno.
+
+# Kód
+
+```
+string[] jmena = { "Anna", "Eva", "Jan" };
+foreach (string jmeno in jmena)
+{
+    Console.WriteLine(jmeno);
+}
+```

content/programovani/2-rocnik/07-metody.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Methods
+popis: A named piece of the program you can call.
+---

content/programovani/2-rocnik/07-metody.md

@@ -0,0 +1,37 @@
+---
+id: cs-2-metody
+nazev: Metody
+popis: Pojmenovaný kus programu, který lze zavolat.
+---
+
+# Výklad
+
+## Volání
+*jméno()*
+
+- static void Pozdrav() je metoda bez výsledku.
+- Zavolá se Pozdrav(); včetně závorek.
+- Bez závorek by to bylo jen jméno, ne volání.
+
+> Tip: Metodu lze zavolat víckrát a pokaždé udělá totéž.
+
+## Proč
+*jednou*
+
+- Kód, který se opakuje, patří do metody.
+- Jméno metody říká, co dělá: Pozdrav, ne Metoda1.
+- void znamená, že nevrací hodnotu.
+
+> Tip: Přidejte druhé volání Pozdrav().
+
+# Kód
+
+```
+Pozdrav();
+Pozdrav();
+
+static void Pozdrav()
+{
+    Console.WriteLine("Ahoj");
+}
+```

content/programovani/2-rocnik/08-navrat.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Parameters and return
+popis: A method receives values and can return one.
+---

content/programovani/2-rocnik/08-navrat.md

@@ -0,0 +1,38 @@
+---
+id: cs-2-navrat
+nazev: Parametry a návrat
+popis: Metoda dostane hodnoty a může jednu vrátit.
+---
+
+# Výklad
+
+## Parametr
+*vstup*
+
+- int a v závorce je parametr. Volající dodá argument.
+- Součet(2, 5) uloží 2 do a a 5 do b.
+- Jména parametrů platí jen uvnitř metody.
+
+> Tip: Změňte argumenty a výsledek se změní, metoda ne.
+
+## return
+*výstup*
+
+- int před jménem je typ výsledku.
+- return hodnotu vrátí a metodu ukončí.
+- Volající si výsledek může uložit: int s = Soucet(2, 5);
+
+> Tip: return 0 omylem na začátku by zbytek metody nespustil.
+
+# Kód
+
+```
+int s = Soucet(2, 5);
+Console.WriteLine(s);
+Console.WriteLine(Soucet(10, 1));
+
+static int Soucet(int a, int b)
+{
+    return a + b;
+}
+```

content/programovani/3-rocnik/01-trida.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Class and object
+popis: Your own type and one concrete piece of it.
+---

content/programovani/3-rocnik/01-trida.md

@@ -0,0 +1,40 @@
+---
+id: cs-3-trida
+nazev: Třída a objekt
+popis: Vlastní typ a jeho konkrétní kus.
+---
+
+# Výklad
+
+## Třída
+*návod*
+
+- class Zak popisuje, co žák má: jméno a věk.
+- new Zak() vytvoří objekt, jeden konkrétní kus.
+- Dva new jsou dva objekty. Změna jednoho druhý nemění.
+
+> Tip: Třída sama o sobě není žák. Je to popis.
+
+## Pole objektu
+*tečka*
+
+- z.Jmeno se čte a zapisuje přes tečku.
+- Na začátek dáme veřejná pole, ať je vidět, komu patří.
+- Později je schováme za vlastnost.
+
+> Tip: Vytvořte druhého žáka a vypište obě jména.
+
+# Kód
+
+```
+Zak z = new Zak();
+z.Jmeno = "Anna";
+z.Vek = 17;
+Console.WriteLine($"{z.Jmeno}, {z.Vek}");
+
+class Zak
+{
+    public string Jmeno;
+    public int Vek;
+}
+```

content/programovani/3-rocnik/02-konstruktor.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Constructor
+popis: A method that fills the object immediately.
+---

content/programovani/3-rocnik/02-konstruktor.md

@@ -0,0 +1,44 @@
+---
+id: cs-3-konstruktor
+nazev: Konstruktor
+popis: Metoda, která objekt hned naplní.
+---
+
+# Výklad
+
+## Jméno třídy
+*new Zak*
+
+- Konstruktor se jmenuje jako třída a nemá návratový typ.
+- new Zak("Anna", 17) ho zavolá.
+- Prázdný new Zak() přestane fungovat, jakmile napíšete vlastní konstruktor.
+
+> Tip: Hodnoty patří do new, ne až na další řádky.
+
+## this
+*tento objekt*
+
+- this.Jmeno je pole objektu. Jmeno bez this by v konstruktoru byl parametr.
+- Když se jmenují stejně, this je nutný.
+- Mimo konstruktor this často není potřeba.
+
+> Tip: Přidejte do výpisu věk z konstruktoru.
+
+# Kód
+
+```
+Zak z = new Zak("Anna", 17);
+Console.WriteLine($"{z.Jmeno}, {z.Vek}");
+
+class Zak
+{
+    public string Jmeno;
+    public int Vek;
+
+    public Zak(string jmeno, int vek)
+    {
+        Jmeno = jmeno;
+        Vek = vek;
+    }
+}
+```

content/programovani/3-rocnik/03-vlastnosti.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Properties
+popis: get and set instead of a bare field.
+---

content/programovani/3-rocnik/03-vlastnosti.md

@@ -0,0 +1,50 @@
+---
+id: cs-3-vlastnosti
+nazev: Vlastnosti
+popis: get a set místo holého pole.
+---
+
+# Výklad
+
+## get a set
+*tečka zůstává*
+
+- public string Jmeno { get; set; } se zvenku používá jako pole.
+- Uvnitř může set odmítnout špatnou hodnotu.
+- get hodnotu vrátí, set ji uloží.
+
+> Tip: Zápis z.Vek = -1 může set zarazit, holé pole ne.
+
+## Kontrola
+*set*
+
+- V příkladu set u věku záporné číslo neuloží.
+- get pořád vrátí poslední platnou hodnotu.
+- Tak se objekt nepokazí zvenku.
+
+> Tip: Zkuste z.Vek = -3 a vypište věk. Zůstane 17.
+
+# Kód
+
+```
+Zak z = new Zak("Anna", 17);
+z.Vek = -3;
+Console.WriteLine(z.Vek);
+
+class Zak
+{
+    public string Jmeno { get; set; }
+    private int vek;
+    public int Vek
+    {
+        get { return vek; }
+        set { if (value >= 0) vek = value; }
+    }
+
+    public Zak(string jmeno, int vek)
+    {
+        Jmeno = jmeno;
+        Vek = vek;
+    }
+}
+```

content/programovani/3-rocnik/04-zapouzdreni.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Encapsulation
+popis: Private data and public methods.
+---

content/programovani/3-rocnik/04-zapouzdreni.md

@@ -0,0 +1,49 @@
+---
+id: cs-3-zapouzdreni
+nazev: Zapouzdření
+popis: Soukromá data a veřejné metody.
+---
+
+# Výklad
+
+## private
+*schované*
+
+- private pole vidí jen kód té třídy.
+- public metoda je dveře, kterými se s objektem mluví.
+- Zvenku z.penize nenapíšete. Zavoláte Pridej.
+
+> Tip: Když je vše public, kdokoli rozbije pravidla objektu.
+
+## Metoda
+*Pridej*
+
+- Pridej přičte a vrátí nový stav.
+- Záporný vklad lze v metodě odmítnout.
+- Výpis stavu jde přes Kolik, ne přes pole.
+
+> Tip: Zkuste Pridej(-10). Stav se nemá zmenšit.
+
+# Kód
+
+```
+Pokladna p = new Pokladna();
+p.Pridej(50);
+p.Pridej(-10);
+Console.WriteLine(p.Kolik());
+
+class Pokladna
+{
+    private int penize;
+
+    public void Pridej(int castka)
+    {
+        if (castka > 0) penize = penize + castka;
+    }
+
+    public int Kolik()
+    {
+        return penize;
+    }
+}
+```

content/programovani/3-rocnik/05-dedicnost.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Inheritance
+popis: A new class takes over a finished one.
+---

content/programovani/3-rocnik/05-dedicnost.md

@@ -0,0 +1,52 @@
+---
+id: cs-3-dedicnost
+nazev: Dědičnost
+popis: Nová třída převezme hotovou.
+---
+
+# Výklad
+
+## base
+*: Zak*
+
+- class Student : Zak znamená, že student je žák a má něco navíc.
+- Dostane Jmeno a Vek, aniž by se psaly znovu.
+- base(...) zavolá konstruktor předka.
+
+> Tip: Student umí to, co Zak, a ještě obor.
+
+## Je
+*typ*
+
+- Student lze uložit do proměnné Zak. Pořád je to student.
+- Opačně žák bez oboru studentem není.
+- Na specialitu sáhnete, až když máte původní typ.
+
+> Tip: Vypište i obor. Patří studentovi, ne obecnému žákovi.
+
+# Kód
+
+```
+Student s = new Student("Eva", 18, "informatika");
+Console.WriteLine($"{s.Jmeno}, {s.Obor}");
+
+class Zak
+{
+    public string Jmeno { get; set; }
+    public int Vek { get; set; }
+    public Zak(string jmeno, int vek)
+    {
+        Jmeno = jmeno;
+        Vek = vek;
+    }
+}
+
+class Student : Zak
+{
+    public string Obor { get; set; }
+    public Student(string jmeno, int vek, string obor) : base(jmeno, vek)
+    {
+        Obor = obor;
+    }
+}
+```

content/programovani/3-rocnik/06-polymorfismus.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Polymorphism
+popis: The same call, a different answer from the child.
+---

content/programovani/3-rocnik/06-polymorfismus.md

@@ -0,0 +1,50 @@
+---
+id: cs-3-polymorfismus
+nazev: Polymorfismus
+popis: Stejné volání, jiná odpověď potomka.
+---
+
+# Výklad
+
+## virtual a override
+*přepsání*
+
+- virtual u předka dovolí potomkovi metodu vyměnit.
+- override u potomka řekne, že jde o tu samou metodu.
+- Bez virtual by potomek jen schoval jméno a přes typ předka by se volala stará verze.
+
+> Tip: Proměnná je Zvire, objekt je Pes. Zavolá se štěk, ne obecné zvíře.
+
+## Seznam
+*víc tvarů*
+
+- Do pole Zvire lze dát psa i kočku.
+- foreach volá Zvuk a každý objekt odpoví po svém.
+- Nové zvíře přidáte třídou, ne úpravou smyčky.
+
+> Tip: Přidejte do pole kočku a třetí řádek výstupu bude mňau.
+
+# Kód
+
+```
+Zvire[] zvirata = { new Pes(), new Kocka() };
+foreach (Zvire z in zvirata)
+{
+    Console.WriteLine(z.Zvuk());
+}
+
+class Zvire
+{
+    public virtual string Zvuk() { return "..."; }
+}
+
+class Pes : Zvire
+{
+    public override string Zvuk() { return "haf"; }
+}
+
+class Kocka : Zvire
+{
+    public override string Zvuk() { return "mňau"; }
+}
+```

content/programovani/3-rocnik/07-rozhrani.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Interface
+popis: A contract: which methods a type must have.
+---

content/programovani/3-rocnik/07-rozhrani.md

@@ -0,0 +1,50 @@
+---
+id: cs-3-rozhrani
+nazev: Rozhraní
+popis: Smlouva: které metody typ musí mít.
+---
+
+# Výklad
+
+## interface
+*I*
+
+- interface nemá hotový kód, jen hlavičky metod.
+- class Pes : IMluvici slíbí, že Mluv napíše.
+- Jedna třída může splnit víc rozhraní. Dědit může jen jednu třídu.
+
+> Tip: Jméno rozhraní se často píše s I na začátku: IMluvici.
+
+## Společný typ
+*seznam*
+
+- Proměnná typu rozhraní udrží kohokoli, kdo smlouvu splnil.
+- Pes a Radio nemají společného předka, ale oba umí Mluv.
+- Smyčka jim rozumí přes smlouvu, ne přes původ.
+
+> Tip: Rozhraní neříká, jak metoda funguje. To napíše až třída.
+
+# Kód
+
+```
+IMluvici[] veci = { new Pes(), new Radio() };
+foreach (IMluvici v in veci)
+{
+    Console.WriteLine(v.Mluv());
+}
+
+interface IMluvici
+{
+    string Mluv();
+}
+
+class Pes : IMluvici
+{
+    public string Mluv() { return "haf"; }
+}
+
+class Radio : IMluvici
+{
+    public string Mluv() { return "hudba"; }
+}
+```

content/programovani/3-rocnik/08-enum.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Enum
+popis: A fixed list of named values.
+---

content/programovani/3-rocnik/08-enum.md

@@ -0,0 +1,50 @@
+---
+id: cs-3-enum
+nazev: Výčet
+popis: Pevný seznam pojmenovaných hodnot.
+---
+
+# Výklad
+
+## enum
+*Den*
+
+- enum Den { Po, Ut, St } jsou tři pojmenované hodnoty.
+- Místo magického čísla 1 píšete Den.Po.
+- Překladač nepustí hodnotu, která ve výčtu není.
+
+> Tip: Čísla 0, 1, 2 by za měsíc nikdo nepřečetl. Jména ano.
+
+## switch
+*přes výčet*
+
+- switch na enum má case pro každou hodnotu.
+- Když přidáte čtvrtek a zapomenete case, překlad na to v novém zápisu upozorní.
+- Výčet je typ. Není to string.
+
+> Tip: Změňte dnes na Den.St.
+
+# Kód
+
+```
+Den dnes = Den.Po;
+switch (dnes)
+{
+    case Den.Po:
+        Console.WriteLine("pondělí");
+        break;
+    case Den.Ut:
+        Console.WriteLine("úterý");
+        break;
+    default:
+        Console.WriteLine("jiný den");
+        break;
+}
+
+enum Den
+{
+    Po,
+    Ut,
+    St
+}
+```

content/programovani/4-rocnik/01-vyjimky.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Exceptions
+popis: An error you can catch and explain.
+---

content/programovani/4-rocnik/01-vyjimky.md

@@ -0,0 +1,43 @@
+---
+id: cs-4-vyjimky
+nazev: Výjimky
+popis: Chyba, kterou lze chytit a vysvětlit.
+---
+
+# Výklad
+
+## try
+*pokus*
+
+- try je kus, který může spadnout.
+- catch (Exception e) ho chytí, místo aby spadl celý program.
+- e.Message je text chyby.
+
+> Tip: Bez try by Parse na textu abc program ukončil.
+
+## finally
+*vždy*
+
+- finally se spustí, ať try prošel, nebo ne.
+- Hodí se na úklid. V příkladu jen vypíše, že končíme.
+- catch může být víc, pro různé typy chyb.
+
+> Tip: Změňte abc na 5. catch se přeskočí, finally ne.
+
+# Kód
+
+```
+try
+{
+    int n = int.Parse("abc");
+    Console.WriteLine(n);
+}
+catch (Exception e)
+{
+    Console.WriteLine("Chyba: " + e.Message);
+}
+finally
+{
+    Console.WriteLine("konec");
+}
+```

content/programovani/4-rocnik/02-list.en.md

@@ -0,0 +1,4 @@
+---
+nazev: List
+popis: A list that can grow.
+---

content/programovani/4-rocnik/02-list.md

@@ -0,0 +1,39 @@
+---
+id: cs-4-list
+nazev: List
+popis: Seznam, který umí růst.
+---
+
+# Výklad
+
+## Přidávání
+*Add*
+
+- List<string> začne prázdný. Add přidá na konec.
+- Count je počet. Indexy jsou zase od nuly.
+- Na rozdíl od pole délku dopředu neříkáte.
+
+> Tip: List<string> potřebuje špičaté závorky s typem prvku.
+
+## Odebrání
+*Remove*
+
+- Remove("Eva") odebere první Evu.
+- RemoveAt(0) odebere podle indexu.
+- foreach pak projde, co zůstalo.
+
+> Tip: Přidejte třetí jméno před odebráním.
+
+# Kód
+
+```
+List<string> jmena = new List<string>();
+jmena.Add("Anna");
+jmena.Add("Eva");
+jmena.Remove("Eva");
+foreach (string j in jmena)
+{
+    Console.WriteLine(j);
+}
+Console.WriteLine(jmena.Count);
+```

content/programovani/4-rocnik/03-slovnik.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Dictionary
+popis: A value under a key.
+---

content/programovani/4-rocnik/03-slovnik.md

@@ -0,0 +1,39 @@
+---
+id: cs-4-slovnik
+nazev: Slovník
+popis: Hodnota pod klíčem.
+---
+
+# Výklad
+
+## Klíč
+*jednou*
+
+- Dictionary<string, int> má klíč text a hodnotu číslo.
+- znamky["Anna"] = 1 uloží nebo přepíše.
+- Stejný klíč je v slovníku jen jednou.
+
+> Tip: Pole je podle čísla. Slovník je podle jména, které si zvolíte.
+
+## Čtení
+*ContainsKey*
+
+- Čtení chybějícího klíče spadne.
+- ContainsKey napřed zjistí, jestli klíč je.
+- foreach projde dvojice Key a Value.
+
+> Tip: Zeptejte se na jméno, které v slovníku není, až po ContainsKey.
+
+# Kód
+
+```
+Dictionary<string, int> znamky = new Dictionary<string, int>();
+znamky["Anna"] = 1;
+znamky["Eva"] = 2;
+znamky["Anna"] = 3;
+if (znamky.ContainsKey("Eva"))
+{
+    Console.WriteLine(znamky["Eva"]);
+}
+Console.WriteLine(znamky["Anna"]);
+```

content/programovani/4-rocnik/04-linq.en.md

@@ -0,0 +1,4 @@
+---
+nazev: LINQ
+popis: Queries over a list.
+---

content/programovani/4-rocnik/04-linq.md

@@ -0,0 +1,36 @@
+---
+id: cs-4-linq
+nazev: LINQ
+popis: Dotazy nad seznamem.
+---
+
+# Výklad
+
+## Where
+*filtr*
+
+- Where nechá jen prvky, které splní podmínku.
+- n => n >= 10 je krátká funkce: vezmi n a vrať, jestli je aspoň 10.
+- Samotné Where ještě nic neprojde. ToList nebo foreach výsledek vezme.
+
+> Tip: Šipka => není porovnání. Je to zápis malé funkce.
+
+## Select
+*převod*
+
+- Select z každého prvku udělá jiný.
+- OrderBy seřadí.
+- Dotaz lze řetězit: Where a pak Select.
+
+> Tip: Změňte 10 na 12 a dvojka z výpisu zmizí.
+
+# Kód
+
+```
+int[] cisla = { 4, 11, 7, 20 };
+var velka = cisla.Where(n => n >= 10).OrderBy(n => n);
+foreach (int n in velka)
+{
+    Console.WriteLine(n);
+}
+```

content/programovani/4-rocnik/05-soubory.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Files
+popis: Writing and reading text.
+---

content/programovani/4-rocnik/05-soubory.md

@@ -0,0 +1,33 @@
+---
+id: cs-4-soubory
+nazev: Soubory
+popis: Zápis a čtení textu.
+---
+
+# Výklad
+
+## WriteAllText
+*jednou*
+
+- File.WriteAllText zapíše celý soubor. Když existuje, přepíše ho.
+- Cesta pozdrav.txt je vedle programu, v jeho složce.
+- ReadAllText celý text vrátí jako string.
+
+> Tip: Na telefonu se soubor nespustí. Na počítači s .NET ano.
+
+## Řádky
+*Append*
+
+- AppendAllText přidá na konec a soubor nesmaže.
+- ReadAllLines vrátí pole řádků.
+- Po skončení programu soubor ve složce laboratoře zůstane.
+
+> Tip: Spusťte dvakrát. Druhý zápis WriteAllText starý text nahradí.
+
+# Kód
+
+```
+File.WriteAllText("pozdrav.txt", "Ahoj ze souboru");
+string zpet = File.ReadAllText("pozdrav.txt");
+Console.WriteLine(zpet);
+```

content/programovani/4-rocnik/06-generika.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Generics
+popis: One method for several types.
+---

content/programovani/4-rocnik/06-generika.md

@@ -0,0 +1,37 @@
+---
+id: cs-4-generika
+nazev: Generika
+popis: Jedna metoda pro víc typů.
+---
+
+# Výklad
+
+## T
+*typový parametr*
+
+- static void Vypis<T>(T hodnota) přijme int i string.
+- T se doplní při volání podle argumentu.
+- Jedna metoda tak nenutí kopírovat kód pro každý typ.
+
+> Tip: Když metoda s T má umět jen porovnávat, T se omezí. Tady stačí výpis.
+
+## List
+*už ho znáte*
+
+- List<string> je generická třída. string je dosazený T.
+- Stejný List<int> drží čísla a metody jsou stejné.
+- Generika hlídá typ. Do List<int> string nedáte.
+
+> Tip: Zavolejte Vypis s číslem i s textem.
+
+# Kód
+
+```
+Vypis(7);
+Vypis("ahoj");
+
+static void Vypis<T>(T hodnota)
+{
+    Console.WriteLine(hodnota);
+}
+```

content/programovani/4-rocnik/07-delegaty.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Delegates
+popis: A variable that holds a method.
+---

content/programovani/4-rocnik/07-delegaty.md

@@ -0,0 +1,34 @@
+---
+id: cs-4-delegaty
+nazev: Delegáty
+popis: Proměnná, do které uložíte metodu.
+---
+
+# Výklad
+
+## Func
+*funkce*
+
+- Func<int, int> je metoda, která dostane int a vrátí int.
+- x => x * x je taková metoda bez jména.
+- Do proměnné ji uložíte a zavoláte později.
+
+> Tip: Závorky pocet(4) metodu spustí. Bez nich byste ji jen předali dál.
+
+## Action
+*bez výsledku*
+
+- Action nic nevrací. Hodí se na kroky.
+- Metodu můžete předat jiné metodě jako argument.
+- Tak se píše i Where z minulé lekce.
+
+> Tip: Vyměňte x * x za x + 1.
+
+# Kód
+
+```
+Func<int, int> pocet = x => x * x;
+Console.WriteLine(pocet(4));
+Action pozdrav = () => Console.WriteLine("ahoj");
+pozdrav();
+```

content/programovani/4-rocnik/08-async.en.md

@@ -0,0 +1,4 @@
+---
+nazev: Async and await
+popis: Work that waits without freezing the way you write it.
+---

content/programovani/4-rocnik/08-async.md

@@ -0,0 +1,33 @@
+---
+id: cs-4-async
+nazev: Async a await
+popis: Práce, která počká, aniž by zamkla zbytek zápisu.
+---
+
+# Výklad
+
+## await
+*počkej*
+
+- await Task.Delay čeká, ale zápis zůstane řádek za řádkem.
+- Metoda s await má v hlavičce async a vrací Task.
+- V krátkém programu smí await stát i na nejvyšší úrovni.
+
+> Tip: Delay(300) čeká 300 milisekund. Výpis hotovo přijde až po něm.
+
+## Task
+*slib*
+
+- Task je slib, že práce doběhne.
+- await slib rozbalí. Bez await byste měli slib, ne výsledek.
+- Na síť a soubory se await hodí. Na 2 + 2 ne.
+
+> Tip: Dejte za první výpis ještě jeden await a druhý řádek.
+
+# Kód
+
+```
+Console.WriteLine("začátek");
+await Task.Delay(300);
+Console.WriteLine("hotovo");
+```