Hello World.

namespace HelloWorld // A namespace (névtér) összefogja és elkülöníti az ide tartozó kódelemeket; a HelloWorld ennek a névtérnek a neve.
{ // A nyitó kapcsos zárójel jelzi, hogy itt kezdődik a HelloWorld névtérhez tartozó kódblokk.
    internal class Program // Az internal azt jelenti, hogy ez az osztály ezen a programon/assemblyn belül érhető el; a class új osztályt definiál, amelynek neve Program.
    { // Itt kezdődik a Program osztály törzse, vagyis minden, ami ehhez az osztályhoz tartozik.
        static void Main(string[] args) // A Main a program belépési pontja; a static miatt példány létrehozása nélkül fut, a void azt jelenti, hogy nem ad vissza értéket, a string[] args pedig a parancssori argumentumokat tartalmazó szövegtömb.
        { // Itt kezdődik a Main metódus kódblokkja; a program indulásakor az ebben lévő utasítások hajtódnak végre.
            Console.WriteLine("Hello, World!"); // A Console a konzollal való kommunikációra szolgáló osztály, a WriteLine kiírja a megadott "Hello, World!" szöveget, majd új sort kezd; a ; lezárja az utasítást.
            Console.ReadKey(); // A ReadKey megvárja, hogy a felhasználó lenyomjon egy billentyűt; így például a konzolablak nem záródik be azonnal. A ; itt is az utasítás végét jelzi.
        } // Ez a záró kapcsos zárójel lezárja a Main metódus kódblokkját.
    } // Ez a záró kapcsos zárójel lezárja a Program osztály törzsét.
} // Ez az utolsó záró kapcsos zárójel lezárja a HelloWorld névteret.

/*
 * internal class Program
 * ----------------------
 *
 * Ez a sor egy Program nevű osztályt hoz létre.
 *
 * A felépítése:
 *
 *     internal   class   Program
 *        ↓         ↓        ↓
 *   hozzáférés   típus    az osztály
 *   módosító     megadása    neve
 *
 * Az "internal" egy hozzáférési módosító (access modifier).
 * Azt mondja meg, hogy honnan lehet elérni az adott osztályt.
 * Az internal jelentése: az osztály az adott assemblyn, vagyis leegyszerűsítve
 * az adott lefordított programon/projekten belül használható.
 *
 * A "class" kulcsszó azt jelzi a C# fordítónak, hogy egy osztályt definiálunk.
 * Az osztály egy olyan egység, amely adatokat és az azokkal dolgozó
 * metódusokat foghat össze.
 *
 * A "Program" egyszerűen az osztály neve.
 * Ezt a nevet mi adjuk meg, tehát lehetne például:
 *
 *     internal class Auto
 *     internal class Diak
 *     internal class Szamologep
 *
 * Az osztályhoz tartozó tartalom a név után következő { } kapcsos
 * zárójelek között helyezkedik el:
 *
 *     internal class Auto
 *     {
 *         // Az Auto osztályhoz tartozó kód kerül ide.
 *     }
 *
 * Általánosan tehát egy osztály deklarációja például így képzelhető el:
 *
 *     [hozzáférési módosító] class [osztály neve]
 *
 * Például:
 *
 *     public class Ember
 *     {
 *     }
 *
 * A "public" az internalhoz hasonlóan hozzáférési módosító, de azt jelenti,
 * hogy az osztály más assemblykből/projektekből is elérhető lehet.
 */


/*
 * static void Main(string[] args)
 * -------------------------------
 *
 * Ez egy Main nevű metódus deklarációja. Konzolos C# programoknál
 * a Main hagyományosan a program belépési pontja: innen indul
 * a saját programkódunk végrehajtása.
 *
 * A felépítése:
 *
 *     static   void   Main   (string[] args)
 *       ↓       ↓       ↓          ↓
 *   módosító  vissza-  metódus    paraméter
 *             térési    neve
 *              típus
 *
 * A "static" azt jelenti, hogy a Main metódus magához a Program
 * osztályhoz tartozik, és a meghívásához nem kell előtte létrehozni
 * egy Program típusú objektumot.
 *
 * A "void" a metódus visszatérési típusa.
 * A void jelentése: ez a metódus nem ad vissza értéket.
 *
 * Más metódus például visszaadhat egy egész számot:
 *
 *     static int Osszead(int a, int b)
 *     {
 *         return a + b;
 *     }
 *
 * Itt az "int" azt jelenti, hogy a metódus egy egész számot ad vissza.
 * A Main esetében a "void" miatt nincs ilyen visszaadott érték.
 *
 * A "Main" a metódus neve.
 * Ez itt különleges név, mert a C# futtatókörnyezet ezt használhatja
 * a program belépési pontjaként.
 *
 * A metódus neve után található ( ) zárójelben vannak a paraméterek:
 *
 *     string[] args
 *
 * Ez két részből áll:
 *
 *     string[]   args
 *        ↓        ↓
 *      típus     név
 *
 * A "string" szöveges adattípust jelent.
 * A [] azt jelenti, hogy nem egyetlen stringről, hanem stringek tömbjéről van szó.
 * Az "args" ennek a változónak a neve. Az "args" az "arguments"
 * (argumentumok) szó rövidítése.
 *
 * Ebben a tömbben kaphatja meg a program a parancssorból átadott adatokat.
 * Ha például a programot így indítanánk:
 *
 *     Program.exe alma körte
 *
 * akkor leegyszerűsítve:
 *
 *     args[0] -> "alma"
 *     args[1] -> "körte"
 *
 * A Main után következő { } kapcsos zárójelek között található maga
 * a metódus törzse, vagyis azok az utasítások, amelyeket végre akarunk hajtani:
 *
 *     static void Main(string[] args)
 *     {
 *         Console.WriteLine("Hello!");
 *         Console.WriteLine("Ez már a Main metódus törzse.");
 *     }
 *
 * Egy metódus deklarációjának általánosított formája például:
 *
 *     [módosító] [visszatérési típus] [metódus neve]([paraméterek])
 *
 * Például:
 *
 *     static int Negyzet(int szam)
 *     {
 *         return szam * szam;
 *     }
 *
 * Ebben:
 *     static  -> a metódus az osztályhoz tartozik
 *     int     -> egész számot ad vissza
 *     Negyzet -> a metódus neve
 *     int     -> a paraméter típusa
 *     szam    -> a paraméter neve
 */

namespace HelloWorld
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
            Console.ReadKey();
        }
    }
}