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

Nekem működik úgy is, ha simán beírom, hogy "Main();", persze ha a Main argumentumait kitörlöm.

static void Main()

{

char c = Convert.ToChar(Console.ReadLine());

if(c == 'Y')

{

Main();

}

}

Egyébként ilyen esetekben do-while-lal is érdemes megpróbálkozni.

char c;

do

{

c = Convert.ToChar(Console.ReadLine());

}while(c == 'Y');

Ilyen esetben a végtelenségig bekéri a karaktert, amíg Y-t adsz meg, ha mást, akkor pedig kilép.

Pont ezért írtam, hogy a Main argumentumait töröld ki.

"static void Main(string[] args)"-ből legyen:

"static void Main()"

"Pont ezért írtam, hogy a Main argumentumait töröld ki.

"static void Main(string[] args)"-ből legyen:

"static void Main()""

1. Mert ha vannak argumentumai, akkor nem lehet meghívni? :D

2. Totál szar megoldás a Main-t újra meghívni, mert akkora stack overflow lesz belőle egy idő után, hogy csak na.

Simán while ciklus a jó megoldás.

A stack overflow valójában nem esélyes, ha a user-en múlik, hogy folytassa, vagy nem, mert többezerszer kellene Y-t nyomnia, hogy gond legyen.

DE: algoritmikailag a while ciklus a jobb ;o)

1. Ha sok lokális változóval dolgozik, nem szükséges több 1000 hívás egy stack overflow-hoz, akár néhány száz is elég lehet.

2. Ettől függetlenül is, ha egy olyan programról beszélünk, ami mondjuk nem egy házifeladat-program, vagy hobbi-programozás, akkor simán esélyes, hogy több ezres mélységű rekurzió összejön, pl. Marika néni a hivatalban napi 8-10 órában adatokat vesz fel, akkor könnyen összejöhet.

Szóval szerintem nem kéne neki hülyeségeket javasolni, mert ha ezt szokja meg, és még nem is érti, amit csinál, akkor az első munkahelyén elég gyorsan megkérik, hogy csukja be az ajtót kívülről. És ott már NEM fogják elmagyarázni neki, hogy "öcsém, te azért lettél kirúgva, mert main függvényből rekurziót csináltál"..

Félreértés ne essék: egyáltalán nem szándékoztam azt sugallni, hogy a rekurzió itt okos dolog. Arra szerettem volna felhívni a figyelmet, hogy a stack overflow rémképe túlzás.

Magyarázat:

Sokat segít, ha a függvényhívást nem úgy képzeljük el, hogy odaugrik a vezérlés a függvény elejére, hanem úgy, hogy egy szinttel mélyebben elkezdünk valami egész mást. Ha annak a "más"-nak a legvége előtt mindig egyre mélyebbre és mélyebbre megyünk, akkor sosem térünk vissza. Ebből adódik a (garantált) stack overflow.

Jelen esetben attól tesszük függővé, hogy lesz-e stack overflow vagy nem, hogy mit mond a felhasználó.

Ilyenkor kell elővenni a gonosz manót.

A gonosz manó olyan segítség, hogy mindig a lehető legrosszabb dolgot teszi egy bizonyos szempontból. Elméleti teszteléshez kitűnő. ;o)

Jelen esetben például mindig Y-t nyom, tehát egy türelmes gonosz manó 100-1000 hívásból le tudja hidaltatni a programunkat.

Mindamellett Marinéni, aki nem gonosz és nem manó, nem fogja kiborítani a programot szándékosan. (Maximum, ha véletlenül a sodrófát ráejti az Y-ra, ami beragad és kész is a baj.)

Viszont akkor érezhetjük úgy, hogy megoldottunk egy programozási feladatot, ha végiggondoltuk az összes típusú gonosz manót (meg Marinénit) és egyik sem tud pirosikszet készíteni a programunkból.

És a do-while ciklussal ez teljesül. ;o)

Tehát aki hobbiszinten programozik, annak is inkább a do-while ciklust javaslom, hiszen az az algoritmikailag helyes megoldás. És ahhoz, hogy programozni tudjon akár hobbiszonten is, szükséges az algoritmizálást is elsajátítania.