C# előre definiált típusok

Egész típusok:

Típus	.NET típus	Ábrázolás	Értékkészlet
sbyte	System.Sbyte	8-bites, előjeles	-128 … 127
byte	System.Byte	8-bites, előjel nélküli	0 … 255
short	System.Int16	16-bites, előjeles	-32768 … 32767
ushort	System.Uint16	16-bites, előjel nélküli	0 … 65535
char	System.Char	16-bites, előjel nélküli, Unicode	'\u0000' … '\uffff'
int	System.Int32	32-bites, előjeles	-2147483648-2147483647
uint	System.Uint32	32-bites, előjel nélküli	0 … 4294967295
long	System.Int64	64-bites, előjeles	-9223372036854775808- 9223372036854775807
ulong	System.Uint64	64-bites, előjel nélküli	0 … 18446744073709551615

Lebegőpontos típusok:

Típus	.NET típus	Ábrázolás	Értékkészlet
float	System.Single	32-bites	±1.5 × 10−45 … ±3.4 × 1038
double	System.Double	64-bites	±5.0 × 10−324 …±1.7 × 10308
decimal	System.Decimal	128-bites	±1.0 × 10−28 … ±7.9 × 1028

Logikai típus:

Típus	.NET típus	Ábrázolás	Értékkészlet
bool	System.Boolean	8-bites	true, false

Referencia típusok:

Típus	.NET típus	Leírás
object	System.Object	Minden előre definiált és felhasználó által készített típus a System.Object osztálytól származik.
string	System.String	Nem módosítható unicode karaktersorozatok típusa.

Változó deklarálása:

Típus VáltozóNév;

VáltozóNév betűvel vagy _ karakterrel kezdődhet, utánna már tartalmazhat számokat is.

A kis és nagy betűvel létrehozott változó nevek különböznek. pl.: Név, név

A programozási nyelv foglalt szavait nem használhatjuk változó névnek. pl.: for, new

A változóknak az = értékadó operátor segítségével adhatunk értéket.

Változó = kifejezés;

Az értékadás először kiértékeli a jobb oldalon található kifejezést, majd átadja az értékét a bal oldalon található változónak.

pl.:

int a = 5 + 2;

Jobb oldal: 5+2 = 7

A kiértékelés után a változó értéke 7 lett.

A kifejezések kiértékelésének sorrendje:

Szimbólum	Művelet típusa	Kiértékelés iránya
[ ] ( ) . –> postfix ++ postfix ––	Kifejezés	->
prefix ++ prefix –– sizeof & * + – ~ !	Unáris	<-
típus kényszerítés	Unáris	<-
* / %	Multiplikatív	->
+ –	Addítiv	->
<< >>	Bit shiftelés	->
< > <= >=	Relációs	->
== !=	Azonosság	->
&	Bitenkénti ÉS	->
^	Bitenkénti kizáró VAGY	->
|	Bitenkénti VAGY	->
&&	Logikai ÉS	->
||	Logikai VAGY	->
? :	Feltételes kifejezés	<-
= *= /= %=  += –= <<= >>=&=  ^= |=	Egyszerű és összetett hozzárendelés	<-
,	Felsorolás	->

A következő értékadás:

x = x + 5;

felírható rövid alakban így:

x += 5;

A következő műveletek írhatók fel rövid alakban:

+=	összeadás
-=	kivonás
*=	szorzás
/=	osztás
%=	maradékos osztás
~=	bitenkénti negáció
^=	bitenkénti kizáró VAGY
&=	bitenkénti ÉS
|=	bitenkénti VAGY

Implicit típuskonverzió:

A „szűkebb” típus adatvesztés nélkül konvertálódik a „szélesebb” típusra, ha szükséges.

Például egész számok esetén: byte -> short -> int -> long

Explicit típuskonverzió:

A felhasználó írja elő, hogy az eltérő típusok miként kerüljenek át a változóba.

Használhatjuk a (típus) típuskényszerítést. Pl.:

