Konzolkezelés.

namespace Konzolkezeles // A namespace (névtér) összefogja és elkülöníti az ide tartozó kódelemeket; ennek a névtérnek a neve Konzolkezeles.
{ // A nyitó kapcsos zárójel jelzi, hogy itt kezdődik a Konzolkezeles névtérhez tartozó kódblokk.
    internal class Program // Az internal azt jelenti, hogy ez az osztály ezen az assemblyn belül érhető el; a class egy Program nevű osztályt definiál.
    { // Itt kezdődik a Program osztály törzse.
        static void Main(string[] args) // A Main a program belépési pontja; static: példány nélkül futtatható, void: nem ad vissza értéket, string[] args: parancssori argumentumok tömbje.
        { // Itt kezdődik a Main metódus törzse.
            // Console osztály – a konzolos be- és kimenet kezelésére használható beépített .NET-osztály.

            // KIÍRÁS – adatok megjelenítése a konzolablakban.
            Console.Write("Hello, World! Nincs mögött Enter"); // Kiírja a szöveget, de a végén nem kezd új sort; a következő kiírás ugyanazon a soron folytatódik.
            Console.WriteLine("Hello World! Enterrel a végén"); // Kiírja a szöveget, majd új sort kezd.
            Console.WriteLine("Entert lehet rakni \na szöveg közepére is"); // A \n escape szekvencia sortörést helyez a szöveg közepére, ezért a szöveg két sorban jelenik meg.

            // BEKÉRÉS – adatok beolvasása a felhasználótól.
            Console.Write("Kérek egy szöveget: "); // Kiír egy bekérő üzenetet új sor kezdése nélkül, így a felhasználó ugyanabban a sorban gépelhet.
            string szöveg = Console.ReadLine(); // A ReadLine() egy teljes sort olvas be Enterig, és a beolvasott szöveget adja vissza; ezt a szöveg nevű string változóban tároljuk.

            ConsoleKeyInfo beolvasottKarakter = Console.ReadKey(); // A ReadKey() egy billentyűleütést olvas be és ConsoleKeyInfo típusú értéket ad vissza, amely nemcsak a karaktert, hanem a billentyűvel kapcsolatos további adatokat is tartalmaz.
            char karakter = beolvasottKarakter.KeyChar; // A ConsoleKeyInfo objektum KeyChar tulajdonságából kivesszük a lenyomott billentyűhöz tartozó karaktert, és egy char változóban tároljuk.

            // Ugyanez egy lépésben is elvégezhető:
            char másikKarakter = Console.ReadKey().KeyChar; // A ReadKey() visszatérési értékének KeyChar tulajdonságát közvetlenül elérjük, ezért nincs szükség külön ConsoleKeyInfo változóra.

            // VÁLTOZÓ KIÍRÁSA – 1. módszer: összetett formázás (composite formatting).
            Console.WriteLine("A szöveg változó tartalma: {0}", szöveg); // A {0} helyére a vessző után megadott első érték, vagyis a szöveg változó tartalma kerül.
            int a = 12; // Létrehozunk egy int típusú, a nevű változót, és 12 kezdőértéket adunk neki.
            int b = 23; // Létrehozunk egy int típusú, b nevű változót, és 23 kezdőértéket adunk neki.
            Console.WriteLine("{0} + {1} = {2}", a, b, a + b); // A {0}, {1}, {2} helyőrzők rendre az a, b és a+b kifejezés értékét kapják.

            // VÁLTOZÓ KIÍRÁSA – 2. módszer: string interpoláció.
            Console.WriteLine($"{a} + {b} = {a + b}"); // A $ jellel interpolált stringet hozunk létre; a { } között változók és kifejezések értékei közvetlenül beilleszthetők a szövegbe.
        } // Ez a záró kapcsos zárójel lezárja a Main metódus törzsét.
    } // Ez a záró kapcsos zárójel lezárja a Program osztályt.
} // Ez az utolsó záró kapcsos zárójel lezárja a Konzolkezeles névteret.


/*
 * A Console OSZTÁLY
 * -----------------
 *
 * A Console egy beépített .NET-osztály, amelyen keresztül konzolos
 * programokban adatokat írhatunk ki és adatokat olvashatunk be.
 *
 * Gyakori metódusai:
 *
 *     Console.Write(...)
 *     Console.WriteLine(...)
 *     Console.ReadLine()
 *     Console.ReadKey()
 *
 * A felépítés például:
 *
 *     Console   .   WriteLine   ("Hello!");
 *        ↓              ↓            ↓
 *     osztály        metódus       argumentum
 *
 * A pont (.) tagelérési operátor. Azt jelzi, hogy a Console
 * osztály valamely tagját – jelen esetben egy metódusát – használjuk.
 */


