Představení jazyka C#

1. Představení jazyka C#

C# (vyslovuj [siː šaːp] je velmi flexibilní a mocný moderní vysokoúrovňový objektově orientovaný programovací jazyk vyvinutý firmou Microsoft (využívá platformu .NET Framework), který je založen na jazycích C, C++ a Java (z jazyka C čerpá syntaxi). Jazyk C# lze využít k tvorbě formulářových aplikací ve Windows, databázových aplikací, aplikací pro mobilní zařízení, webových stránek atd.

U jazyka C# se zdrojový kód programu nepřeloží do strojového kódu počítače, ale do mezikódu – univerzálního pomocného jazyku označovaného „Common Intermediate Language“ – „CIL“ (má jednodušší instrukční sadu a podporuje objektové programování). Ten se pomocí dalšího interpreteru – u .NET Framework je to „Common Language Runtime“ – „CLR“ - převede do strojového kódu cílového počítače, ale zpravidla až v okamžiku, kdy jsou programem vyžadovány – JIT (zkratka anglického „Just In Time“).

Prostředí .NET Framework podporuje práci s tzv. metadaty, což jsou dodatečné informace ukládané do CIL v době překladu a umožňují získávat z přeloženého programu velmi podrobné informace o třídách, které obsahuje – mechanismus reflexe (anglicky „Reflection“). Pojem třída (anglicky „Class“) berme jako základní konstrukční prvek objektově orientovaného programování, který slouží jako předpis pro vznik objektu (tzv. instance třídy) reprezentujícího např. nějaký prvek reálného světa a tyto třídy jsou ve vzájemné hierarchii. Jazyk C# a prostředí .NET Framework umožňuje spolupracovat i s tzv. neřízeným kódem (anglicky „Unmanaged Code“) který neběží v rámci CLR jedná se např. o starší programy. [1]

Prostředí CLR zajišťuje běh programů přeložených z různých jazyků a díky tomu mohou různé části napsané v různých jazycích vzájemně spolupracovat. Stará se také o automatickou správu paměti (anglicky „Garbage Collector“), např. odstraňování nepotřebných objektů atd. a programátor je od této činnosti oproštěn.

Pro bezproblémový běh vyvinutých aplikací v C# je zapotřebí na cílovém počítači stejné verze .NET, jako je verze, ve které byla aplikace vyvíjena.

Překladač programovacího jazyka C# zároveň kontroluje syntaktickou správnost programu, tedy zda je program napsán podle jistých formálních pravidel, která zaručují, že mu počítač rozumí. Syntaktická správnost programu bohužel nezaručuje věcnou správnost programu, tj. nezaručuje, že program bude dělat to, co si přejeme. [3]

Doplňme ještě největší výhodu C#, kterou je kompletní sada knihoven (předpřipravené kódy), které v sobě mají implementovánu řadu struktur a komponent odladěných zejména pro Windows. Mezi další výhody, kterými jsou: stabilita provádění kódu, správa paměti, shodné datové typy, přenositelnost kódu mezi programovacími jazyky (C#, Visual Basic, C++), pomalejší start ale vyšší rychlost provádění operací než interpretovaný jazyk (menší než kompilovaný jazyk), malá možnost napadení kódu (špatná čitelnost zdrojového kódu v „CIL“) atd.

2. Visual Studio - generované soubory

Pro tvorbu kódu budeme využívat nástroj Visual Studio, což je prostředí (IDE - zkratka anglického „Integrated Development Environment“), ve kterém budeme psát zdrojové kódy pro naše aplikace. Toto prostředí nabízí možnost zálohy a verzování vaší práce pomocí synchronizace s webovým uložištěm např. pomocí služby OneDrive a mnohem více.