double a = 10;

int b = (int) a;

Létezik az alaptípusok számára létrehozott Convert osztály, amelynek metódusait is meghívhatjuk.

double a = 10;

int b = Convert.ToInt32(a);

Szöveggé alakítás:

Nagyon gyakori feladat, hogy egy számot szövegként szeretnénk megjeleníteni. Minden objektum rendelkezik egy .ToString() metódussal, amely ezt az átalakítást lehetővé teszi. A átalakítás esetén egy formátum sztringet is megadhatunk, amellyel előírhatjuk az átalakítás végeredményét

double a = 3.14;

string szoveg = a.ToString("F3"); //3.140

Az F3 lebegőpontos számok esetén előírja a tizedesjegyek számát.

A matematikai függvények a Math osztályban találhatók. Ügyeljünk arra, hogy a trigonometrikus függvények radiánban dolgoznak.

Leggyakorik függvények:

Math.Abs(szám)	Abszolút érték
Math.Pow(alap, kitevő)	Hatványozás
Math.Sqrt(szám)	Gyökvonás
Mat.Sin(szám radiánban)	Szinusz
Math.Cos(szám radiánban)	Koszinusz

Ez az osztály tartalmaz még két konstanst is:

Math.PI //a pi értéke

Math.E //az Euler-féle szám

if szerkezet:

Az összehasonlításokban két kifejezést relációs műveleti jellel kapcsolunk össze.

kifejezés1 > kifejezés2	akkor igaz, ha a kifejezés1 nagyobb, mint a kifejezés2,
kifejezés1 >= kifejezés2	akkor igaz, ha a kifejezés1 nagyobb, vagy egyenlő, mint a kifejezés2,
kifejezés1 < kifejezés2	akkor igaz, ha a kifejezés1 kisebb, mint a kifejezés2
kifejezés1 <= kifejezés2	akkor igaz, ha a kifejezés1 kisebb, vagy egyenlő, mint a kifejezés2,
kifejezés1 == kifejezés2	akkor igaz, ha a kifejezés1 egyenlő a kifejezés2-vel,
kifejezés1 != kifejezés2	akkor igaz, ha a kifejezés1 nem egyenlő a kifejezés2-vel,

A feltételes logikai operátorok:

! kifejezés	negáció: a kifejezés logikai értékét ellentettjére változtatja
kifejezés1 && kifejezés2	feltételes ÉS: akkor ad igaz eredményt, ha mindkét kifejezés értéke igaz
kifejezés1 || kifejezés2	feltételes VAGY: akkor ad igaz eredményt, bármelyik kifejezés igaz értékű

if szerkezet:

Az elágazó utasítás egy logikai kifejezést vizsgál meg. Annak igaz állapota esetén végrehajtja a következő utasítást.

if (logikai kifejezés) utasítás;

Ha több utasítást is szeretnénk végrehajtani, akkor egy utasítás blokkba kell azokat foglalni:

if (logikai kifejezés) {

  utasítás1;

  utasítás2;

  utasítás3;

}

Ha a hamis ágat is szeretnék figyelembe venni, akkor alkalmazhatjuk az else ágat is:

if (logikai kifejezés) {

  // igaz esetben

  utasítás1;

  utasítás2;

  utasítás3;

}

else {

  // hamis esetben

  utasítás1;

  utasítás2;

  utasítás3;

}

Az egyes if .. else szerkezetek egymásba is ágyazhatók:

if (logikai kifejezés) utasítás1;

else if (logikai kifejezés) utasítás2;

else (logikai kifejezés) utasítás3;

A switch szerkezet esetén a megadott kifejezés értékétől függően (ami lehet: bool, enum, int, vagy string) több lehetséges utasítás valamelyike kerül végrehajtásra.

switch (változó) {

case érték1:

utasítás;

break;

case érték2:

utasítás;

break;

case érték3:

utasítás;

break;

default:

utasítás;

break;

}

