c# (c-sharp)

Paradigmák:

• strukturalt,
• imperativ,
• objektumorientalt

A Microsoft által kifejezetten a .NET framework-re fejlesztett ECMA és ISO szabványosított erősen típusos teljesen objektumorientált¹⁾ programozási nyelve.

A nyelv struktúrájának bemutatása:

1. using System;
2. namespace SajátNévterem {
3.   class PéldaOsztály {
4.     public static void Main()
5.     {
6.       Console.WriteLine("Hello VMG!");
7.     }
8.   }
9. }

A C# program objektumok, struktúrák, adattípusok definícióniak halmazából áll. Az objektumorientált nyelvek egysegbezaras elvét az osztalyok valósítják meg. Egy forrásfájlban több osztály is definiálható, és egy osztály több állományba is szétbontható (.NET 2.0 partial_class). Az osztályok állapotaikat az adattagokon őrzik és metodusaikkal változtatják.

A .NET keretrendszerben minden futtatható file-nak rendelkeznie kell egy belépési ponttal (4.sor). C#-ban a belépési pont tulajdonságai:

• metódusának neve: Main (a nyelv case-sensitive)
• a Main() metódus kötelezően statikus_metodus
• visszatérési értéke void vagy int
• paraméter/argumentum listája opcionálisan: string[] típusú
• a Main metódus lathatosaga kötelezően public (!ez eltér a c# default metódus láthatóságtól, ami a private)

Egy alkalmazás a Main() metódusból kilépésig fut. (7.sor)

Az osztályokat (3.sor) (és egyéb adattípusokat) névterekbe lehet szervezni (2.sor). Egy névtör több file-t, és egy forrás több névteret is lefedhet. A névteret (a névtéren belüli osztályok egyszerűbb használatához) az adott programforráson belül a using kulcsszóval lehet igénybe venni. (Példánkban a Console osztály WriteLine() metódusához az 1. sorban szereplő utasítás.) A névterek using kulcsóval való használatba vétele nem kötelező, közvetlen hivatkozhatunk is rá: System.Console.WriteLine(„helló c# világ!”);

adatszerkezetek²⁾

Jobbról balra történik, és más nyelvekhez hasonlóan a bal oldalon egyéb művelet nem lehet.

   int i, j, k;
   i = j = k = 10; 	//k legyen 10, j legyen k (ami 10), i legyen j

• additív többváltozós (+,-),
• multiplikatív többváltozós (*,/,%)
• additív egyváltozós (++, –) (prefix, postfix)

   i = j + 10 - k + 1;  // 11
   k = 3 * j;           // 30
   i++;                 // 12
   --k;                 // 29

Egy aritmetikai és az értékadó (egyenlőségjel) operátorból képezhető. A számítási szabály így változó <aritmetikai operátor>= változóÉrték jelentése változó = változó + változóÉrték

+=, -=, *=, /=, %=

   j -= 3;              // j = j - 3;
   k %= 2;              // k = k % 2;

relációs operátor: <, > ==, !=, >=, ⇐ eredményük: {true, false} általában az elágazásokban használjuk (feltételes log. műveletek)

Az egyetlen háromváltozós művelet a feltételes művelet.

	int x = 121243;
	//[változó] = ( [feltétel] ) ? [érték, ha igen...] : [érték,ha nem...];
	bool páros = ( x % 2 == 0 ) ? true : false ;

A műveleti sorrend kötött

 1. elsődleges: ().[] x++ x-- new typeof sizeof checked unchecked
 2. egyváltozós
 3. multiplikatív
 4. additív
 5. eltolási
 6. viszonyító
 7. egyenlőségi
 8. logikai és
 9. logikai xor
10. logikai or
11. feltételes and
12. feltételes or
13. feltételes művelet
14. értékadás

Hatókör: egy változó jellemzően csak egy {} blokkon belül él.

  int x;
  {
     int y = 0;
     y++;
     x = y;
  }
  x++;
  // viszont itt y-ra már nem hivatkozhatunk
 
  for(int i = 0; i<10; i++) 
  {
     // i a ciklusmagon belül elérhető, de
  }
  // a cikluson kívül már nem, a GC fel fogja szabadítani az általa foglalt memóriát.

ez a szakasz hiányos implicit konvertálás: célszerűen bővebb típusra, ne dobjon kivételt, különben explicit konverzió: ez a type cast ehelyett használható az as operátor. Itt sikertelen konverzió esetén nem kapunk kivételt, hanem egyszerűen nulla értéket.

A konverzió sikeressége előre is eldönthető, az is operátor használatával. Ha típuskompatibilis, akkor igaz, ha nem hamis értéket kapunk.

Itt jegyzünk meg két fontos dolgot:

• lusta (mohó) algoritmus
• saját típusunkon használandó operátorok is definiálhatók

a program menete a megadott feltételeket teljesítő ágban fut tovább

• kétágú szelekció: egy logikai kifejezéstől (feltételtől) függ, hogy melyik tevékenységet hajtjuk végre. Nem kötelező megvalósítani a „különben” ágat és tetszőleges feltételek és utasításblokkok egymásba ágyazhatók.

    int i = 2;
    if ( i <= 0 )
    {              // ha igaz a feltétel, hogy az i változó értéke kisebbegyenlő, mint 0, akkor...
           System.Console.WriteLine("i nemnegatív");
    } else {       // különben pedig...
           System.Console.WriteLine("i természetes szám");
    }

• többágú szelekció típusok: egy kifejezés értékétől függő elágazás. Ha egy kifejezés több értékcsoportba is beleesik, akkor az előrébbvalósági sorrend definiálja a működést. (vö. struktogrammok, ahol ez definiálatlan)

  	if (i==2) 
  	{
  	    // ha i éppen kettő	
  	}
  	else if (i>=3) 
  	{
  	    // ha i 3 vagy nála nagyobb
  	}
  	else 
  	{
  	    // különben (se nem kettő, se nem három vagy háromnál nagyobb)
  	    // tehát ha 3-nál kisebb, de nem kettő
  	}

  	// Megjegyzés: a "break" kulcsszó elhagyása hiba!
  	string szöveg = "";
  	switch (szöveg)
  	    case 'Macska':
  		    // ha Macska a szöveg változó értéke
  		break;
  	    case 'Nyúl':
  		break;
  	    default:
  		    // ha egyik sem
  		break;

Más néven ciklusban, vagy ismétlési szerkezetben egy feltételtől függően végzünk utasítássorozatokat. Az ismétlendők alkotják a ciklusmagot.

1. elöltesztelős ciklus (pl. eldöntési tétel)

     while ( futási feltétel ) 
     {
        //ciklusmag
     }

2. hátultesztelős ciklus (Figyelem! c#-ban az elöltesztelős ciklussal egyezően a futási feltételt adjuk meg a blokk végén.): Olyan esetben használjuk, ahol a ciklusmagnak egyszer biztosan le kell futnia.

     do
     {
        //ciklusmag
     } while ( futási feltétel ) ;

3. for ciklus: sokszor tömbök bejárására használjuk

     for ( [ciklusváltozók inicializálása] ; [futási feltétel] ; [ciklusváltozók módosítása] ) 
     {
    
     }

4. foreach ciklus: legtöbbször gyűjtemények (és toembök)³⁾ bejárására használjuk

     foreach ( változóTípus változóNév in gyűjtemény ) 
     {
    
     }

Példa:

  int[] Tömb = new int[2] { 2,3 };
  int i = 0;
  while ( i < Tömb.Length && !(Tömb[i]%7==0) ) 
      ++i;
  string kiír = (i<Tömb.Length) ? "van 7-tel osztható elem" : "hamis feltétel";
  System.Console.WriteLine(kiír);