C#-ban hogyan hívom meg a Main metódust?

Hát nem rossz ez a gonosz manós magyarázat :) De én megpróbálom kicsit szakmaibban(nem nagyon :)) a hátterét is megvilágítani, h. miért nem helyes ez. Előre bocsátom(mielőtt a "szakik" belém kötnek :)), hogy a nem tökéletesen fedi a valóságot, de a megértéshez jó lesz.

Először is, tudni kell, mi történik, amikor meghívsz egy függvényből(A) egy másikat(B):

Ilyenkor a CPU utasítás-mutatója egy másik helyre ugrik a memóriában(B függvény címére), és az ott lévő kódot hajtja végre a proci. Ahhoz, hogy a függvény befejeződése után a program folytatódni tudjon, meg kell valahogy jegyezni, hogy melyik memória-címen lévő utasítást kell végrehajtani, miután a hívott függvény véget ért.

Továbbá: a hívó függvény(A) paramétereit és lokális változóit is el kell tárolni, hogy visszaállítható legyen a hívó függvény(A) contextusa.

Ezeknek az adatoknak az eltárolására használják a stack adatszerkezetet, ami úgy működik, hogy amit legutoljára betettél, azt veheted ki legelőször, tehát mint egy torony, amit építőkockákból raksz össze. Csak azt tudod levenni, amit legutoljára felraktál, ha hozzá akarsz férni a legalsóhoz, le kell venned a tetejéről az összeset.

Egy programnak azt a memória-területét, ahol a függvény-hívások adatait tárolják, call stack-nek hívják.

Ezt tekintsük egy fix méretű memória-területnek(tehát korlátos).

Tehát, van A függvényed, van két paramétere, int x, és int y:

void A(int x, int y)

{

int a = x+y;

B();

a = x*y;

}

void B()

{

//végrehajt valamit

return;

}

Amint látható, az A hívja B-t, majd utána még elvégez vmilyen műveletet.

A hívás pillanatában az történik, hogy A függvény berakja a call stack-be az a = x*y; utasítás címét, valamint x, y, és a értékét.

tehát, a call stack így néz ki:

a értéke

y értéke

x értéke

Az "a = x*y;" címe

Lefut a B függvény, a return utasítás hatására a hívó függvény kiveszi a stack tetején lévő értéket(a értéke), és beleteszi az a változóba. Megint kiveszi a verem tetején lévő értéket(ami mostmár y értéke), és belerakja y-ba, stbstb., végülis kiveszi az utolsó elemet is, és a CPU utasítás-mutatóját ráállítja arra az értékre, így az a = x*y; utasításnál folytatódik a végrehajtás.

Innentől már nyilvánvaló a dolog, hogy ha végtelen rekurzív hívást(azaz a függvény önmagát hívja) csinálsz, az folyamatosan csak rakja bele a stack-be az adatokat, de sosem vesz ki belőle semmit, aminek egyenes következménye, hogy előbb-utóbb betelik a stack, és már nem lesz hova rakni a dolgokat, és szépen elszáll a program.