Mindig csak egyetlen ág lehet azonos a változó értékével. A többi ág nem lesz végrehajtva. Ha egyetlen egyezés sem található, akkor alkalmazhatunk egy default esetet.

A legegyszerűbb szelekciós utasítást a ? : három operandusú operátorral végezhetjük el.

(logikai kifejezés) ? (igaz állapot) : (hamis állapot);

Használhatjuk például két szám közül a nagyobb eldöntésére:

int a=10, b=20;

int max = (a>b) ? a: b;

Addig ismétlődik a ciklus, ameddig a ciklus feltétele igaz:

while(feltétel)

utasítás;

Több utasítás végrehajtása esetén egy utasítás blokkot kell használni:

while(feltétel)

{

utasítás1;

utasítás2;

};

Figyeljünk arra, hogy a feltétel előbb utóbb hamissá váljon, különben egy végtelen ciklust kapunk! Fontos, hogy a while(feltétel)-t tilos egy ;-vel lezárni!!!

Ez egy elöl tesztelt ciklus, amely a feltételtől függően akár egyszer sem fut le.

Ez egy hatul tesztelt ciklus, amelynek ciklusmagja legalább egyszer mindenképpen lefut.

do

{

utasítás;

} while(feltétel);

A ciklusmag addig ismétlődik, ameddig a feltétel igaz.

Fontos, hogy ebben az esetben a ciklus-t ;-vel zárjuk!!

A tömb azonos típusú elemeket tartalmazó összefüggő memóriaterület.

Deklarációja:

típus [] név;

Memória foglalása

név = new int [méret];

Ezt írhatjuk egybe is:

típus [] név = new int[méret];

Elemek elérése index segítségével történik. Az index 0-tól indul és méret-1-ig tart.

név [index]

Példa:

int [] tomb = new int[10]; //10 elemű tömb

int elso=tomb[0];

int utolsó=tomb[9];

A tömböt létrehozhatjuk inicializáló elemekkel is

int [] tomb = new int[] {10,20,30};

vagy egyszerűen:

int [] tomb = {10,20,30};

ilyenkor a megadott elemek lesznek a tömb kezdő értékei, és akkora lesz a tömb, amennyi elemet megadtunk.

Több dimenziós tömb:

típus [,] név = new típus[sor,oszlop];

Adat elérése:

név[sor index, oszlop index]

A tömb méretét a Length tulajdonsággal kérdezhetjük le. Ez visszaadja a tömb teljes méretét. Több dimenzió tömb esetén a sor * oszlop eredményét.

Ha külön a sorok vagy oszlopok számát szeretnénk lekérdezni akkor a GetLength(dimenzió) metódust használhatjuk. GetLength(0) visszaadja a sorok számát, GetLenght(1) pedig az oszlopok számát adja vissza.

A tömbök bejárásának legegyszerűbb módja a for ciklussal történő indexelés:

A for ciklus egy elöl tesztelt ciklus. Alakja:

for( inicializálás ; feltétel ; léptetés )

utasítás;

Ameddig a feltétel igaz, addig a ciklus magja folyamatosan ismétlésre kerül.

A { } utasításblokk alkalmazásával több utasítás is végrehajtható.

for( inicializálás ; feltétel ; léptetés )

{

utasítás1;

utasítás2;

}

Példa a használatára: (0..9 közötti számokat írja ki)

for (int i=0; i<10; i++)

Console.WriteLine(i);

Mindig csak egyetlen ág lehet azonos a változó értékével. A többi ág nem lesz végrehajtva. Ha egyetlen egyezés sem található, akkor alkalmazhatunk egy default esetet.

Véletlen számokat a Random osztály segítségével állíthatunk elő.

Példány létrehozása:

Random véletlen = new Random();

A következő véletlen szám előállításának lehetőségei:

• 0 és max-1 közötti egész szám generálása: véletlen.Next(max);
• min és max-1 közötti egész szám generálása: véletlen.Next(min, max);
• 0 és 1 közötti valós szám generálása: véletlen.NextDouble();