/*
 * Console.Write() ÉS Console.WriteLine()
 * --------------------------------------
 *
 * Mindkettő adatot ír a konzolra.
 *
 *     Console.Write("Hello");
 *
 * A Write a kiírás után nem kezd új sort.
 *
 *     Console.WriteLine("Hello");
 *
 * A WriteLine a kiírás végén új sort kezd.
 *
 * Például:
 *
 *     Console.Write("Anna");
 *     Console.Write(" Béla");
 *
 * eredménye:
 *
 *     Anna Béla
 *
 * míg:
 *
 *     Console.WriteLine("Anna");
 *     Console.WriteLine("Béla");
 *
 * eredménye:
 *
 *     Anna
 *     Béla
 *
 * A WriteLine névben a "Line" arra utal, hogy a kiírás után
 * lezárja az aktuális sort.
 */


/*
 * ESCAPE SZEKVENCIÁK A STRINGBEN
 * ------------------------------
 *
 * Bizonyos speciális karaktereket backslash (\) segítségével írunk le.
 *
 * Például:
 *
 *     "\n"  -> újsor
 *     "\t"  -> tabulátor
 *     "\""  -> dupla idézőjel
 *     "\\"  -> backslash
 *
 * Ezért:
 *
 *     Console.WriteLine("Első sor\nMásodik sor");
 *
 * eredménye:
 *
 *     Első sor
 *     Második sor
 *
 * Fontos: a \n a string része. Nem maga a WriteLine teszi oda,
 * hanem a szövegben található escape szekvencia.
 */


/*
 * Console.ReadLine()
 * ------------------
 *
 * A ReadLine egy teljes sort olvas be a konzolról.
 *
 *     string szöveg = Console.ReadLine();
 *
 * A felépítése:
 *
 *     string    szöveg     =     Console.ReadLine();
 *       ↓          ↓       ↓            ↓
 *     típus     változó  értékadó   visszaad egy
 *                neve    operátor    beolvasott sort
 *
 * A program a felhasználó által begépelt karaktereket addig olvassa,
 * amíg a felhasználó Entert nem nyom.
 *
 * Például ha a felhasználó ezt írja:
 *
 *     Alma körte
 *
 * akkor a szöveg változó értéke:
 *
 *     "Alma körte"
 *
 * A ReadLine nem intet vagy double-t ad vissza, hanem szöveget.
 * Ha számot kérünk be, azt később számmá kell alakítani.
 *
 * Például:
 *
 *     string beolvasott = Console.ReadLine();
 *     int szám = int.Parse(beolvasott);
 *
 * Modern, bekapcsolt nullable referencia-típusok mellett a ReadLine()
 * visszatérési típusa string? lehet, mert elméletileg null értéket is
 * adhat vissza, ha nincs több bemenet. Kezdő konzolos példáknál ezt
 * gyakran egyszerűsítve stringként kezeljük.
 */


/*
 * Console.ReadKey() ÉS ConsoleKeyInfo
 * -----------------------------------
 *
 * A ReadKey nem egy teljes sort, hanem egyetlen billentyűleütést olvas be.
 *
 *     ConsoleKeyInfo beolvasottKarakter = Console.ReadKey();
 *
 * Fontos:
 *
 *     Console.ReadKey()
 *
 * nem char értéket ad vissza, hanem ConsoleKeyInfo típusú értéket.
 *
 * A ConsoleKeyInfo több információt tartalmazhat a billentyűleütésről:
 *
 *     KeyChar   -> a karakter
 *     Key       -> melyik billentyű volt
 *     Modifiers -> például Shift, Alt vagy Ctrl
 *
 * Ha csak a karakterre van szükségünk:
 *
 *     char karakter = beolvasottKarakter.KeyChar;
 *
 * A felépítése:
 *
 *     beolvasottKarakter   .   KeyChar
 *              ↓                  ↓
 *       ConsoleKeyInfo         tulajdonság
 *          érték
 *
 * A pont (.) segítségével érjük el az objektum egyik tulajdonságát.
 */


