A C# programozási nyelv

Utasítások, vezérlési szerkezetek

A vezérlési szerkezetek - blokkok, elágazások, ciklusok - szintaktikája megegyezik a C++-ban megszokottakkal. Apró szemantikai különbség, hogy a feltételek típusa bool, nem pedig int. Érdekesség, hogy – bár erős megszorításokkal, de - van goto is.

Értékadás, üres utasítás

Mint c++ -ban.

Szekvencia

; -vel elválasztva.

Elágazás

if

// Rövid alak, ha csak egy-egy utasítás van
if (feltétel) utasítas1;
[else utasítás2];

// Ha nem cska egy-egy utasítás van
if (feltétel){
utasítasok1
}
[else{
utasítások2
}]

A feltétel igaz kiértékelés mellett az utasítások1 blokkot hajtja végre, létező else ág esetén false érték esetén az utasítások2 blokkot.

 

else if

A nyelvben nincs elif vagy elseif kifejezés, ezt így oldhatjuk meg :
 

if (feltétel){
utasítasok1
}
else if(feltétel1){
utasítások2
}
else if(feltétel2){
utasítások2
}

// ...

else if(feltételn){
utasításokn
}
[else {
utasítások2
}]

Lényegében itt egymásba ágyazott elágazásokról van szó.

switch

switch (kifejezés){
case konstans_kif: utasítások; ugró_utasítás;
[default: utasítások; ugró_utasítás]
}

A switch szerkezettel többször elágazás valósítható meg, ha a kifejezés egész vagy string típusú. a futás ahhoz a case blokkhoz kerül, ahol a kifejezés megegyezik a megadott konstans kifejezéssel. a blokk végrehajtása végén ugró utasítás meghatározza a következő blokk végrehajtását. Ezt mindig meg kell adni, ami vagy egy másik case blokk, vagy a default ág.

Ciklus

for

for([init_rész],[kifejezés],[léptetés]) utasítás/blokk;

A for utasítással lehet a ciklust megvalósítani. Az inicialízációs részben kell a változó(ka)t (vesszővel elválasztva, ha több van) kezdeti értékre állítani, a léptetés részben kell változtatni az értéküket. A ciklus addig tart, amíg a kifejezés értéke hamis nem lesz. Futtatási sorrend: init_rész, kifejezés kiértékelés, ha igaz utasítás/blokk, majd léptetés, és ismétlés a kifejezés kiértékeléstől.

foreach

Újdonság a foreach(típus azonosító in collection) törzs alakú szerkezet, mellyel egy olyan objektum elemeit járhatjuk be, amelyek az IEnumerable iterface-t valósítják meg. Az azonosítóval jelölt változó tartalma a végrehajtás során éppen aktuális elemet tartalmazza, azaz egy iterátor. Fontos, hogy ez a változó nem módosítható illetve nem adható át ref, valamint out paraméterként.

double[,] values = { {1.2, 2.3, 3.4, 4.5}, {5.6, 6.7, 7.8, 8.9}};
foreach (double elementValue in values)
{
        Console.Write("{0} ", elementValue); // -> 1.2 2.3 3.4 4.5 5.6 6.7 7.8 8.9
}

A foreach vezérlési szerkezete valójában úgy működik, hogy meghívja a végigjárandó osztály GetEnumator() függvényét, ami visszaad egy bejárót. Tehát a foreach nem más, mint egy while ciklus, csak ügyesen szervezve.

// Implementáció

ArrayList list = new ArrayList();

// ...

foreach(object obj in list)
{
DoSomething(obj);
}

// A fordított átmeneti kód

Enumerator e = list.GetEnumerator();

while(e.MoveNext())
{
object obj = e.Current;
DoSomething(obj);
}