A szövegek tárolására és kezelésére a String osztály szolgál.

A szöveg változó String típussal hozható létre. pl.: String nev="Attila";

A szöveget " " karakterek közé kell írni.

A szöveg nem más, mint karakterek sorozata (tömbje). A szöveg egyes karaktereit az [] index operátorral ki tudjuk választani (0-ás indextől kezdődően) és lekérdezhetjük az adott helyen található karaktert

A karaktereken a Char osztályban található metódusokkal tudunk dolgozni. A karaktert mindig ' ' karakterek között kell megadni.

A String osztály legfontosabb metódusai:

Length (hossz): Megadja, hogy az adott string hány karakter hosszúságú.

string a = ”cicus”;

label1.Text = Convert.ToString(a.Length); // 5

Összehasonlítás: static int Compare (String a, String b);

string a = "aaz";

string b = "aba";

label1.Text = String.Compare(a, b);   // -1, mert a < b  (0, ha egyenlő és 1, ha nagyobb)

Összefűzés: static String Concat (String a, String b);

string a = "aaz";

string b = "aba";

label1.Text = String.Concat(a, b);   // aazaba

Kisbetűssé alakít: static String ToLower ();

string a =  ”AAZ";

label1.Text = a.ToLower();   // aaz

Nagybetűssé alakít: static String ToUpper ();

string a =  ”aaz";

label1.Text = a.ToUpper();   // AAZ

Karakterek eltávolításas: tatic String Trim (); …TrimStart() …TrimEnd()

string a =  ”***aaz***";

label1.Text = a.Trim(‘*’);   // aaz  (startnál csak az elejéről szedi le, endnél pedig csak a végéről)

Karakter első előfordulásának helye: int IndexOf(String a);

string a =  ”***aaz***";

label1.Text = Convert.ToString(a.IndexOf(‘a’));   // 3

Adott helyre beszúr: String Insert (int start, String a);

string  a = ”aaa ccc”;

string  b = ” bbb”;

string  c = a.Insert(3, b);

label1.Text = c;   // aaa bbb ccc

Adott egyező részletet kicserél: String Replace (String a, String b);

string  a = ”abc abb abc”;

label1.Text = a.Replace(”abb”, ”abc”);   // abc abc abc

Eltávolít adott számú karaktereket: String Remove (int start, int db);

string  a = ”abc abb abc”;

label1.Text = a.Remove(3,4);   // abc  abc

Kivágja a string egy adott részletét: String Substring(int start, int db);

string  a = ”abcdefghij”;

label1.Text =  a.Substring (3,4));   // defg

Szöveg darabolása: String Split(char[] karaktarek);

string  a = ”abc cba abc”;
string[] részek =  a.Split(' '));   // 3 rész

Szöveg tartalmaz-e: String Contains(string tartalom);

string  a = ”abc cba abc”;
bool tartalmaz =  a.Contains("cba"));   // igaz

A fájlkezeléshez használt referencia:

using System.IO;    // fájlkezeléshez (StreamReader, StreamWriter)

Szövegfájlok használatára szolgáló osztályok:

• StreamReader - szövegfájlok olvasására
• StreamWriter - szövegfájlok írására

A példányosítás során megdható a szükséges fájl elérési útja.

A fájlműveletek végén a .Close() metódussal zárhatjuk be a fájlt.

A StreamReader-rel az egész fájlon egy elöl tesztelt ciklus segítségégével mehetünk végig, ahol a file végét az EndOfStream tulajdonság jelöli.

while(!Olvaso.EndOfStream)

{…}

A beolvasni kívánt fájlból a ReadLine() metódussal olvashatunk be egy sort.

StreamReader olvaso = new StreamReader("fajl.txt");

{

string sor = olvaso.ReadLine();

}

olvaso.Close();

A metódusok létrehozása:

	[módosítók] típus metódusnév ([paraméterlista])
	{

		// a metódus törzse
		//lokális deklarációk
		//egyéb utasítások
		[return [kifejezés];]

	}
	

