C# - Property-k létrehozása osztályokon belül

C# nyelv 17. rész

forráskód letöltése
Egy-egy osztályon belüli változókhoz történő hozzáférést célszerű letiltani úgy, hogy azt osztályon kívülről ne lehessen elérni, vagyis private-ként vagy protected-ként deklarálni. Amennyiben mégis szükség van az osztály belső változóinak elérésére, akkor ezekhez célszerű property-ket létrehozni. Ennek az a legnagyobb előnye, hogy így ellenőrizhető, szabályozható a változóhoz történő hozzáférés, vagyis programkódot rendelhetünk a változó értékének kiolvasásához és megváltoztatásához is.
Egy property-t létrehozása után épp úgy használhatunk, mintha az egy változó lenne: adhatunk neki értéket és ki is olvashatjuk azt, vagyis az egyenlőségjel mindkét oldalán állhat.
A property deklarációjakor külön kódot rendelhetünk annak írásához és külön kódot a kiolvasáshoz. Amikor deklarálunk egy property-t, akkor nem kell semmilyen külön kulcsszóval ezt jelölnünk, egyszerűen csak megadjuk a láthatósági kört, a property típusát és nevét. Mivel a property-knek értéket kell szolgáltatni és tárolni is, így általában tartozik hozzájuk egy tényleges változó, melyből olvassák a szükséges értéket és odaírják az újonnan kapott értéket is. Ezt a változót célszerű private-ként, vagy protected-ként deklarálni, hogy ahhoz kívülről ne lehessen hozzáférni.
Egy property deklarációján belül két speciális metódust kell deklarálnunk: az egyik a get a másik a set. Ezekre úgy tekinthetünk, mint két függvény. Amikor a property értékét kell kiolvasni, akkor fut le a get-hez rendelt kód. Itt a return-nak kell megadnunk azt az értéket, mely a property aktuális értéke lesz. A set akkor fut le, amikor a property-nek értéket adunk. Ebben az esetben a property-nek átadott értéket a value kulcsszó segítségével tudhatjuk meg. Mivel a get és set esetében is tetszőleges kódot futtathatunk, így teljesen ránk van bízva, hogy mi is történik ilyenkor. Lehetőségünk van például ellenőrizni a kapott értéket és ha az nem felel meg számunkra, akkor akár nem is tároljuk el, de azt is megtehetjük – ahogy ez a mellékelt példában is látható -, hogy a kapott sztringet nagybetűssé konvertáljuk és ezt tároljuk el. Ezzel biztosíthatjuk, hogy a belső „s” változónkban mindig csak nagybetűs szöveg szerepel.
   public class One
  {
    private string s;    
    public string Text 
    {
      get 
      {
        return s;
      }
      set
      {
        s = value.ToUpper();
      }
    }
Lehetőségünk van arra is, hogy olyan property-t készítsünk, mely readonly-ként, vagyis csak olvashatóként működik. Ennek megvalósítása igen egyszerű: hagyjuk el a property deklarációjánál a set metódust.
    public int Length
    {
      get
      {
        return s.Length;
      }
    }
Ennek ellenkezőjére is van lehetőségünk: ha azt szeretnénk, hogy egy property csak írható legyen, akkor a get metódust kell elhagynunk.
    public string SetValue
    {
      set
      {    
        s = value;
        s.Insert(0, "gfx");        
      }
    }
  }
Ezek után, ha deklarálunk egy új változót az imént létrehozott osztályunkból, akkor az alábbi lehetőségeink lesznek:
One one = new One();
…
A Text property olvasható, írható is, így az egyenlőségjel mindkét oldalán állhat.
      protected void button2_Click (object sender, System.EventArgs e)
      {
        label1.Text = one.Text;
      }
      protected void button1_Click (object sender, System.EventArgs e)
      {
        one.Text = textBox1.Text;
      }
Mivel a Length property-t csak olvashatóra deklaráltuk, így annak értéket nem adhatunk. Ha erről megfeledkeznénk, akkor a fordító hibaüzenettel válaszolna.
      protected void button3_Click (object sender, System.EventArgs e)
      {
        label2.Text = one.Length.ToString();
        //one.Length = 5;
      }
A SetValue property esetében fordított a helyzet: itt csak az értékadás megengedett. E property értékét kiolvasni nem lehetséges.
      protected void button4_Click (object sender, System.EventArgs e)
      {
        one.SetValue = textBox2.Text;
        //Text = one.SetValue;
      }

C# nyelv cikksorozat