Za účelem zjednodušení výkladu, budeme vytvářet programy ve formě konzolových aplikací (anglicky „Console Application“. Počítačová konsole má jednoduché okno, které nám bude sloužit pro zadání vstupů, nebo výpisů dat v našem programu. Pokud se chcete podívat, jak vypadá konzole, spusťte si příkazový řádek ve Windows (takové to černé okno) Nevyužívá žádné pokročilé grafické rozhraní, což zatím není zapotřebí. V začátcích kurzu je důležité vysvětlit základní podstatu a smysl prvků používaných při programování.

Před tím, než v tomto prostředí začneme vytvářet nějaké konzolové aplikace, měli bychom vědět, jaké soubory vygeneruje Visual Studio:

3. Základní struktura kódu

Pojďme se nyní podívat, jaký zdrojový kód nám pro typ konzolové aplikace vygenerovalo Visual Studio, pokud jsme název projektu definovali jako "AhojSvete" – viz Kód 1.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

Kód 1: Základní struktura kódu pro typ konzolové aplikace v C#

Pojďme si nyní tento základní vygenerovaný zdrojový kód doplnit pár řádky nového kódu, který bude imitovat podstatu našeho algoritmu HelloWorldPromenna, jehož podstatu jsme řešili již dříve v aplikaci Flowgorithm:

Algoritmus HelloWorldPromenna 

• Popis: Vývojový diagram výpisu proměnné s názvem osloveni v níž je uložen text "Hello, World!" 
• Zadání: Zkuste vymyslet, jak byste zaznamenali výpis hodnoty uložené v proměnné pomocí vývojového diagramu, včetně komentářů, které popisují, co jednotlivé značky zajišťují
• Řešení: https://phix.zcu.cz/moodle/pluginfile.php/389317/mod_book/chapter/98991/Algoritmus_HelloWorld_Promenna.png
  

Jedná se o modifikaci programu HelloWorld, v níž jsme deklarovali lokální proměnnou osloveni a uložili jsme do ní text "Hello, World!". Výsledný zdrojový kód programu HelloWorldPromenna vypadá následovně - viz Kód 2.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace HelloWorldPromenna
{
    class Program
    {
        static void Main(string[] args)
        {
            //Deklarace proměnné
            string osloveni;
            //Přiřazení textu proměnné
            osloveni = "Hello, World!";
            //Výpis hodnoty proměnné
            Console.WriteLine(osloveni); 
        }
    }
}

Kód 2: Základní struktura kódu  - program HelloWorldPromenna - konzolová aplikace

Tento příklad je prvotním základem skoro všech učebnicí programovacích jazyků. V návaznosti na vývojový diagram by C# kód vypadal následovně - viz Obrázek 1.

Obrázek 1: Popis základní struktury kódu  - program HelloWorldPromenna - konzolová aplikace

V dalších kapitolách bude stručně popsán tento zdrojový kód včetně specifikace a vysvětlení základních pojmů, které jsme nalezli v předchozím obrázku.

Co je velmi důležité zmínit, než se dostaneme k programování, je fakt, že jazyk C# rozlišuje malá a velká písmena (anglicky „Case-sensitive“). Dávejte proto velký pozor na kód, které budete psát pro Vaši aplikaci. 

4. Klíčová slova

Klíčové slovo (anglicky „Keyword“) je předdefinované rezervované slovo, který má zvláštní význam pro kompilátor. Toto slovo užívané v programovacím jazyku nesmí být použito jako identifikátor (anglicky „Identifier“). Identifikátor je název (jméno) konstanty, proměnné, třídy, návěští, podprogramu ve formě procedury a funkce – v C# označovaných obecně jako metoda (anglicky „Method“). 

Pozn.: Jednotlivá klíčová slova v základním kódu C#, které obsahuje tento kurz budou označena modrou barvou (jsou takto označeny i ve Visual Studio).

Jednotlivá klíčová slova můžeme rozdělit do jednotlivých skupin týkajících se:

• Modifikátoru - jsou určitá klíčová slova, která určují, zda může být upravena určitá část programu, popř. modifikován určitý typ - abstract, async, const, event, extern, new, override, partial, readonly, sealed, static, unsafe, virtual, volatile
• Modifikátory přístupu - klíčová slova, která jsou použity při deklaraci třídy, metody, vlastnosti, datových složek, nebo jiných členů. Definují přístupnost třídy, nebo jejích členů - public, private, internal, protected
• Příkazu - vztahují se k vykonávání programu - if, else, switch, case, do, for, foreach, in, while, break, continue, default, goto, return, yield, throw, try, catch, finally, checked, unchecked, fixed, lock
• Parametrů metody - klíčová slova použitá parametrů metody - params, ref, out
  
• Jmenného prostoru - using, . (operátor), :: (operátor), extern, alias
• Operátoru - as, await, is, new, sizeof, typeof, stackalloc, checked, unchecked
• Přístupu - přístup k obsahu třídy, nebo základní třídě objektu nebo třídy - base, this 
  
• Literálu - použití u instance, nebo hodnoty objektu - null, false, true, value, void 
• Datového typu - bool, byte, char, class, decimal, double, enum, float, int, long, sbyte, short, string, struct, uint, ulong, ushort 
• Kontextu - některá kontextová klíčová slova mohou mít i více významů, záleží na kontextu, ve kterém jsou použita, tj. mají specifický význam pro kód, ale nejsou to rezervovaná slova tohoto jazyka (nejsou označena modře ve Visual Studio):
• Kontextová - add, var, dynamic, global, set, value
• Dotazovací - LINQ - from, where, select, group, into, orderby, join, let, in, on, equals, by, ascending, descending

Reference: https://www.tutorialsteacher.com/csharp/csharp-keywords

5. Jmenný prostor

Ve vygenerované základní struktuře kódu pro typ konzolové aplikace jsou na začátku kódu uvedeny za klíčovým slovem using (též nazývaným direktiva) tzv. jmenné prostory, nebo někdy také označovány též prostor jmen (anglický termín „Namespace“) - viz Kód 1.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace HelloWorldPromenna

Kód 1: Jmenné prostory - program HelloWorldPromenna - konzolová aplikace

Tyto jmenné prostory slouží k tomu, aby logicky sdružovaly typy (datové typy a třídy), které spolu souvisejí (můžeme je brát jako příjmení k identifikátorům – názvům knihoven) – např. pokud chceme vypsat v konzoli text a využíváme jmenný prostor System, můžeme pak pouze napsat příkaz Console.WriteLine() namísto zdlouhavého System.Console.WriteLine(). Můžeme také vytvářet vlastní jmenné prostory pomocí klíčového slova namespace. Lze také definovat vnořené jmenné prostory. Přístup do takového prostoru se provede vypsáním jména vnějšího, pak se uvede tečka a následuje jméno vnitřního jmenného prostoru.

Seskupení

Při překladu zdrojového kódu vzniká seskupení (nebo také sestava – anglicky „Assembly“), které obsahuje jeden nebo několik modulů – spustitelné soubory (*.exe), dynamické knihovny (*.dll) nebo jiné součásti programů včetně tzv. manifestu, tj. souboru s dodatečnými informacemi. Spustitelné soubory nebo dynamické knihovny obsahují kromě mezikódu (univerzálního pomocného jazyku – CIL) také tzv. metadata – doplňující informace o datových typech – např. jak se jmenují třídy, jaké obsahují metody apod. Tyto informace mohou využívat nejen překladače, ale i ostatní programy např. pro automatické generováni dokumentace. V seskupení jsou také uloženy informace o lokalizaci (kultuře – jazykové mutaci seskupení). [3]

Seskupení může obsahovat mnoho tříd. Třídy zahrnuté v knihovně tříd prostředí .NET Framework (také obsahuje třídu System.Console), jsou instalovány společně s Visual Studio na počítač. Knihovna tříd .NET Framework obsahuje tisíce tříd. Tyto třídy nelze vměstnat do stejného seskupení, protože toto seskupení by bylo obrovské a šlo by jen těžko spravovat. Proto knihovna tříd .NET Framework je rozdělena do velkého počtu seskupení rozdělených podle funkcí, které vykonávají, nebo podle technologií, které implementují. Například „základní“ sestava (ve skutečnosti nazývaná mscorlib.dll) obsahuje všechny běžné třídy, například System.Console, a další sestavy obsahují třídy pro manipulaci s databázemi, přístup k webovým službám, vytváření GUI atd. Pokud chceme použít třídu v seskupení, musíme přidat odkaz na toto seskupení do našeho projektu. Klíčové slovo using nám umožní tato seskupení používat jako jmenný prostor ve zdrojovém kódu. Měli bychom také vědět, že mezi seskupením a jmenným prostorem nemusí nutně existovat ekvivalence 1: 1: Jediné seskupení může obsahovat třídy definované v mnoha jmenných prostorech a jediný jmenný prostor může zahrnovat více seskupení. Například třídy a položky ve jmenném prostoru System jsou ve skutečnosti implementovány několika seskupeními zahrnující mscorlib.dll, System.dll a System.Core.dll. To sice zní zpočátku velmi zmateně, ale po čase si lze na tuto skutečnost zvyknout. Když používáme Visual Studio k vytvoření aplikace, vybraná šablona automaticky zahrnuje odkazy na příslušná seskupení. To zjistíme tak, že v panelu Solution Explorer u daného projektu rozbalíme složku s odkazy – References. Konzolová aplikace automaticky obsahuje odkazy na seskupení nazvané Microsoft.CSharp, System, System.Core, System.Data, System.Data.DataSetExtensions, System.Net.Http, System.Xml a System.Xml.Linq. Možná nás překvapí, že mscorlib.dll není v tomto seznamu zahrnuta. Důvodem je to, že všechny aplikace .NET Framework musí toto sestavení používat, protože obsahuje základní funkce nutné pro běh aplikace. Složka References uvádí pouze volitelná seskupení (tato seskupení můžeme podle potřeby přidat nebo odebrat z této složky).

6. Třída Program

Vzhledem k tomu, že dosud nemáme osvojeny všechny základní znalosti programování, představme si pojem třída (anglicky „Class“) jako základní konstrukční prvek objektově orientovaného programování, který slouží jako předpis pro vznik objektu (tzv. instance třídy) reprezentujícího např. nějaký prvek reálného světa apod. a tyto třídy jsou ve vzájemné hierarchii. Soubor Program.cs definuje třídu Program a metodu nazvanou Main - viz Kód 1.

    class Program
    {
        static void Main(string[] args)
        {

        }
    }

Kód 1: Třída a metoda Main - program HelloWorldPromenna

V C# je veškerý spustitelný kód definován v rámci metody a všechny metody musí patřit do třídy nebo struktury. Metoda Main označuje vstupní bod programu (hlavní program). Tato metoda by měla být definována ve třídě Program jako statická metoda; jinak .NET Framework ji nemusí rozpoznat a ztratíme tím výchozí bod vaší vytvářené aplikace při jejím spuštění.

Za metodou Main jsou uvedeny kulaté závorky, které značí parametr metody (vstupy) ve formě pole s textovými řetězci. Parametr args není povinné uvádět, takže můžeme tento parametr uvnitř závorky smazat v případě, že ho nepotřebujeme.

Zdrojový kód, který má být v rámci metody Main vykonán, se umísťuje do složených závorek { }. Více se o třídách a metodách dozvíte v pozdějších kapitolách tohoto kurzu. 

Jistě si vzpomínáte, že hlavní program v našich algoritmech byl uvozen mezními značkami - viz Obrázek 1. Hlavní program v C# představuje metoda Main, která byla automaticky vygenerována Visual Studiem v základní struktuře kódu pro konzolovou aplikaci. 

Obrázek 1: Začátek a konec algoritmu - vývojový diagram

7. Přehlednost kódu

Zdrojový je vhodné udržovat ve formě, která je přehledná, čitelná, vhodně rozdělená, popsaná atd. Pro tyto účely můžeme využít následující prvky, které nemají vliv na provádění zdrojového kódu programu.

Komentář

Komentář (anglicky „Comment“) je dodatečná informace (popisující např. podstatu kódu), který nemá vliv na chod přeloženého programu. Komentář často uživateli pomůže rychle pochopit již dříve vytvořený algoritmus, ke kterému se po čase vrátil. Komentář může také sloužit jako informace ostatním osobám, který budou daný kód analyzovat, a může jim pomoci se rychleji orientovat v daném algoritmu zapsaném ve formě kódu.

Asi jste si všimli ve zdrojovém kódu zeleného textu, který je uvozen dvojitým lomítkem // - viz Kód 1.

//Deklarace proměnné
string osloveni;

Kód 1: Komentář k deklaraci proměnné - program HelloWorldPromenna

Tato dvě lomítka umístěná za sebou značí jednořádkový komentář. Díky okomentování tohoto příkazu některé z příkazu ve zdrojovém kódu, nebude tento příkaz v programu vykonán.

Pro úplnost si ještě uveďme značku komentáře používanou v předchozích algoritmech zaznamenaných pomocí vývojových diagramech – viz Obrázek 1.

Obrázek 1: Komentář k deklaraci proměnné - algoritmus HelloWorld_Promenna

Pokud programátor potřebuje víceřádkový komentář, použije lomítko s hvězdičkou pro počátek komentáře /* a víceřádkový komentář uzavře pomocí hvězdičky a lomítka, tj. */ .

Poznámky k dokumentaci ve formě XML

V C# můžeme také vytvořit dokumentaci, kterou lze uvádět u třídy, metody, atributu atd. Poznámky jsou speciální typ dokumentace pomocí XML prvků přidaného ke zdrojovému kódu. Tyto XML prvky jsou uvozeny pomocí trojitého lomítka ///. Taková poznámka specifikovaná např. u metody, bude zobrazena, pokud najedete kurzorem na jméno metody, kterou voláte.

/// <summary>
/// Dokumentace k metodě
/// </summary>

Kód 2: Dokumentace k metodě

/// <returns>Výstup metody</returns>

Kód 3: Dokumentace k výstupu

/// <param name="param1">Komentář k parametru1</param>

Kód 4: Dokumentace k parametru

Oblasti v kódu

U kódu lze také využít poznámky pro rozdělení kódu do jednotlivých oblastí, které kód zpřehledňují, udržují více organizovaný atd. - viz Kód 5. Tyto oblasti je možné sbalit anebo rozbalit. U oblastí lze také využít princip vnoření, tzn., že do oblasti lze umístit další oblasti.

#region Poznámka k oblasti
//…
#endregion

Kód 5: Oblast v kódu

8. Identifikátor

Identifikátor (anglicky „Identifier“) je název konstanty, proměnné, návěští, třídy nebo metody. Identifikátor by měl dostatečně vystihovat a popisovat podstatu, pro kterou je použit. Identifikátor by neměl být příliš dlouhý, nebo příliš krátký.

Při specifikaci identifikátoru bychom měli dodržovat následující pravidla:

• Jedinými povolenými znaky pro identifikátory jsou všechny alfanumerické znaky, tj. množina velkých písmen [A-Z], množina malých písmen [a-z], množina číslic [0-9] a podtržítko, tj. „_“. Podtržítko není vhodné používat jako počáteční písmeno identifikátoru. Ostatní znaky nejsou platnými identifikátory v jazyku C#, např. proměnná „promenna@“ není platná, protože obsahuje speciální znak „@“
• Identifikátory by neměly začínat číslicemi [0-9] např. „123promenna“
• Identifikátory nesmí obsahovat mezery
• Identifikátory nelze používat jako klíčové slovo, pokud neobsahují @ jako předponu. Například @as je platný identifikátor, ale „as“ není, protože se jedná o klíčové slovo

Identifikátory v C# mají následující vlastnosti:

• Identifikátory umožňují použít znaky Unicode
• Identifikátory rozlišují velká a malá písmena
• Identifikátory nemohou obsahovat více než 512 znaků
• Identifikátory neobsahují ve svém názvu dvě po sobě jdoucí podtržítka [7]

V kurzu nebudeme u identifikátorů používat českou diakritiku. U víceslovných názvů budeme používat tzv. velbloudí notaci (anglicky „Camel Case“) v níž víceslovné názvy jsou spojeny do jediného slova, kde každé slovo víceslovného názvu začíná velkým písmenem např. „Moje proměnná“ zapíšeme jako mojePromenna. Je standardem že název proměnné má na počátku malé písmeno.

9. Proměnná – přiřazovací příkaz, výraz

Programy pracují s daty a tato data potřebují uchovávat. Za tímto účelem využíváme proměnné (anglicky „Variable“), které lze vnímat jako pojmenovaný šuplík v paměti, do kterého program dočasně ukládá data. Pro její název platí stejná pravidla jako pro identifikátory. U názvu proměnných budeme psát malé počáteční písmeno. Název proměnné se používá k označení hodnoty, která je do ní uložena, a měl by dostatečně vystihovat podstatu proměnné, např. proměnná týkající se věku by měla být pojmenována jako vek a ne x39. Názvy proměnných by neměly být příliš dlouhé, nebo příliš krátké. Názvy proměnných by se neměly lišit pouze v počátečním písmenu, protože může dojít k jejich záměně např. MojePromenna vs mojePromenna.

Proměnná může obsahovat různé typy dat, které jsou do ní uloženy např. celá čísla, reálná čísla, Booleanovské logické hodnoty atd. Jedná se o tzv. datové typy (ty jsme již používaly ve vývojových diagramech našich algoritmů). Abychom mohly tyto šuplíky v paměti založit a popsat ji svým jménem a třeba ji i přiřadit nějakou počáteční hodnotu, je zapotřebí tzv. deklarovat proměnnou - viz Kód 1.

string osloveni;

Kód 1: Deklarace proměnné osloveni - program HelloWorldPromenna

Doplňme, jak vypadá značka deklarace proměnné osloveni ve vývojovém diagramu - viz Obrázek 1.

Obrázek 1: Deklarace proměnné osloveni - algoritmus HelloWorld_Promenna

Pro uložení hodnoty do proměnné využíváme tzv. přiřazovací příkazu (operátor =). Jeho tvar je:

proměnná = výraz

kde:

• proměnná - představuje identifikátor proměnné
• = ... značí operátor přiřazení
  
• výraz - představuje výraz jehož hodnota se přiřazuje. Výraz tvoří proměnné, konstanty, operátory, jména funkcí a závorky. Výraz reprezentuje pravidlo pro výpočet hodnot. Výraz se vyhodnocuje zleva doprava s ohledem na závorky a prioritu operátorů

Následující kód popisuje přiřazení pomocí operátoru (=), který představuje tzv. operátor přiřazení (anglicky „Assignment Operator“) - viz Kód 2. Každý krok (příkaz, výraz, atd.) je oddělen středníkem uváděným na konci.

//Přiřazení textu proměnné
osloveni = "Hello, World!";

Kód 2: Přiřazení hodnoty proměnné osloveni - program HelloWorldPromenna

Značka předchozího přiřazovacího příkazu ve vývojovém diagramu ve Flowgorithm vypadá následovně - viz Obrázek 2.

Obrázek 2: Přiřazení hodnoty proměnné osloveni - algoritmus HelloWorld_Promenna

Přiřazovat lze do proměnné, jejíž datový typ je datově kompatibilní vzhledem k přiřazení s datovým typem přiřazovaného výrazu. Předpokládejme, že na levé straně od přiřazovacího příkazu je proměnná datového typu TYP1 a na pravé straně přiřazovacího příkazu je výraz datového typu TYP2. Pak můžeme zjednodušeně, s ohledem na dosud vysvětlenou látku, tvrdit, že hodnota datového typu TYP2 je kompatibilní vzhledem k přiřazení s datovým typem TYP1, jestliže hodnoty datového typu TYP2 patří do množiny hodnot specifikované datovým typem TYP1. Jednoduše řečeno, pokud máte vpravo od přiřazovacího operátoru datový typ text, nemůže ho uložit do proměnné (na levé straně od operátoru přiřazení), která je celočíselného typu. V takovém případě musíte použít konverzi, která převede např. výraz na datový typ proměnné.

Hodnotu proměnné lze v C# nastavit i přímo v její deklaraci. Tomuto nastavení počáteční hodnoty se říká inicializace proměnné (anglicky „Initializing Variable") - viz Kód 3. 

//Deklarace proměnné včetně inicializace
string osloveni = "Hello, World!";

Kód 3: Inicializace proměnné osloveni - program HelloWorldPromenna

Nyní máme v proměnné uložený text. Abychom se k tomuto textu dostali (kouknuli se do  bloku paměti, kde je text uložen), stačí použít název proměnné (obecně lze říci identifikátor). Řekněme, že chceme k aktuální hodnotě uložené v proměnné, tedy "Hello, World!" připojit další text, např. " It is me, your PC.". V kódu se nejprve vyhodnotí pravá strana tzv. výrazu, tzn., že použitím názvu proměnné obdržíme její aktuální hodnotu, tj. "Hello, World!" a následně připojíme další text " It is me, your PC." pomocí operátoru +. Výraz se totiž vyhodnocuje zleva doprava za operátorem přiřazení (tj. =). Výsledná hodnota této textové operace (tj. "Hello, World! It is me, your PC.")  je následně uložena do proměnné uvedené na levé straně od operátoru =, tj. do proměnné osloveni - viz Kód 4.

//Připojení nového textu k obsahu proměnné a následné přiřazení do proměnné
osloveni = osloveni + " It is me, your PC.";

Kód 4: Připojení hodnoty k aktuálnímu obsahu proměnné osloveni - program HelloWorldPromenna

Ve vývojovém diagramu bychom k této operaci znovu využili značku pro přiřazení do proměnné.

Pokud bychom chtěli provést nějakou operaci např. výpisu obsahu proměnné, aniž by v ní byla uložena hodnota, nastal by chyba s výpisem "Use of unassigned local variable 'osloveni'". Jazyk C# nedovoluje používat proměnné, aniž by do ní nebyla přiřazena hodnota – pravidlo jednoznačného přiřazení (anglicky „Definite Assignment Rule“).

A jak by vypadaly všechny předchozí operace uplatněná na celá čísla?  Pojďme si nejprve ukázat, jak by vypadala deklarace celočíselné proměnné počet - viz Kód 5.

//Deklarace proměnné pro uložení celých čísel
int pocet;

Kód 5: Deklarace proměnné pocet

Při deklaraci lze hned provést inicializaci proměnné - viz Kód 6.

//Deklarace a inicializace celočíselné proměnné
int pocet = 0;

Kód 6: Inicializace proměnné pocet

Řekněme, že chceme k aktuální hodnotě uložené v proměnné pocet přičíst 1 - viz Kód 7.

//Operace přičtení 1 k aktuální hodnotě uložené v proměnné
pocet = pocet + 1;

Kód 7: Přičtení 1 k aktuální hodnotě v proměnné pocet

Pokud bychom chtěli provést nějakou početní operaci např. přičtení 1 do proměnné, aniž by v ní byla uložena hodnota, nastal by problém – pravidlo jednoznačného přiřazení - viz Kód 8.

//Deklarace proměnné pro uložení celých čísel
int pocet;
//Toto nelze provést, v proměnné není uložena hodnota
pocet = pocet + 1;

Kód 8: Příklad neplatného výrazu při absenci inicializace proměnné pocet

Pokud chceme inicializovat více proměnných najednou, můžete provést následující zápis – viz Kód 9. Asi si odvodíte, že tento výraz je vyhodnocován postupně zprava doleva.

//Deklarace více celočíselných proměnných
int pocet1, pocet2, pocet3;
//Inicializace více proměnných -> postupné vyhodnocení zprava doleva
pocet3 = pocet2 = pocet1 = 0;

Kód 9: Příklad inicializace více proměnných

V C# lze také zapsat následující kód - viz Kód 10. Tento kód ale znamená něco jiného než předchozí. V tomto kódu bude provedena pouze inicializace proměnné pocet3.

//Deklarace pouze jedné celočíselné proměnné ze tří proměnných
int pocet1, pocet2, pocet3 = 0;

Kód 10: Příklad inicializace pouze jedné proměnné ze tří proměnných

Obor platnosti

Proměnné mají také svůj obor platnosti:

• Třídní (nelokální) proměnná – lze použít v metodách třídy

Více o této problematice se dozvíme později, až budeme vysvětlovat metody.

Implicitně typované proměnná

U lokálních proměnných můžete také použít tzv. anonymní typ (přesněji se tomuto typu říká implicitně typovaná lokální proměnná – anglicky „Implicitly Typed Local Variable“), tzn., že nemusíme specifikovat datový typ proměnné (dosud jsme používali tzv. explicitně typované proměnné, kde jsme uváděli datový typ proměnné)  - viz Kód 11.

//Explicitně typovaná lokální proměnná
int explicitneTypovanaPromenna = 0;
//Implicitně typovaná lokální proměnná
var implicitneTypovanaPromenna = 0;

Kód 11: Příklad explicitně a implicitně typované lokální proměnné

Implicitní typ je odvozen kompilátorem při inicializace proměnné. Na ukázce zdrojového kódu vidíme, že si kompilátor odvodí dva různé datové typy – celé číslo a text – viz Kód 12.

//První implicitně typovaná lokální proměnná
var implicitneTypovanaPromenna1 = 0;
//Druhá implicitně typovaná lokální proměnná
var implicitneTypovanaPromenna2 = "text";

Kód 12: Příklad implicitně typované lokální proměnné

Pokud tedy neinicializujete tento typ proměnné, nelze s ní provádět další operace – viz Kód 13.

//Chybí inicializace implicitně typované proměnné
var implicitneTypovanaPromenna;
//Operaci přičtení nelze provést díky absenci inicializace
implicitneTypovanaPromenna = implicitneTypovanaPromenna + 1;

Kód 13: Příklad chyby u implicitně typované lokální proměnné

10. Zjednodušený příkaz vstupu

Pro další výklad budeme potřebovat znát princip, jak jednoduše přečteme data z klávesnice. Tyto jednoduché vstupní operace budeme provádět pomocí konzole.

Hodnoty se do programu zadávají různým způsobem – nejčastěji pomocí vstupního zařízení naplníme určité proměnné např. klávesnice počítače, čtecí zařízení, import ze souboru apod. Při plnění proměnné bychom měli dodržet zásady: vstupní seznam nesmí být prázdný a v seznamu mohou být pouze jména proměnných, které mají být naplněny (nesmí to být např. konstanta nebo jiný výraz. Hodnota konstanty se v průběhu algoritmu nemění a nemusí mít vždy jen číselnou hodnotu).

Načtení textu

Pro demonstraci principu načtení hodnoty z klávesnice do proměnné využijeme již dříve vytvořený algoritmus, který je modifikací základního algoritmu HelloWorld.

Ilustrativní příklad HelloWorldNacteni

Algoritmus HelloWorldNacteni

• Popis: Vývojový diagram načtení textu zadaného uživatelem do proměnné
• Zadání: Zkuste vymyslet, jak byste zaznamenali načtení hodnoty zadané uživatelem a její uložení v proměnné s názvem osloveni pomocí vývojového diagramu, včetně komentářů, které popisují, co jednotlivé značky zajišťují
• Řešení: https://phix.zcu.cz/moodle/pluginfile.php/286373/mod_book/chapter/61236/Algoritmus_HelloWorldNacteni.png?time=1577571268914

Na základě vývojového diagramu HelloWorldNacteni vytvoříme v konzolové aplikaci program, na kterém si vysvětlíme základní příkaz vstupu.

Program HelloWorldNacteni

• Popis: Program pro načtení proměnné v níž je uložen text zadaný uživatelem 
• Zadání: Na základě algoritmu HelloWorldNacteni vymyslete, jak byste v hlavní metodě Main naprogramovali načtení hodnoty zadané uživatelem uložené do proměnné s názvem osloveni pomocí konzolové aplikace v C#, včetně komentářů, které popisují, co jednotlivé příkazy zajišťují 
• Řešení: Bude postupně probráno v následujícím textu a finální verze řešení bude zobrazena v další kapitole
  

Následující značka definuje, jak bychom ve vývojovém diagramu zaznamenali načtení textu do proměnné osloveni – viz Obrázek 1.

Obrázek 1: Příklad načtení textu do proměnné osloveni - algoritmus HelloWorldNacteni

V tomto případě se jedná o čtení textu (v C# datový typ string) v konzolové aplikaci pomocí příkazu načtení ReadLine, který je definován ve třídě Console, tzn., že pokud budeme chtít zavolat tento příkaz, musíme napsat Console.ReadLine. Pokud chceme načíst v konzoli text a využíváme jmenný prostor System, můžeme pak pouze napsat příkaz Console.ReadLine namísto zdlouhavého System.Console. ReadLine.

Za slovem ReadLine následuje prázdná závorka. Pro uložení textu do proměnné využijeme operátor přiřazení (tj. =), který umístíme před příkaz čtení. Vlevo od tohoto operátoru napíšeme název proměnné, do níž budeme chtít text  uložit, v našem případě osloveni - viz Kód 1. 

//Načtení hodnoty (textu) do proměnné
osloveni = Console.ReadLine();

Kód 1: Příklad načtení textu do proměnné osloveni - program HelloWorldNacteni

Uživatelem zadaný text, který je vstupem do programu, např. uživatel zadá text pomocí klávesnice, je po stisknutí klávesy Enter na klávesnici (tzv. omezovače) načten do proměnné a program v konzoli umístí kurzor na nový řádek.

Příkaz Read nebudeme v našich programech používat, protože tento příkaz načítá sekvenčně jednotlivé znaky, a to v našem případě není zapotřebí.

Ve zdrojovém kódu budeme také využívat příkaz Console.ReadKey(). Tento příkaz budeme umísťovat před koncovou složenou závorku }, která značí konec provádění kódu. Příkaz zajistí, že program bude čekat, až uživatel stiskne nějakou klávesu. Náš kompilovaný program by bez tohoto příkazu totiž skončil a my bychom si ani nestihli přečíst výsledek, pokud by byl v programu vypisován.

Načtení čísla

V mnoha případech našich programů budeme potřebovat provádět aritmetické výpočty a k tomu potřebujeme znát hodnoty ve formě celých, nebo reálných čísel. Tak tomu bylo i v případě našeho algoritmu kalkulačky, kde jsme na začátku algoritmu načetli číselný kód prováděné aritmetické operace a následně dva operandy této operace.

Ilustrativní příklad Kalkulacka

Algoritmus Kalkulacka

• Popis: Vývojový diagram pro řešení aritmetických operací u dvou zadaných čísel 
• Zadání: Zkuste navrhnout algoritmus, který řeší základní aritmetické operace podle zadaného číselného kódu (1 … sčítání, 2 … odečítání, 3 … násobení a 4 … dělení) u dvou uživatelem zadaných čísel a a b
• Řešení: https://phix.zcu.cz/moodle/pluginfile.php/389317/mod_book/chapter/98998/Algoritmus_Kalkulacka.png

Pokud jste si zapnuli v aplikaci Flowgorithm zobrazení kódu algoritmu Kalkulacka, asi jste zjistili, že aplikace přidává vlastní metodu readValue (podprogram - funkci) pro načtení čísla z klávesnice. Základní kamenem této funkce je konverze (transformace) načteného textu (v C# datového typu string, který představuje řetězec znaků) z klávesnice a jeho následné převedení na číslo. Existují různé typy konverze. Třídy jednotlivých datových typů obsahují metody, které jsou schopny převést text na celé nebo reálné číslo (záleží na tom, který datový typ jsme zvolili např. u proměnné). Konverzi budeme provádět pomocí příkazu Parse uvedeného za tečkou uvedenou přímo za datovým typem, do něhož chceme načtený text konvertovat. Tento příkaz konvertuje načtené znaky textu a poskládá je do výsledného čísla - viz Kód 2.

//Deklarace celočíselné proměnné - datový typ int
int kod;
/*Načtení textu z klávesnice do proměnné -> provedení konverze ->
  uložení konvertované hodnoty do proměnné*/
kod = int.Parse(Console.ReadLine());

Kód 2: Příklad načtení textu, jeho konverze na celé číslo a uložení do celočíselné proměnné

U tohoto příkazu musíme dávat pozor, abychom dobře napsali danou hodnotu čísla uváděnou pomocí načteného textu, protože pokud bychom např. napsali text "bflmpsvz", asi z něj těžko obdržíme po konverzi celé nebo reálné číslo. Ošetřováním chyb na vstupu a na výstupu se nyní věnovat nebudeme.

Všimněte si, že metodě Parse můžeme předat výsledek jako argument (vstupní parametr) výsledek jiné metody, v tomto případě ReadLine, než abychom vytvářeli další textovou proměnnou a do ní ukládali načtený text. Ušetřili jsme tím nejen kód, místo v paměti, ale zároveň i výpočetní výkon počítače. Takový postup je v programování běžný.

Značka načtení celého čísla ve vývojovém diagramu se nijak neliší od značky pro načtení textu (kosodélník s textem Input a za ním následuje název proměnné), který byl zobrazen na začátku této kapitoly.

Uváděný datový typ int je zkratkou pro třídu Int32. Je zbytečné vypisovat celou adresu této třídy ve jmenném prostoru, protože bychom např. pro metodu Parse museli uvádět System.Int32.Parse, což by značně prodlužovalo psaní kódu - viz Kód 3. Kompilátor by sám nabídl možnost zkrácení tohoto zápisu.

//Specifikace jmenného prostoru pro datový typ
kod = System.Int32.Parse(Console.ReadLine());

Kód 3: Specifikace jmenného prostoru pro datový typ

Stejným způsobem, jakým jsme načítali hodnotu do celočíselné proměnné, bychom postupovali i při načítání reálného čísla (datový typ double) – viz Kód 4.

//Deklarace reálné proměnné - datový typ double
double y;
//Konverze načteného textu na reálné číslo -> uložení do proměnné
y = double.Parse(Console.ReadLine());

Kód 4: Příklad načtení textu, jeho konverze na reálné číslo a uložení do reálné proměnné

11. Zjednodušený příkaz výstupu

V předchozí kapitole jsme si ukázali, jak načíst hodnotu do proměnné. Jelikož vytvářená aplikace by měla být uživatelsky přívětivá, je vhodné při načítání nějaké vstupní hodnoty, vyzvat uživatele k zadání této hodnoty. Pro výzvu využijeme příkaz Write do jehož kulatých závorek, které představují seznam vstupů, napíšeme text v horních dvojitých uvozovkách (takto se definuje textový řetězec – datový typ string). Příkaz Write nám zajistí, že kurzor se neumístí na nový řádek, ale bude umístěn za vypsaným textem (oproti příkazu WriteLine, který po vypsání textu umístí kurzor na nový řádek).

Výpis textu

Pro demonstraci principu výpisu využijeme již dříve vytvořený základní algoritmus HelloWorld. V tomto jednoduchém programu pouze vypíšeme text "Hello, World!".

Ilustrativní příklad HelloWorld

Algoritmus HelloWorld

• Popis: Vývojový diagram výpisu textu "Hello, World!" 
• Zadání: Zkuste vymyslet, jak byste zaznamenali výpis textu pomocí vývojového diagramu, včetně komentáře, který popisuje, co daná značka výpisu provádí
  
• Řešení:
  https://phix.zcu.cz/moodle/pluginfile.php/286373/mod_book/chapter/61236/Algoritmus_HelloWorld.png?time=1577571215952

Program HelloWorld

• Popis: Program pro výpis textu
• Zadání: Na základě algoritmu HelloWorld vymyslete, jak byste v hlavní metodě Main naprogramovali výpis textu "Hello, World!" pomocí konzolové aplikace v C#, včetně komentáře který popisuje, co příkaz zajišťuje 
• Řešení: Bude postupně probráno v následujícím textu

Následující značka definuje, jak bychom ve vývojovém diagramu zaznamenali výpis textu – viz Obrázek 1.

Obrázek 1: Příklad výpisu textu - algoritmus HelloWorld

V tomto případě se jedná o výpis textu (v C# datový typ string) v hlavním programu konzolové aplikace pomocí příkazu načtení WriteLine, který je definován ve třídě Console, tzn., že pokud budeme chtít zavolat tento příkaz, musíme napsat Console.WriteLine (po výpisu textu umístí kurzor na další řádek) - viz Kód 1. Všimněte si, že textový řetězec umístěný v dvojitých uvozovkách (datový typ string) je umístěn do kulaté závorky za příkaz výpisu. Příkaz se od jiného příkazu odděluje středníkem!

Další verzí příkazu výpisu je příkaz Write, ten ale na rozdíl od příkazu WriteLine neumístí kurzor na další řádek.

//Výpis textu
Console.WriteLine("Hello, World!");

Kód 1: Příklad výpisu textu - program HelloWorld

Pokud chceme vypsat v konzoli text a využíváme jmenný prostor System, můžeme pak pouze napsat příkaz Console.WriteLine namísto zdlouhavého System.Console. WriteLine.

Vzhledem k tomu, že pracujeme s konzolovou aplikací, využili jsme ve zdrojovém kódu příkaz Console.ReadKey(). Tento příkaz jsme umístili před koncovou složenou závorku } těla hlavní metody, která značí konec provádění kódu v metodě. Příkaz zajistí, že program bude čekat, až uživatel stiskne nějakou klávesu. Náš kompilovaný program by bez tohoto příkazu totiž skončil a my bychom si ani nestihli přečíst výsledek, pokud by byl v programu vypisován. Celý kód hlavního programu by vypadal následovně - viz Kód 2.

static void Main(string[] args)
{
    //Výpis textu
    Console.WriteLine("Hello, World!");
 
    //Čekání na stisk klávesy -> ukončení programu
    Console.ReadKey();
}

Kód 2: Deklarace hlavní metody Main a výpis textu - program HelloWorld

Na následujícím výpisu v konzoli (výstupy programu budou formátovány tímto způsobem) vidíme, že textový řetězec byl vypsán v konzole naší aplikace – viz Výstup programu - Kód 2. Po výpisu program čeká na stisknutí nějaké klávesy (znaku, nebo funkční klávesy). Po stisknutí klávesy bude program ukončen (ve skutečnosti si program načte znak, nebo funkční klávesu, ale není definováno, kam má hodnotu uložit, tudíž je hodnota zapomenuta a nastane další krok programu, což je konec programu).

Hello, World!

Výstup programu - Kód 2: Výpis textu

Výpis hodnoty v proměnné

Jak je to s výpisem načtené hodnoty uložené v proměnné? To nám osvětlí další program HelloWorldNacteni, který je modifikací základního algoritmu HelloWorld.

Ilustrativní příklad HelloWorldNacteni

Algoritmus HelloWorldNacteni

• Popis: Vývojový diagram výpisu proměnné v níž je uložen text zadaný uživatelem
• Zadání: Zkuste vymyslet, jak byste zaznamenali výpis hodnoty zadané uživatelem uložené v proměnné s názvem osloveni pomocí vývojového diagramu, včetně komentářů, které popisují, co jednotlivé značky zajišťují
• Řešení: https://phix.zcu.cz/moodle/pluginfile.php/286373/mod_book/chapter/61236/Algoritmus_HelloWorldNacteni.png?time=1577571268914

Na základě vývojového diagramu HelloWorldNacteni vytvoříme v konzolové aplikaci program, na kterém si vysvětlíme základní příkaz výstupu - výpisu.

Program HelloWorldNacteni

• Popis: Program pro výpis textu
• Zadání: Na základě algoritmu HelloWorldNacteni vymyslete, jak byste v hlavní metodě Main naprogramovali výpis načteného hodnoty (textu) zadané uživatelem uložené do proměnné s názvem osloveni pomocí konzolové aplikace v C#, včetně komentářů, které popisují, co jednotlivé příkazy zajišťují 
• Řešení: Bude postupně probráno v následujícím textu

Obrázek 2: Příklad výpisu textu v proměnné osloveni - algoritmus HelloWorldNacteni

Následující výřez zdrojového kódu ukazuje, jak bychom nechali program vypsat načtenou hodnotu do proměnné oslovení, která je datového typu string - viz Kód 3. Identifikátor proměnné stačí pouze napsat do kulaté závorky za příkaz. 

//Výpis hodnoty uložené v proměnné
Console.WriteLine(osloveni);

Kód 3: Příklad výpisu textu - program HelloWorld

Pojďme si ale nejprve celý program sestrojený na základě algoritmu projít postupně. Nejprve musíme deklarovat proměnnou osloveni, do které budeme načítat hodnotu - text (datový typ string). Aby uživatel věděl, že má zadat nějaký text, musíme uživatele o této skutečnosti informovat pomocí výpisu v konzoli. Po výpisu bude provedeno načtení hodnoty z klávesnici a její uložení (přiřazení) do proměnné osloveni. Uživatelem zadaný text pomocí klávesnice, bude po stisknutí klávesy Enter načten do proměnné osloveni a program v konzoli umístí kurzor na nový řádek. Pomocí příkazu WriteLine tuto načtenou hodnotu vypíšeme. Nezapomeňte na příkaz ReadKey, abychom si vypsanou hodnotu stihli přečíst. Celý hlavní program - metoda Main - by vypadal následovně - viz Kód 4. 

static void Main(string[] args)
{
    //Deklarace proměnné
    string osloveni;
 
    //Oslovení uživatele pro zadání textu
    Console.WriteLine("Zadejte text:");
 
    //Načtení hodnoty (textu) do proměnné
    osloveni = Console.ReadLine();
 
    //Výpis hodnoty uložené v proměnné
    Console.WriteLine(osloveni);
 
    //Čekání na stisk klávesy -> ukončení programu
    Console.ReadKey();
}

Kód 4: Deklarace hlavní metody Main a výpis načteného textu uloženého v proměnné osloveni - program HelloWorldNacteni

Na následujícím výpisu v konzoli vidíme, že uživatel zadal na druhé řádce v konzoli textový řetězec, který byl následně vypsán v další řádce naší konzolové aplikace – viz Výstup programu - Kód 4.

Zadejte text:
Toto je zadaný text
Toto je zadaný text

Výstup programu - Kód 4: Výpis načtené textu uloženého v proměnné 

A jak je to s výpisem čísel? U předchozího ilustrativního příkladu Kalkulacka víme, jak načíst do proměnné celé číslo (proměnná kod  byla deklarována jako datový typ int). Museli jsme provést konverzi textového řetězce na celé číslo pomocí příkazu Parse. Obdobným způsobem, ale obráceně, musíme postupovat i výpisu obsahu číselné proměnné. Více již v následujícím příkladu.

Ilustrativní příklad Kalkulacka

Algoritmus Kalkulacka

• Popis: Vývojový diagram pro řešení aritmetických operací u dvou zadaných čísel 
• Zadání: Zkuste navrhnout algoritmus, který řeší základní aritmetické operace podle zadaného číselného kódu (1 … sčítání, 2 … odečítání, 3 … násobení a 4 … dělení) u dvou uživatelem zadaných čísel a a b
• Řešení: https://phix.zcu.cz/moodle/pluginfile.php/286676/mod_book/chapter/62102/Algoritmus_Kalkulacka.png

Na následujícím výřezu zdrojového kódu implementovaného v hlavní metodě Main podle algoritmu Kalkulacka vidíme, že  na začátku jsou deklarovány tři proměnné, do kterých budeme ukládat desetinná čísla. Jedná se o typ double (o datových typech se více dozvíme později) - viz Kód 5. 

Pro výpis textu "Výsledek C:" spojeného s hodnotou uloženou v proměnné c (spojení je pomocí operátoru +) použijeme znovu příkaz WriteLine jehož vstupní argumenty jsou umístěny do kulaté závorky. 

//Deklarace reálných proměnných - datový typ double
double a, b, c;
 
//...
 
//Výpis textu s hodnotou výsledku
Console.WriteLine("Výsledek C: " + c);

Kód 5: Příklad výpisu textu a hodnoty uložené v proměnné c

Asi si říkáte, jak to, že příkaz WriteLine, který požaduje jako vstupní argument text, dokáže vypsat jak text, tak i hodnotu reálné proměnné, která text není.  Výhodou konzolové aplikace, že tuto konverzi provede za nás (datový typ double konvertovala na datový typ string). Pokud bychom chtěli postupovat zcela správně, měli bychom využít metodu konverze např. příkaz ToString - viz Kód 6. Metodu vybereme pomocí tečkové notace, tzn. uvedeme tečku za identifikátorem proměnné a vybereme příslušnou metodu. Tato metoda nemá žádné vstupní argumenty, proto za ToString uvedeme prázdné závorky.

//Výpis textu + konverze reálného čísla na text
Console.WriteLine("Výsledek C: " + c.ToString());

Kód 6: Příklad výpisu textu a konvertované hodnoty uložené v proměnné c

Obdobně bychom mohli využít metody třídy Convert, které dokáží provádět konverze i do jiných datových typů - viz Kód 7.  

//Výpis textu + konverze reálného čísla na text
Console.WriteLine("Výsledek C: " + Convert.ToString(c));

Další možností jako vypsat hodnotu uložené v proměnné je za použití operátoru $. Tento symbol na začátku tzv. interpolovaného textového řetězce (anglicky „String Interpolation“) označuje, že se jedná o řetězec, jehož výrazy uzavřené ve složených závorkách, by měly být nejprve vyhodnoceny a následně vráceny jako text. Interpolace řetězce je lépe čitelná, méně náchylná k chybám a také méně náročnější na paměť, než použití operátoru +, se kterým pracuje .NET Framework.

//Interpolace řetězce
Console.WriteLine($"Výsledek C: {c}");

My budeme zejména využívat pro výpis hodnoty proměnné (nebo více proměnných) příkaz WriteLine (lze použít i příkaz Write) takovým způsobem, že do závorky za tento příkaz umístíme text, který chceme vypsat včetně indexu proměnné uzavřeného ve složených závorkách (index první proměnné má hodnotu 0). Za čárku v kulatých závorkách umístíme název proměnné, jejíž aktuální hodnotu chceme vypsat – viz Kód 9. Výpis v konzoli je stejný jako v předchozím případě (kromě prázdného řádku s kurzorem).

//Výpis textu + konverze celého čísla na text
Console.WriteLine("Výsledek C: {0}", c);

Všechny předchozí by vypadaly totožně (za předpokladu, že budeme vypisovat stejnou hodnotu v proměnné) - viz Výstup programu - Kód 5, 6, 7, 8. Ve výstupu vidíme, že se reálné číslo formátuje podle místních zvyklostí, tzn., že pokud je v operačním systému nastavena česká lokalizace, tak se vypíše česká desetinná čárka, namísto americké desetinné tečky. To samé platí i pro vstup, tj. zadávání reálného čísla jako vstup do programu, budeme zadávat číslo s desetinnou čárkou.

Výsledek C: 2,5

Výstup programu - Kód 5, 6, 7, 8: Příklad výpisu textu a konvertované hodnoty 2.5 uložené v proměnné c 

Abychom ukázali případ výpisu více proměnných, použijeme dvě číselné proměnné x a y. První celočíselnou proměnnou x (datový typ int) inicializujeme hodnotou 0. Druhou reálnou proměnnou b (datový typ double), inicializujeme hodnotu 1.5. Kód pro výpis hodnot v těchto proměnných by byl následující – viz Kód 9.

//Deklarace celočíselné proměnné včetně inicializace - datový typ int
int x = 0;
//Deklarace reálné proměnné včetně inicializace - datový typ double
double y = 1.5;
//Výpis textu + konverze více proměnných
Console.Write("Aktuální hodnota x: {0} a y: {1}", x, y);

Výpisu textu a hodnot proměnných v konzoli by vypadal následovně – viz Výstup programu - Kód 9.

Aktuální hodnota x: 0 a y: 1,5

Výstup programu - Kód 9: Příklad výpisu textu a hodnot čísel uložených v celočíselné a reálné proměnné

12. Operátory

Následující tabulka obsahuje aritmetický operátory, které jsou využívány při matematických operacích v C# – viz Tabulka 1. Ve vývojových diagramech jsme záměrně využívali ty samé operátory, aby náš přechod směrem od algoritmů ke zdrojovým kódům byl o něco lehčí.

Tabulka 1: Aritmetické operátory

Pokud ukládáme do proměnné nějakou hodnotu výrazu, tento výraz se skládá z tzv. operandů (anglicky „Operand“ - např. z = x + y; kde x a y na pravé straně od operátoru přiřazení (operátor =) jsou operandy ve výrazu, tzn., že x + y je výraz). Nejprve je vypočtena hodnota výrazu na pravé straně a následně uložena do proměnné na levé straně.

Následující zdrojový kód ukazuje použití různých operátorů na celých číslech (datový typ int) – viz Kód 1.

//Deklarace celočíselné proměnné včetně inicializace
int x = 7;
//Deklarace celočíselné proměnné včetně inicializace
int y = 2;
 
//Provedení součtu celočíselných proměnných -> výsledek je 9
int soucet = x + y;
 
//Provedení rozdílu celočíselných proměnných -> výsledek je 5
int rozdil = x - y;
 
//Provedení součinu celočíselných proměnných -> výsledek je 14
int soucin = x * y;
 
//Provedení celočíselného dělení celočíselných proměnných -> výsledek je 3
int podilCelociselny = x / y;
 
//Provedení zbytku po celočíselného dělení celočíselných proměnných -> výsledek je 1
int zbytekPodilCelociselny = x % y;

Kód 1: Příklady aritmetických operací s celými čísly

Dbejte vždy zvýšené pozornosti na to, když jsou operandy různého datového typu. Pokud uvedeme příklad u celočíselného dělení, kde oba operandy budou celá čísla např. x = 5 / 2 do proměnné x bude uložena celočíselná hodnota 2. Pokud ale napíšeme x = 5 / 2.0, pak kompilátor C# detekuje nesoulad operandů a vygeneruje kód, který převede celé číslo (typ int) na reálné (typ double) před provedením aritmetické operace. Výsledek operace je pak reálná hodnota 2.5 (typ double).

Dále bychom také měli vědět, že výsledek dělení libovolného čísla nulou je nekonečno (to je mimo rozsah typů int, long a decimal). Uveďme vyhodnocení výrazu např. 5 / 0. Vyhodnocení způsobí chybu. Avšak datové typy double a float mají ve skutečnosti speciální hodnotu, která může představovat nekonečno. Pokud tedy přepíšeme operandy výrazu na 5.0 / 0.0 výsledek bude nekonečno (výjimkou z tohoto pravidla je hodnota výrazu 0.0 / 0.0). Obvykle, pokud vydělíte nulu nějakou hodnotou, výsledek je nula. Pokud ale vydělíte číslo nulou, výsledkem je nekonečno. Výraz 0.0 / 0.0 vede k paradoxu; hodnota musí být současně nula a nekonečno. C # má pro tuto situaci další zvláštní hodnotu zvanou NaN, což znamená, že není číslem – zkratka anglického „Not a Number“. Pokud tedy vyhodnocujete výraz 0.0 / 0.0, výsledkem je NaN.

NaN a Nekonečno se ovlivňuje výrazy. Pokud vyhodnocujete 10 + NaN, výsledkem je NaN, a pokud vyhodnocujete 10 + Nekonečno, výsledkem je Nekonečno. Hodnota výrazu Nekonečno * 0 je NaN. [6]

Dalším důležitým faktem u výrazů je přednost některých operátorů před jinými operátory, např. násobení má přednost před sčítáním.

Co ale pokud operátory mají stejnou přednost, např. násobení a dělení. Pak je výraz postupně vyhodnocen zleva doprava. Pokud potřebujeme některý operátor upřednostnit před jiným, můžeme použít systém závorek.

Následující zdrojový kód ukazuje použití různých operátorů na kombinaci celé (datový typ int) a reálné číslo (datový typ double) – viz Kód 2.

//Deklarace celočíselné proměnné včetně inicializace
int x = 7;
//Deklarace reálné proměnné (desetinné číslo) včetně inicializace
double z = 2;

//Provedení dělení celočíselné a reálné proměnné -> reálné číslo -> výsledek je 3.5
double podilRealny = x / z;
 
//Nelze provést dělení celočíselné a reálné proměnné, když výsledný typ je int -> K.O.
int podilRealny2 = x / z;
 
//Priorita operátorů -> výsledek je 26
int prioritaOperatoru1 = 2 * 3 + 4 * 5;
 
//Použití závorek pro upřednostnění operace -> výsledek je 70
int seZavorkami = 2 * (3 + 4) * 5;
 
//Priorita operátorů -> výsledek je 8
int prioritaOperatoru2 = 2 + 12 / 2;
 
//Použití závorek pro upřednostnění operace -> výsledek je 7
int seZavorkami2 = (2 + 12) / 2;

Kód 2: Příklady aritmetických operací s celým a reálným číslem

Jazyk C# umožňuje také zkrácení zápisu, tj. použití kombinace libovolného aritmetického operátoru s přiřazovacím operátorem. Tyto operátory se nazývají operátory složeného přiřazení (anglicky „Compound Assignment Operators“) - viz Tabulka 2. Výraz za přiřazovacím operátorem lze tedy zkrátit vypuštěním operandu se stejným názvem jako má proměnná na levé straně od operátoru přiřazení (proměnná, do které ukládáme hodnotu). Znamená to, že vypouštíme operand, který nám poskytuje informaci o aktuální hodnotě uložené v proměnné. U textového řetězce lze použít pouze operátor typu +=. 

Tabulka 2: Operátory složeného přiřazení – zkrácený zápis výrazu

Jistě si vzpomínáte, že v cyklu s krokem byla definována tzv. řídící proměnná (nebo též čítač) včetně přírůstku (nebo také inkrementu). Čítač obecně bývá značen písmenem i a jeho zápis inkrementace by vypadal např. takto i = i + 1; .Tento zápis bychom mohli redukovat za pomoci použití operátoru složeného přiřazení, tj. i += 1; Pro inkrementaci proměnné o hodnotu 1 jazyk C# umožňuje použít zápis proměnné s připojením dvojité plus, tj. i++. Tento operátor je tzv. unární, což znamená, že má pouze jeden operand. Pro dekrementaci (snížení) o hodnotu 1 zase lze použít operátor dvojité mínus, tj. i--.

Podívejme se na následující kód, který provádí inkrementaci - viz Kód 3. V něm je provedena deklarace a inicializace proměnné. Další řádek kódu nám vypisuje hodnotu proměnné, na níž byla provedena inkrementace. Tento výsledek necháme vypsat v dalším příkazu pro výpis.

//Deklarace proměnné včetně inicializace
int i = 0;
//Výpis proměnné, kde byla provedena inkrementace o 1
Console.WriteLine("Inkrementace i: {0}", i++);
//Výpis aktuální hodnoty proměnné
Console.WriteLine("Inkrementace i: {0}", i);

Kód 3: Příklad postfixové inkrementace proměnné

Na následujícím výpisu v konzoli vidíme, že se stala menší zrada – viz Výstup programu - Kód 3. V prvním řádku se vypsala hodnota proměnné, aniž by byla provedena inkrementace o 1.

Inkrementace i: 0
Inkrementace i: 1

Výstup programu - Kód 3: Ukázka výsledku inkrementace

Tím, že jsme použili operátor ++ umístněný za proměnnou, jsme programu řekli, že má nejprve provést vypsání v konzoli a teprve až po vypsání zvednout hodnotu proměnné o 1 (v kódu se postupovalo zleva doprava, jak jsme zvyklí). Použili jsme tzv. postfixový zápis. Pokud bychom potřebovali, aby se nejprve vypsala hodnota zvýšená o 1, musíme použít prefixový zápis, tzn. operátor umístit před proměnnou – viz Kód 4.

//Deklarace proměnné včetně inicializace
int i = 0;
//Výpis proměnné, kde byla neprve provedena inkrementace o 1
Console.WriteLine("Inkrementace i: {0}", ++i);
//Výpis aktuální hodnoty proměnné
Console.WriteLine("Inkrementace i: {0}", i);

Kód 4: Příklad prefixové inkrementace proměnné

Na následujícím výpis v konzoli vidíme, že už vše funguje tak, jak požadujeme – viz Výstup programu - Kód 4. V prvním řádku se vypsala hodnota proměnné, kde byla provedena inkrementace o 1. 

Inkrementace i: 1
Inkrementace i: 1

Výstup programu - Kód 4: Ukázka výsledku prefixové inkrementace 

A co to vše znamená? Jednoduchou poučku, vždy je nutné sledovat pořadí operandu a operátoru. Operátory inkrementace a dekrementace jsou zejména využívány v cyklech.

Na závěr této kapitoly si pojďme vyjmenovat prioritu jednotlivých skupin operátorů, podle toho, jak budou v C# postupně vykonávány – viz Tabulka 3.

Tabulka 3: Operátory – priorita vykonávání

13. Konstanta

Protějšek k pojmu proměnná je konstanta. Pro konstanty platí stejná pravidla jako pro proměnné s jedinou výjimkou, při definici konstanty ji přiřadíme hodnotu, kterou již nemůžeme nikdy za běhu programu měnit. [8]

Konstantu lze deklarovat následujícím způsobem:

const datovýTyp identifikátorKonstanty = hodnota;

kde:

• const - klíčové slovo
• datovýTyp - představuje datový typ konstanty
• = .. operátor přirazení
• hodnota - hodnota jež nabývá konstanta

V následujícím kódu nalezneme, jak deklarovat konstantu včetně její inicializace – viz Kód 1. Jak si můžete všimnout, v dalším řádku kódu se pokoušíme o změnu hodnoty v této konstantě. Překladač však hlásí chybu, že nelze na levou stranu nelze umístit konstantu. Toto hlášení je samozřejmě v pořádku, protože jinak by byla popřena podstata konstanty.

//Deklarace konstanty typu double včetně její inicializace
const double doubleKonstanta = 0.21;
//Operaci přiřazení nelze provést -> K.O.
doubleKonstanta = 0.15;

Kód 1: Příklad deklarace konstanty typu double a její inicializace

14. Stručné shrnutí

//Toto je komentář

int promenna;

int promenna = 1;

promenna = 13;

System.Int32.Parse("15");

int.Parse("15");

promenna = int.Parse(Console.ReadLine());

Console.WriteLine("Hodnota: " + Convert.ToString(promenna));

Console.WriteLine("Hodnota: {0}", promenna);

(3 + 4) * 5

promenna = promenna2 = promenna3 = 17;

promenna++;

promenna += hodnota;

const double konstanta = 0.21;