A leggyakrabban előforduló módosítók:

public – a metódus nyilvános, vagyis bármely más metódusból hívható,
private – saját metódus, azaz csak a metódust tartalmazó osztály metódusaiból hívható, de más osztály
metódusaiból nem,
static – statikus, objektumpéldány nélkül is hívható az osztály nevét használva.

A metódus (visszatérési) típusa az alábbiak közül kerülhet ki:

- tetszőleges értéktípus, az egyszerű típusoktól, a felsorol típuson át egészen a struktúrákig,
- a referenciatípusok (tömb, osztály stb.) valamelyike,
- ha nincs visszatérési érték, akkor ezt a void típussal jelezzük.

A return utasításnak két fontos szerepe van:

- hatására a hívott metódus visszatér a hívás helyére, és a vezérlés a hívást követő utasításra kerül,
- az utasításban szereplő kifejezés értéke, mint függvényérték (visszatérési érték) jelenik meg

---

Példa egy függvény elkészítésére:

	public double MertaniKozep(double x, double y)
	{

		return Math.Sqrt(x*y);

	}
	

Metódus hívása: double mk = MertaniKozep(7, 27);

---

Példa egy eljárás elkészítésére: (nincs visszatérési értéke - void)

	public void Megjelenit(string szoveg, double adat)
	{

		MessageBox.Show(szoveg + ": " + adat, "Megjelenít");
 
	}
	

Metódus hívása: Megjelenit("12 és 23 mértani közepe", MertaniKozep(12, 23));

Értéktípus:

Az átadott paraméter átmásolódik a metódus paraméterébe

	int osszeg(int a, int b)
	{
		return a + b;
	}
	

Használata:

	int szam1 = 2;
	int szam2 = 5;
	int szam3 = osszeg(szam1, szam2);
	

---

Hivatkozástípus:

Ilyenkor az átadott tömb vagy referencia objektum (osztály példány) megváltoztatható

	void Feltolt(int[] a)
	{
		Random rnd = new Random();
		for (int i = 0; i < a.Length; i++)
			a[i] = rnd.Next(1,6);
	}
	

Használata:

	int[] vektor = new int[12];
	Feltolt(vektor);
	

---

Referencia paraméterek:

Így a paraméteren keresztül magát a változót érjük el. A referencia-paramétert a ref módosítóval jelöljük, mind a deklarációban, mind pedig a metódus hívásakor a megfelelő aktuális paraméter (argumentum) előtt:

	void csere(ref int x, ref int y)
	{
		int z = x;
		x = y;
		y = z;
	}
	

Használata: (Csak értékkel rendelkező (inicializált) változókkal hívható meg!)

	int szam1 = 2;
	int szam2 = 5;
	csere(ref szam1, ref szam2);
	

---

Kimenő paraméterek:

Így a paraméteren keresztül magát a változót érjük el. A kimenő-paramétert az out módosítóval jelöljük, mind a deklarációban, mind pedig a metódus hívásakor a megfelelő aktuális paraméter (argumentum) előtt:

	void osszeg(int a, int b, out int c )
	{
		c = a + b;
	}
	

Használata: (Nem szükséges kezdő értékkel rendelkeznie a kimenő-paraméternek!)

	int szam1 = 2;
	int szam2 = 5;
	int szam3;
	osszeg(szam1, szam2, out szam3);
	

Metódus túlterhelése (átdefiniálása - overloading):

- Azonos néven, de eltérő paraméterekkel rendelkező metódusok

- Híváskor a paraméter alapján dől el, hogy melyik metódus fog lefutni!

	// egész számok összege
	int osszeg(int a, int b)
	{
		return a + b;
	}

	//tört számok összege
	double osszeg(double a, double b)
	{
		return a + b;
	}

	

Metódus hívása: osszeg(1,2); //egész számokra

Metódus hívása: osszeg(1.4,1.5); //tört számokra