====== c# (c-sharp) ======
Paradigmák: 
  * [[informatika:programozas:dotnet:strukturalt]],
  * [[informatika:programozas:dotnet:imperativ]],
  * [[informatika:programozas:dotnet:objektumorientalt]]

A Microsoft által kifejezetten a [[oktatas:informatika:programozas:dotnet:start|.NET]] framework-re fejlesztett ECMA és ISO szabványosított [[oktatas:informatika:programozas:erosen_tipusos|erősen típusos]] teljesen objektumorientált((Minden őse a System.Object osztály)) programozási nyelve.

A nyelv struktúrájának bemutatása:
<code c#>
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. }
</code>
A C# program objektumok, struktúrák, adattípusok definícióniak halmazából áll. Az objektumorientált nyelvek [[informatika:programozas:dotnet:c-sharp:egysegbezaras]] elvét az [[informatika:programozas:dotnet:c-sharp:osztaly]]ok 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 [[informatika:programozas:dotnet:c-sharp:partial_class]]). Az osztályok állapotaikat az [[informatika:programozas:dotnet:c-sharp:adattag]]okon őrzik és [[informatika:programozas:dotnet:c-sharp:metodus]]aikkal 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 [[informatika:programozas:dotnet:c-sharp:statikus_metodus]]
  * visszatérési értéke ''void'' vagy ''int''
  * paraméter/argumentum listája opcionálisan: ''string[]'' típusú
  * a Main metódus [[informatika:programozas:dotnet:c-sharp:lathatosag]]a 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 =====

[[informatika:programozas:dotnet:c-sharp:adatszerkezetek]]((
Alapfogalmak: adat konstans változó típus
Referencia vs. Érték
/.NET típusok és megfeleltetések/
struktura, osztály (partial class .NET 2.0)
tömb, láncolt lista (generikus osztályok .NET 2.0)
))




===== Műveletek =====

==== Értékadás ====

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

<code c#>
   int i, j, k;
   i = j = k = 10; 	//k legyen 10, j legyen k (ami 10), i legyen j
</code>

==== Aritmetikai műveletek ====
  *  additív többváltozós (+,-),
  *  multiplikatív többváltozós (*,/,%)
  *  additív egyváltozós (++, --) (prefix, postfix)

<code c#>
   i = j + 10 - k + 1;  // 11
   k = 3 * j;           // 30
   i++;                 // 12
   --k;                 // 29
</code>

==== Összetett műveletek ====

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''

''+=, -=, *=, /=, %= ''
<code c#>
   j -= 3;              // j = j - 3;
   k %= 2;              // k = k % 2;
</code>

==== Összehasonlító, viszonyító műveletek ====
relációs operátor: ''<, > ==, !=, >=, <='' eredményük: {true, false} általában az [[#elágazás]]okban használjuk (feltételes log. műveletek) 
==== Feltételes logikai műveletek ====

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

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

==== Típusműveletek (as,is) ====


==== Műveleti sorrend ====

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


===== Egymásbaalakíthatóság, hatókörök =====

Hatókör: egy változó jellemzően csak egy {} blokkon belül él.
<code c#>
  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.
</code>

** 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



===== Program menetének szabályozása ===== 
==== Vezérlési szerkezetek ====
=== szelekció, elágazás((szokásos elnevezés még: kiválasztás)) ===

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.<code c#>

  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");
  }
</code>
    * **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ö. [[informatika:programozas:struktogrammok]], ahol ez definiálatlan)<code c#>
	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ő
	}
</code><code c#>
	// 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;
</code>


=== iteráció (bejárások) ===
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 **ciklusmag**ot.

    - elöltesztelős ciklus (pl. [[oktatas:informatika:programozas:tetelek|eldöntési tétel]])<code c#>
  while ( futási feltétel ) 
  {
     //ciklusmag
  }
</code>
    - hátultesztelős ciklus (Figyelem! c#-ban az elöltesztelős ciklussal egyezően a **futási feltétel**t adjuk meg a blokk végén.): Olyan esetben használjuk, ahol a ciklusmagnak egyszer biztosan le kell futnia.<code c#>
  do
  {
     //ciklusmag
  } while ( futási feltétel ) ;

</code>
    - for ciklus: sokszor tömbök bejárására használjuk<code c#>
  for ( [ciklusváltozók inicializálása] ; [futási feltétel] ; [ciklusváltozók módosítása] ) 
  {

  }
</code>
    - foreach ciklus: legtöbbször gyűjtemények (és [[informatika:programozas:dotnet:c-sharp:toemb]]ök)((IEnumerable Interface-t megvalósítják)) bejárására használjuk<code c#>

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

  }

</code>

Példa:
<code c#>
  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);
</code>

=== kivételkezelés ===

=== többszálúság ===