8.

Tulajdonságok
 Tulajdonságok (Properties)
• Az előző példákban ún. elérési metódusokat alkalmaztunk a private
adatmezők kezelésére. Ez a megoldás teljes egészében megfelel az
objektum-orientált felfogásnak, hisz az adatok csak ellenőrzött módon
változhatnak meg.
• A C#ban a tulajdonságok (properties) nyelvi szinten történő támogatásával,
automatikussá vált az elérési metódusok létrehozása és hívása:

2
 elérési eloírás típus Tulajdonságnév
{
get
{
return adatmezo;
}

set
{
adatmezo = value;
}
}
Amikor a tulajdonság nevére értékadást hajtunk végre, a fordító
meghívja a set metódust, melynek value paraméterében átadja a
beállítandó értéket. A tulajdonság értékének lekérdezésekor pedig a
get metódus aktivizálódik. A get metódus elhagyásával ún. csak
írható, míg a set elhagyásával csak olvasható tulajdonság készíthető.
A tulajdonságok nevét a metódusokhoz hasonlóan nagybetűvel
kezdjük. 3
class Pont
{
// Adatmezok
private double xPoz;
private double yPoz;
// Konstruktorok
public Pont(double xPoz, double yPoz)
{
this.xPoz = xPoz; this.yPoz = yPoz;
}
// Tulajdonságok - Properties
public double X
{
get { return xPoz; }
set { xPoz = value; }
}
public double Y
{
get { return yPoz; }
set { yPoz = value; }
}

4
// Általános metódusok
public double Távolság(Pont p2)
{
return Math.Sqrt(Math.Pow(xPoz - p2.xPoz, 2) + Math.Pow(yPoz
- p2.yPoz, 2));
}
public void Elmozgat(double dx, double dy)
{
xPoz += dx;
yPoz += dy;
}
}

