Toegankelijkheid van accessor beperken (C#-programmeerhandleiding)

Artikel
03/02/2024

De get- en set-gedeelten van een eigenschap of indexeerfunctie worden accessors genoemd. Deze accessors hebben standaard hetzelfde zichtbaarheids- of toegangsniveau van de eigenschap of indexeerfunctie waartoe ze behoren. Zie toegankelijkheidsniveaus voor meer informatie. Het is echter soms handig om de toegang tot een van deze accessors te beperken. Normaal gesproken beperkt u de toegankelijkheid van de set accessor, terwijl de get toegangsrechten openbaar toegankelijk blijven. Voorbeeld:

private string _name = "Hello";

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

In dit voorbeeld definieert een eigenschap met de naam Name een get en set accessor. De get toegangsfunctie ontvangt het toegankelijkheidsniveau van de eigenschap zelf, public terwijl de set toegangsfunctie expliciet wordt beperkt door de beveiligde toegangsaanpassing toe te passen op de toegangsfunctie zelf.

Notitie

In de voorbeelden in dit artikel worden geen automatisch geïmplementeerde eigenschappen gebruikt. Automatisch geïmplementeerde eigenschappen bieden een beknopte syntaxis voor het declareren van eigenschappen wanneer een aangepast back-upveld niet vereist is.

Beperkingen voor toegangsmodifiers voor accessors

Aan de hand van de wijzigingsfuncties voor accessor's voor eigenschappen of indexeerfuncties gelden deze voorwaarden:

U kunt geen toegangsbeheeraanpassingen gebruiken op een interface of een expliciete implementatie van interfaceleden .
U kunt alleen toegangsopties gebruiken als de eigenschap of indexeerfunctie zowel setget als accessors heeft. In dit geval is de wijzigingsfunctie toegestaan op slechts één van de twee accessors.
Als de eigenschap of indexeerfunctie een wijzigingsfunctie voor onderdrukking heeft, moet de wijzigingsfunctie van de toegangsfunctie overeenkomen met de toegangsfunctie van de overschreven toegangsfunctie, indien van toepassing.
Het toegankelijkheidsniveau van de toegangsfunctie moet meer beperkend zijn dan het toegankelijkheidsniveau van de eigenschap of indexeerfunctie zelf.

Toegangsmodifiers voor het overschrijven van accessors

Wanneer u een eigenschap of indexeerfunctie overschrijft, moeten de overschreven toegangsrechten toegankelijk zijn voor de onderdrukkingscode. Bovendien moet de toegankelijkheid van zowel de eigenschap/indexeerfunctie als de bijbehorende accessors overeenkomen met de bijbehorende overschreven eigenschap/indexeerfunctie en de bijbehorende toegangsrechten. Voorbeeld:

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; }
    }
}

Interfaces implementeren

Wanneer u een toegangsfunctie gebruikt om een interface te implementeren, heeft de toegangsfunctie mogelijk geen toegangsaanpassing. Als u echter de interface implementeert met behulp van één toegangsfunctie, zoals getde andere toegangsfunctie, heeft de andere toegangsaanpassing, zoals in het volgende voorbeeld:

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 { }
    }
}

Toegankelijkheidsdomein van Accessor

Als u een toegangsaanpassing voor de toegangsfunctie gebruikt, wordt het toegankelijkheidsdomein van de toegangsfunctie bepaald door deze wijzigingsfunctie.

Als u geen toegangsaanpassing hebt gebruikt voor de toegangsfunctie, wordt het toegankelijkheidsdomein van de toegangsfunctie bepaald door het toegankelijkheidsniveau van de eigenschap of indexeerfunctie.

Opmerking

Het volgende voorbeeld bevat drie klassen, BaseClass, DerivedClassen MainClass. Er zijn twee eigenschappen op de BaseClassen NameId beide klassen. In het voorbeeld ziet u hoe de eigenschap IdDerivedClass kan worden verborgen door de eigenschap Id waarop BaseClass u een beperkende toegangsaanpassing gebruikt, zoals beveiligd of privé. Wanneer u waarden aan deze eigenschap toewijst, wordt de eigenschap in de BaseClass klasse daarom in plaats daarvan aangeroepen. Als u de toegangsaanpassing door openbaar vervangt, wordt de eigenschap toegankelijk.

In het voorbeeld ziet u ook dat een beperkende wijzigingsfunctie voor toegang, zoals private of protected, op de set toegangsfunctie van de Name eigenschap, DerivedClass de toegang tot de toegangsfunctie in de afgeleide klasse voorkomt. Er wordt een fout gegenereerd wanneer u hieraan toewijst of de eigenschap van de basisklasse van dezelfde naam opent, als deze toegankelijk is.

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
*/

Opmerkingen

Als u de declaratie new private string Id vervangt door new public string Id, krijgt u de uitvoer:

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

Delen via