A C# 2.0-ban az iterátor már nem ilyen erőltetetten van megvalósítva. A foreach-nak a feltétele csupán egy GetEnumerator() függvény megléte. Igaz, ez egy speciális függvény, mivel a visszatérési értékének IEnumerator<> -nak kell lennie, a <> között pedig az értékek típusával. A függvényben a visszatérési kulcsszót (return) a yield kulcsszó helyettesíti. A kulcsszó az értékeket ismétlődően adja vissza. A fordító ezekből egy jóldefiniált felsorolási típust készít.

Példa:

public class Names
{
private List<string> names = new List<string>();
public Names()
{
this.names.Add("John");
this.names.Add("Smith");
this.names.Add("Franklin");
}

public IEnumerator<string> GetEnumerator()
{
for(int i = 0; i < this.names.Count; i++)
{
    yield return this.names[i];
}
}
}



 

while

while(feltétel)
{
    // utasítások
}

// Rövid alak
while(feltétel)
    EgyUtasítás;

A while utasítással lehet az elől tesztelős ciklust megvalósítani. Hasonlóan a for ciklushoz, ha nem igaz a feltétel, akkor előfordulhat, hogy egyszer sem fut le. Ellenben a do-while ciklus egyszer mindenképp lefut.

do

do
{
    // utasítások
}
while(feltétel);

A do-while utasításokkal lehet hátul tesztelős ciklust írni. Specialitása, hogy egyszer mindenképp lefut.

Vezérlésátadó utasítások

Lock

Bevezették a lock vezérlési szerkezetet is, erről a Párhuzamos végrehajtás fejezetben lesz szó.

Using

Az using (erőforrás-foglalás) { blokk } szerkezet lefoglalja az erőforrást, végrehajtja a blokkot, és felszabadítja az erőforrást.

using (R r1 = new R())
{
r1.F();
}

ugyanazt hajtja végre, mint

R r1 = new R();

try
{
r1.F();
}

finally
{
if (r1 != null) (IDisposable)r1).Dispose();
}

Kivétel kezelő szerkezet

Try - Catch

Azon kódrészletek "megfigyelésére" és "hibakezelésére" való, melyekben Exception léphet fel.

try
{
    // esetleges hibát okozható utasítások
}
catch( típus [név] )
{
    // egy vezérlési ág egy bizonyos hiba esetén
}

// ... Akármennyi Catch() ág lehet

finally
{
    // biztosan lefut, hibától függetlenül
}

Ugrálás a kódban

goto

Nem épp a struktúrált programozás eszköze, de szerepel a nyelvben. Lehet a hagyományos módon használni, címkével jelölt utasításrészhez ugorhatunk vele, de használhatjuk SWITCH vezérlési szerkezetben is. Ha soha nem hivatkozunk egy cimkére, akkor warning -ot kapunk. A leggyakrabban a SWITCH vezérlési szerkezetben használjuk vagy mélyen egymásba ágyazott ciklusokból való kiugráshoz, mert itt valóban hasznos lehet és tényleg egyszerűsít a dolgon, úgy, hogy nem teszi átláthatatlanná a kódot.

goto identifier;
goto case constant-expression;
goto default;

switch (expression)
{
   case constant-expression:
      statement
      jump-statement
   [default:
      statement
      jump-statement]
}

/*

identifier

Egy cimke
 
constant-expression
 
Egy switch-case címke.

*/


// statements_switch.cs
using System;
class SwitchTest
{
   public static void Main() 
   {
      Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large");
      Console.Write("Please enter your selection: ");
      string s = Console.ReadLine();
      int n = int.Parse(s);
      int cost = 0;
      switch(n)      
      {        
         case 1:  
            cost += 25;
            break;                 
         case 2:           
            cost += 25;
            goto case 1;          
         case 3:           
            cost += 50;
            goto case 1;        
         default:           
            Console.WriteLine("Invalid selection. Please select 1, 2, or 3.");           
            break;     
       }
       if (cost != 0)
          Console.WriteLine("Please insert {0} cents.", cost);
       Console.WriteLine("Thank you for your business.");
   }
}