A programok megírásához elengedhetetlen az alapvető vezérlési szerkezetek ismerete.

Ezek a vezértlési szerkezetek a programok alap építőkövei. Segítségükkel bármely probléma megoldható, és a legtöbb programozási nyelv majdnem ugyanolyan formában tartalmazza őket.

A legyegyszerűbb vezérlési szerkeze az alágazás. Ennek segítségével egy feltétel alapján a program futás közben képes eldönteni, hogy az egyik, vagy másik műveletsort hajtsa végre.

C#-ban a feltételes elágazás az if(...) utasítással van megoldva, melynek formája.

if(feltétel) {
    // Mit kell csinálni, ha igaz a feltétel.
}

A feltételes alágazás legyegyszerűbb fogmája a fenti, ahol egy feltételhez kötjük, hogy a program egy része lefusson-e. A fenti kódban ha a feltetel igaz, akkor lefut a kapcsos zárójelek közötti rész. Ha a feltétel nem teljesül, akkor viszont a kapcsos zárójelek közötti rész kimarad és a program az utána következő résszel folytatódik.

Például

int a = 5;

if(a < 10)
{
    Console.WriteLine("kisebb, mint 10");
}

a = 20;

if (a < 10)
{
    Console.WriteLine("kisebb, mint 10");
}

A fenti kódban az első feltétel igaaz lesz, tehát kiírjuk a szöveget. A második felétetl viszont hamis, így a kiírás elmarad.

A feltételes elágazásnak lehet különben ágat ei adni, ami akkor futle, ha a feltétel nem igaz. Így a program két lehetséges út közül választhat, hogy melyik műveletsort hajtsa végre.

A fenti példánk kiegészítve az alábbi módon néz ki.

int a = 5;

if(a < 10)
{
    Console.WriteLine("kisebb, mint 10");
} else {
    Console.WriteLine("nagyobb, mint 10");
}

Ilyen esetekben a programo futása közben az dől el, hogy a számítógépe a programnak az egyik, vagy a másik "ágát" hajtsa végre.

A C#-ban a feltételek számos formában előállhatnak. A lentiekben megnézzük a leggyakrabba nhasznált formákat. Ehhez viszont legyen néhány változónk.

int a=0;
int b=10;
int c=-2;
bool d = true;
bool e = false;

bool eredmeny;

Feltétel keletkezhet értékek összehasonlításából:

eredmeny = a < b; // kisebb (eredménye most igaz)
eredmeny = a > b; // nagyobb (eredménye most igaz)
eredmeny = b == b; // egynelőek-e (eredménye most hamis)
eredmeny = b <= c; // kisebb, vagy egyenlő (eredménye most hamis)
eredmeny = b >= c; // nagyobb, vagy egyenlő (eredménye most hamis)
eredmeny = a != c; // nem egyenlő (eredménye most igaz)

A relációkkal kapcsolatban fontos, hogy megkülönbözteünk kétféle egyenlőséget. Az egy egyenlőség jel "=" az értékadást jelenti, segítségével érteket adunk egy változónak. A dupla egyenlőség jel "==" jelenti az egyenlőség logikai ellenőrzését, ennek az eredménye egy igaz/hamis érték.

Tovább haladva a logikai értékek érkezhetnek még igaz/hamis értékek kombinációjából.

eredmeny = !d; // negáció (ami !igaz, az hamis)
eredmeny = d || e; // logikai "vagy": ha az egyik oldala igaz, akkor igaz (eremdény itt igaz)
eredmeny = d || e; // logikai "és": csak akkor igaz, ha mind a két oldala igaz (eremdény itt hamis)

A logikai operátorokkal kapcsolatban fontos megjegyezni, hogy minden esetben duplán állnak, és két logikai értéket kötnek össze.

Végezetül pedig fontos tudni, hogy a számokat is használhatjuk logikai érték-ként. Ennek számos oka van, de most csak fogadjuk el, hogy így van. Egy szám logikai értéke hamis, ha a konkrét felvett értéke 0. Az igaz érték pedig a nem hamis, vagyis minden más érték amin különbözik a 0-től.

if(a) {...} // ez hamis, mert a == 0
if(b) {...} // ez igaz, mert b ==10, vagyis nem 0.
if(c) {...} // ez is igaz

A programok futása közben előfordul az is, hogy egy feladatot többször kell elvégezni. Ezt segítik elő a ciklusok. A ciklusokban ugyanaz a kód fut le többször valamilyen feltétellel.

A legegyszerűbb példa erre az egyszerű "while" ciklus, ami az alábbi módon épül fel.

while(feltétel)
{
    // mi kell csinálni
}

Ezen a nyomon haladva az alábbi program 5-ig számol el.

int i = 1;

while(i <= 5)
{
    Console.WriteLine(i);
    i = i+1;
}

A felni kód azárt 5-ször fut le, mert a feltételnek azt adtuk, hogy az i<=5. Ezt azt jelenti, hogy a ciklus addig fut amig az i túl nem lép az 5-ös értéken. Ha ez megtörtént, akkor a ciklis megáll, és az utána következő utasításra lép tovább a program. Mivel az i-t a cikluson belül folyamaosan növeljük, az értéke előbb utóbb eléri az 5-öt.

Fontos viszont, hogy a ciklusok írásakor figyelnnük kell a feltételek megfelelő teljesülésére.

int i = 1;

while(i <= 5)
{
    Console.WriteLine(i);
}

A fenti kódban például az i értékének növelése elmarad. Ez azt eredményezi, hogy az i értéke mindig 0 marad, a ciklus pedig nem éri el a megállási feltételét, tehát a végtelenségig fut. Ezt a jelenséget "végtelen ciklusnak" nevezzük és általában kerülendő a készítése.

Sok esetben előfordul hogy a ciklus magját adott számszor kell lefuttatnunk. A felnti példa is etz csinálta, a ciklus magja pontosan 5-ször futott le.

Ilyen esetekre külön megoldás van a kezünkben, amit számlálásos vezérlésnek, vagy "for ciklus"-nak is nevezünk. A ciklus kinézete a következő:

for(kezdőfeltétel ; megállási feltétel ; növekmény) {
    // mit kell csinálni
}

Bár a fenti konsstrukciót többféle célra lehet használni általában úgy szoktuk kezelni, hogy a segítsgével elszámolunk valamettől valameddig.

int i;

for(i=1; i<=5; i++) {
    Console.WriteLine(i);
}

A fenti kód ugynazt csinálja mint a korábbi példa kódrészlet, csak tömörebb, átláthatóbb formában dolgozik.

A for ciklusnak sokféle felhasználása lehet még a fentin kivíül. Számolhaunk vele 0-tól kettesével 10-ig is.

int i;

for(i=0; i<=10; i+=2) {
    Console.WriteLine(i);
}