Kisegítő lehetőségek korlátozása (C# programozási útmutató)

A tulajdonság vagy indexelő lekérési és beállítási részeit tartozéknak nevezzük. Alapértelmezés szerint ezek a tartozékok ugyanolyan láthatósági vagy hozzáférési szinttel rendelkeznek annak a tulajdonságnak vagy indexelőnek, amelyhez tartoznak. További információ: akadálymentességi szintek. Néha azonban hasznos lehet korlátozni az egyik tartozékhoz való hozzáférést. Általában korlátozza a set hozzáférési metódus hozzáférhetőségét, miközben a get hozzáférési metódus nyilvánosan elérhető marad. Példa:

private string _name = "Hello";

public string Name
{
    get
    {
        return _name;
    }
    protected set
    {
        _name = value;
    }
}

Ebben a példában egy tulajdonság, az úgynevezett Name, definiál egy get és egy hozzáférési metódust set. Ebben az esetben get a hozzáférő maga public a tulajdonság hozzáférési szintjét kapja meg, míg a set hozzáférő kifejezetten korlátozott, ha a védett hozzáférési módosítót magára a hozzáférőre alkalmazzák.

Megjegyzés

A cikkben szereplő példák nem használnak automatikusan implementált tulajdonságokat. Az automatikusan implementált tulajdonságok tömör szintaxist biztosítanak a tulajdonságok deklarálásához, ha nincs szükség egyéni háttérmezőre.

A tartozékokkal kapcsolatos hozzáférési módosítók korlátozásai

A tartozékmódosítók tulajdonságokon vagy indexelőkön való használatára a következő feltételek vonatkoznak:

  • Nem használhat kiegészítő módosítókat sem interfészen, sem explicit felülettag-implementáción .
  • A hozzáférési módosítókat csak akkor használhatja, ha a tulajdonság vagy az indexelő mindkét set és get hozzáférővel rendelkezik. Ebben az esetben a módosító csak a két tartozék egyikén engedélyezett.
  • Ha a tulajdonság vagy indexelő rendelkezik felülbírálási módosítóval, a kiegészítő módosítónak meg kell egyeznie a felülbírált tartozék tartozékával, ha van ilyen.
  • A hozzáférő hozzáférési szintjének szigorúbbnak kell lennie, mint a tulajdonság vagy indexelő hozzáférési szintje.

A hozzáférési módosítók a felülíró lekérdezőkön

Ha egy tulajdonságot vagy indexelőt felülbírál, a felülbírált hozzáférőknek elérhetők kell legyenek a felülbíráló kód számára. Emellett a tulajdonság/indexelő és metódusai elérhetőségének meg kell egyeznie a megfelelő felülbírált tulajdonságnak/indexelőnek és metódusainak. Példa:

public class Parent
{
    public virtual int TestProperty
    {
        // Notice the accessor accessibility level.
        protected set { }

        // No access modifier is used here.
        get { return 0; }
    }
}
public class Kid : Parent
{
    public override int TestProperty
    {
        // Use the same accessibility level as in the overridden accessor.
        protected set { }

        // Cannot use access modifier here.
        get { return 0; }
    }
}

Implementálási felületek

Ha egy tartozékot használ egy interfész implementálásához, előfordulhat, hogy a tartozék nem rendelkezik hozzáférési módosítóval. Ha azonban az interfészt egy tartozék használatával valósítja meg, például geta másik tartozék rendelkezhet hozzáférési módosítóval, ahogyan az alábbi példában is látható:

public interface ISomeInterface
{
    int TestProperty
    {
        // No access modifier allowed here
        // because this is an interface.
        get;
    }
}

public class TestClass : ISomeInterface
{
    public int TestProperty
    {
        // Cannot use access modifier here because
        // this is an interface implementation.
        get { return 10; }

        // Interface property does not have set accessor,
        // so access modifier is allowed.
        protected set { }
    }
}

Tartozék akadálymentességi tartománya

Ha hozzáférési módosítót használ a tartozékon, a tartozék akadálymentességi tartományát ez a módosító határozza meg.

Ha nem használt hozzáférési módosítót a tartozékon, a tartozék akadálymentességi tartományát a tulajdonság vagy az indexelő akadálymentességi szintje határozza meg.

Példa

Az alábbi példa három osztályt tartalmaz, BaseClassDerivedClassés MainClass. A két osztály két tulajdonsággal BaseClassNameId rendelkezik. A példa bemutatja, hogyan rejtheti el a Id-n lévő tulajdonságot a Id-n lévő tulajdonság, amikor olyan korlátozó hozzáférés-módosítót használ, mint a protected vagy private. Ezért ha értékeket rendel ehhez a tulajdonsághoz, a rendszer az osztály tulajdonságát BaseClass hívja meg helyette. A hozzáférési módosító public-ra cserélése elérhetővé teszi a tulajdonságot.

A példa azt is szemlélteti, hogy a set tulajdonság Name hozzáférési metódusán elhelyezett korlátozó hozzáférési módosító, mint például private vagy protected, megakadályozza a metódus elérését a DerivedClass származtatott osztályban. Hiba keletkezik, amikor megpróbálják hozzárendelni, vagy megpróbál hozzáférni az azonos nevű alaposztály tulajdonságához, ha az elérhető.

public class BaseClass
{
    private string _name = "Name-BaseClass";
    private string _id = "ID-BaseClass";

    public string Name
    {
        get { return _name; }
        set { }
    }

    public string Id
    {
        get { return _id; }
        set { }
    }
}

public class DerivedClass : BaseClass
{
    private string _name = "Name-DerivedClass";
    private string _id = "ID-DerivedClass";

    new public string Name
    {
        get
        {
            return _name;
        }

        // Using "protected" would make the set accessor not accessible.
        set
        {
            _name = value;
        }
    }

    // Using private on the following property hides it in the Main Class.
    // Any assignment to the property will use Id in BaseClass.
    new private string Id
    {
        get
        {
            return _id;
        }
        set
        {
            _id = value;
        }
    }
}

class MainClass
{
    static void Main()
    {
        BaseClass b1 = new BaseClass();
        DerivedClass d1 = new DerivedClass();

        b1.Name = "Mary";
        d1.Name = "John";

        b1.Id = "Mary123";
        d1.Id = "John123";  // The BaseClass.Id property is called.

        System.Console.WriteLine("Base: {0}, {1}", b1.Name, b1.Id);
        System.Console.WriteLine("Derived: {0}, {1}", d1.Name, d1.Id);

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
    Base: Name-BaseClass, ID-BaseClass
    Derived: John, ID-BaseClass
*/

Megjegyzések

Figyelje meg, hogy ha lecseréli a deklarációt new private string Idnew public string Id, a kimenet a következő lesz:

Name and ID in the base class: Name-BaseClass, ID-BaseClass Name and ID in the derived class: John, John123

Lásd még

  • Last updated on