C# - Hozzáférés szabályozása osztályon belül

C# nyelv 11. rész

forráskód letöltése
Ha deklarálunk egy osztályt, akkor azon belül öt különböző lehetőségünk van, hogy szabályozzuk az egyes metódusok, változók, egyéb tag hozzáférhetőségét, láthatóságát. Mostani cikkünkben ezek használatának járunk utána.
Röviden tekintsük át ezt az öt lehetőséget, melyhez egy-egy kulcsszó párosul, melyet majd a forráskódjainkban is használni kell.
  • public – a public-ként deklarált tagokhoz a hozzáférés nem korlátozott, így azokat saját osztályon belül, illetve az adott osztályon kívül is épp úgy elérhetjük.
  • protected – ha protected-ként deklarálunk egy tagot, akkor ehhez csak a saját osztályon belül, vagy az adott osztályból leszármazott osztályban férhetünk hozzá, de kívülről nem.
  • internal – az internal-ként deklarált taghoz való hozzáférés a programon belül engedélyezett csak.
  • protected internal – a protected és az internal módosítót kombinálhatjuk is. Ennek eredményeképpen az így deklarált tag az adott osztályon belül, a leszármazott osztályokban és a programon belül lesz látható.
  • private – ha private-ként deklarálunk egy tagot, akkor az kizárólag az adott osztályon belül lesz látható.
Nézzük mindezt a gyakorlatban. Létrehozunk egy A nevű osztályt, melyben deklarálunk öt függvényt, mindegyiket más és más hozzáférés módosítóval.
    class A
    {
      public int A1(){ return 1; }
      protected int A2(){ return 2; }
      internal int A3(){ return 3; }
      protected internal int A4() { return 4; }
      private int A5() { return 5; }
    }
Az A osztályon belül mindegyik függvényt használhatnánk korlátozás nélkül. Ha viszont létrehoztunk egy példányt ebből, akkor ott csak a public, illetve az internal függvényeket tudjuk elérni. Vagyis ekkor az A osztály A1, A3 és A4 függvényei érhetők el.
      protected void button1_Click (object sender, System.EventArgs e)
      {
        A a = new A();
        listBox1.Items.Add(a.A1());
        //listBox1.Items.Add(a.A2());
        listBox1.Items.Add(a.A3());
        listBox1.Items.Add(a.A4());
        //listBox1.Items.Add(a.A5());        
      }
Bonyolítsuk egy kissé a helyzetet és hozzunk létre egy B osztályt az A-ból származtatva. Ebben az osztályban szintén létrehozunk öt függvényt, de most mindegyik public-ként lesz deklarálva. Mindegyik függvény megpróbálja elérni az A osztály egy-egy függvényét. Ezzel egyedül az A5 esetében lesz csak probléma, mivel ez az A osztályban private és ezért ez csak az A osztályon belül használható. A másik négy függvényt elérhetjük.
    class B: A 
   {
      public int B1(){ return A1(); }
      public int B2() { return A2(); }
      public int B3(){ return A3(); }
      public int B4() { return A4(); }
      // public int B5() { return A5(); }
    }
Hozzunk most létre egy példányt a B osztályból is és hasonlóan próbáljuk meg elérni függvényeit. A B5-öt létre sem tudtuk hozni a másik négy viszont gond nélkül elérhető.
      protected void button2_Click (object sender, System.EventArgs e)
      {
        B b = new B();
        listBox2.Items.Add(b.B1());
        listBox2.Items.Add(b.B2());
        listBox2.Items.Add(b.B3());
        listBox2.Items.Add(b.B4());
        //listBox2.Items.Add(b.B5());
      }
Megfigyelhető tehát, hogy az A osztály protected-ként deklarált függvénye nem volt elérhető kívülről, de most a B osztályon keresztül mégis hozzáférünk, mivel az osztályon belül látja az A2-t és a B2 viszont már public.

C# nyelv cikksorozat