/*
 * LÁNCOLT TAGELÉRÉS: Console.ReadKey().KeyChar
 * --------------------------------------------
 *
 * A kétlépéses változat:
 *
 *     ConsoleKeyInfo adat = Console.ReadKey();
 *     char karakter = adat.KeyChar;
 *
 * összevonható:
 *
 *     char karakter = Console.ReadKey().KeyChar;
 *
 * Mi történik?
 *
 *     Console.ReadKey()
 *            ↓
 *     visszaad egy ConsoleKeyInfo értéket
 *
 *     Console.ReadKey().KeyChar
 *                       ↓
 *           ebből azonnal lekérjük
 *           a KeyChar tulajdonságot
 *
 * Ez gyakori programozási minta: egy metódus visszatérési értékének
 * valamely tagját közvetlenül használjuk.
 */


/*
 * ÖSSZETETT FORMÁZÁS: {0}, {1}, {2}
 * ---------------------------------
 *
 * A Console.WriteLine egyik használati módja:
 *
 *     Console.WriteLine("Név: {0}", név);
 *
 * A kapcsos zárójelekben szereplő számok helyőrzők.
 *
 *     {0} -> az első megadott érték
 *     {1} -> a második megadott érték
 *     {2} -> a harmadik megadott érték
 *
 * Például:
 *
 *     int a = 12;
 *     int b = 23;
 *
 *     Console.WriteLine("{0} + {1} = {2}", a, b, a + b);
 *
 * megfeleltetése:
 *
 *     {0} -> a     -> 12
 *     {1} -> b     -> 23
 *     {2} -> a+b   -> 35
 *
 * A kiírt eredmény:
 *
 *     12 + 23 = 35
 *
 * A helyőrzők sorszámozása 0-val kezdődik.
 */


/*
 * STRING INTERPOLÁCIÓ
 * -------------------
 *
 * Modern C# kódban nagyon gyakori a string interpoláció:
 *
 *     Console.WriteLine($"{a} + {b} = {a + b}");
 *
 * Az interpolált stringet a szöveg előtti $ jelzi:
 *
 *     $"..."
 *
 * A { } között közvetlenül C# kifejezéseket írhatunk:
 *
 *     $"{a}"
 *     $"{b}"
 *     $"{a + b}"
 *
 * Ezek helyére futás közben a kifejezések eredménye kerül.
 *
 * Például:
 *
 *     string név = "Anna";
 *     int kor = 17;
 *
 *     Console.WriteLine($"{név} {kor} éves.");
 *
 * eredménye:
 *
 *     Anna 17 éves.
 *
 * A két módszer tehát:
 *
 *     Console.WriteLine("{0} + {1} = {2}", a, b, a + b);
 *
 * és:
 *
 *     Console.WriteLine($"{a} + {b} = {a + b}");
 *
 * ugyanazt az eredményt adhatja, de az interpoláció sok esetben
 * könnyebben olvasható.
 */


/*
 * METÓDUSHÍVÁS, ARGUMENTUM ÉS VISSZATÉRÉSI ÉRTÉK
 * -----------------------------------------------
 *
 * Példa:
 *
 *     Console.ReadLine()
 *
 * Ez egy metódushívás.
 *
 * A () jelzi, hogy meghívjuk a metódust.
 * A ReadLine nem kap argumentumot, ezért a zárójelek üresek.
 *
 * Másik példa:
 *
 *     Console.WriteLine("Hello!");
 *
 * Itt a "Hello!" a WriteLine metódusnak átadott argumentum.
 *
 * Egy metódus vissza is adhat értéket:
 *
 *     string szöveg = Console.ReadLine();
 *
 * Ebben az esetben a ReadLine által visszaadott értéket eltároljuk
 * a szöveg változóban.
 *
 * Ez a minta nagyon gyakori:
 *
 *     [változó] = [valamilyen értéket visszaadó metódushívás];
 */

namespace Konzolkezeles
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Hello, World! Nincs mögött Enter");
            Console.WriteLine("Hello World! Enterrel a végén");
            Console.WriteLine("Entert lehet rakni \na szöveg közepére is");

            Console.Write("Kérek egy szöveget: ");
            string szöveg = Console.ReadLine();

            ConsoleKeyInfo beolvasottKarakter = Console.ReadKey();
            char karakter = beolvasottKarakter.KeyChar;

            char másikKarakter = Console.ReadKey().KeyChar;

            Console.WriteLine("A szöveg változó tartalma: {0}", szöveg);
            int a = 12;
            int b = 23;
            Console.WriteLine("{0} + {1} = {2}", a, b, a + b);

            Console.WriteLine($"{a} + {b} = {a + b}");
        }
    }
}