{
Pont p1 = new Pont(12, 23);
Pont origo = new Pont(0, 0);
p1.X = p1.X / 4; // vagy p1.X /= 4;
p1.Elmozgat(0, -19);
Console.WriteLine("{0}",p1.Távolság(origo);
}

5
• A tulajdonságok olyan „intelligens mezők”, amelyek olvasását és írását a
programozó által megadott ún. hozzáférési metódusok végzik
• Az osztályt felhasználó kód számára mezőnek tűnnek
• Az osztály fejlesztője számára metóduspárként jelennek meg
• A hozzáférési metódusok bármilyen műveletet végrehajthatnak (pl.
beírandó adat ellenőrzése, kiolvasandó adat kiszámítása…)
• Nem célszerű hosszan tartó műveletekkel lelassítani a tulajdonság elérését
• Kerülni kell a felhasználó kód számára váratlan mellékhatásokat

6
• Létrehozhatók csak olvasható vagy csak írható tulajdonságok is
• Ha nem adjuk meg az írási, illetve olvasási metódust, akkor csak olvasható, illetve
csak írható tulajdonság jön létre
• Az olvasási és írási metódushoz hozzáférési szint adható meg
• Ezzel a módszerrel például létrehozhatók nyilvánosan olvasható, de csak a saját
vagy a leszármazott osztályok által írható tulajdonságok
• Az olvasási metódust a get, az írási metódust a set kulcsszó segítségével
kell megadnunk
• A hozzáférési metódusokat a tulajdonság definícióján belül kell megadnunk

7
tulajdonsagTipus tulajdonsagNev
{
get test
set test
}
• A private (alapértelmezett), internal vagy public modifikátorok
felhasználásával elérhető, hogy a tulajdonság privát, internal vagy
nyilvános legyen. A static modifikator alkalmazásával a tulajdonság
sztatikus lesz (nem sztatikus az alapértelmezett).

8
tulajdonsagTipus tulajdonsagNev
{
get test
set test
}
• A test formailag blokk.
• A get test az olvasó metódus (kiemelő - getter) . Akkor hajtódik végre
amikor a tulajdonság értéke kiolvasódik.
változó = objektum.tulajdonságNev;
változó = Osztály.tulajdonságNev;
• A kiemelő végrehajtása a return kifejezés; - el ér véget, ahol a kifejezés
típusa megegyezik a tulajdonsagTipus-ával. Azaz a kiemelő úgy viselkedik,
mintha egy paraméterek nélküli metódus lenne
tulajdonsagTipus tulajdonsagNev() test

9
• A set test részt író metódusnak (beállítónak - setter) nevezik. Akkor
hajtódik, végre amikor a tulajdonság értéke beíródik.
objektum.tulajdonsagNev=kifejezés
Osztály.tulajdonsagNev=kifejezés
• A kifejezés értéke a beállítóban használható a value rejtett paraméter
segítségével (rejtett, mert nem látható a beállító definíciójában), és
amelynek típusa megegyezik a tulajdonsagTipus-al, azaz a beállító
úgy viselkedik, mint egy egyparaméteres metódus
void tulajdonsagNev(tulajdonsagTipus value) test

10
• A tulajdonság mellett létezik egy külön definiált ún. háttér mező (backing field) /
az osztály privát tagja, amely értéke kiemelhető ill. beállítható. A típusa
megegyezik a tulajdonsagTipus-al.
• A tulajdonság általában nyilvános, míg a hozzátartozó háttér mező privát. Bevált
gyakorlat, hogy a tulajdonság és a háttér mező neve megegyezik azzal, hogy a
tulajdonság neve nagy betűvel kezdődik, míg a háttér mezőé kis betűvel kezdődik.
• A tulajdonság lehet összetett, miszerint beállításkor egyszerre több mező értékét is
megváltoztatja, és kiemeléskor az eredményt egyszerre több mező értéke határozza
meg.

11
 Példa:
class Alfa{
private int a=1, b=2;
public int A{
get {return a;} set{a=value;}
}
public int B{
get {return b;} set{b=value;}
}
public int C{
get {return a+b;} set{a+=value;b+=value}
}
}
• A és B nyilvános tulajdonságok – az a és b privát mezők
kiemelésére és értékadására
• A C tulajdonság az a és b mezők összegét emeli ki, értékadáskor
pedig az adott értékkel (value) megnöveli az a és b mezők értékét.
12
class AlfaTest{
static void Main(){
Alfa alfa = new Alfa();
int p = alfa.A; //p=1
alfa.A = 5; // alfa.a=5
int q = alfa.A; // q=5
int r = alfa.B; // r=2
alfa.B = 3; // alfa.b=3
int s = alfa.B; // s=3
int t = alfa.C; // t=8
alfa.C = 4; // alfa.a=9, alfa.b=7
int u = alfa.A; // u=9
int v = alfa.B; // v=7
int w = alfa.C; // w=16
}
}

13
 Példa: Tulajdonságok csak a privát mező
elérésére és csak az értékének a beállítására.
class Beta{
private a = 1, b = 2;
public int A { get { return a;}}
public int B { set { b = value;}}
public void Met (int x, out int y)
{ a = x; y = b; }
}
Az A tulajdonság csak visszaadja az a mező értékét – olvasó metódus
(kiemelő - getter), a B tulajdonság pedig csak beállítja a b tulajdonság
értékét – író metódus (beállító – setter).

14
class BetaTest {
static void Main(){
Beta beta = new Beta();
int p = beta.A; // p=1
beta.A = 5; // HIBA – A nem állíthat be értéket
int q = beta.B; // HIBA – B nem emelhet ki értéket
beta.B = 4; // beta.b=4
int r;
beta.Met(3,r); // beta.a=3, r=4
int s = beta.A;// s=3
}
}

15
 Automatikusan alkalmazott tulajdonságok
• Egyszerű tulajdonság definíciója:
tulajdonságTípusa tulajdonságNév {get{return MezőNév ;}
set{mezőNév = value;}}
• Ez tömörebben felírható a következőképpen:
tulajdonságTípusa tulajdonságNév{get;set;}
• Ebben az esetben a kiemelő (getter) és beállító (setter) és
hozzájuk tartozó privát háttér mező automatikusan
generálódik. A háttér mező neve a programozó számára nem
látható. Az ilyen tulajdonságot nevezik automatikus
tulajdonságnak (Auto Implemented Properties).
• A háttér mező típusa megegyezik a
tulajdonságTípusá-val. Léteznie kell (generált)
kiemelőnek, különben nem lehetne hozzáférni a háttér mező
tartalmához.
16
Automatikusan alkalmazott tulajdonságok
• Az automatikus tulajdonság definíciójában feltüntethetők
inicalizátorok:
tulajdonságTípusa tulajdonságNév{get;set;} = kifejezés
• A hozzárendelt háttérmező kezdőértéke a kifejezés
értéke.
• A set; kihagyásával nem jön létre beállító, és így egy
változtathatatlan tulajdonság keletkezik. A tulajdonság
értékét kezdőértékadás után nem lehet megváltoztatni,
mivel az nem látható (elérhető) a programozó számára.
• A változtathatatlan tuladonság rövidített definíciója:
tulajdonságTípusa tulajdonságNév => kifejezés;

17
 Példa: Automatikusan alkalmazott tulajdonságok
class Gamma{
public int A {get; set;} //inicializalo nelkul
public int B {get; set;}=1; // inicializaloval
public int C {get; }=2; //valtozhatatlan tulajdonsag
public int D =>4; //valtozhatatlan tulajdonsag
public int E {set; }; //HIBA- nincs kiemelo
}
class GammaTest{
static void Main(){
Gamma gamma = new Gamma();
int.p=gamma.A; //p=0
gamma.A=5;
int q=gamma.A; //q=5
int r=gamma.B; //r=1
gamma.B=8;
int s=gamma.B; //s=8
int t=gamma.C; //t=2
gamma.C=6; //HIBA-nem lehet beallitani
int u=gamma.D; //u=4
gamma.D=7; //HIBA-nem lehet beallitani } } 18