Ograniczanie dostępności metody dostępu (Przewodnik programowania w języku C#)

Artykuł
06/10/2015

Uzyskać i set części właściwość lub indeksator są nazywane akcesorów.Domyślnie te akcesorów mają taką samą widoczność lub poziom dostępu: z właściwość lub indeksator, do których one należą.Aby uzyskać więcej informacji, zobacz poziomy dostępności.Jednak czasami jest przydatne do ograniczania dostępu do jednego z tych akcesorów.Zazwyczaj wymaga to ograniczenie dostępności set akcesor przy zachowaniu get akcesor publicznie.Na przykład:

private string name = "Hello";

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

W tym przykładzie właściwość o nazwie Name definiuje get i set akcesor.get Akcesor odbiera poziom dostępności, właściwości public w tym przypadku podczas set akcesor jest wyraźnie ograniczone przez zastosowanie chronione modyfikator dostępu do samej akcesor.

Ograniczenia dotyczące modyfikatorów dostępu

Za pomocą modyfikatorów akcesor właściwości lub indeksatory podlega następujące warunki:

Nie można używać modyfikatorów akcesor na interfejsie lub jawnej interfejsu Członkowskich wdrożenia.
Modyfikatory akcesor można użyć tylko wtedy, gdy właściwość lub indeksator mają zarówno set i get akcesorów.W tym przypadku modyfikator jest dozwolone na jednym tylko z dwóch akcesorów.
Jeśli właściwość lub indeksator zastąpić , modyfikator modyfikator akcesor musi odpowiadać akcesor akcesor przesłonięte, ewentualne.
Poziom dostępności na akcesor musi być bardziej restrykcyjny niż poziom dostępności na właściwość lub indeksator sam.

Modyfikatory dostępu na zastępowanie akcesorów

Zastąpić właściwość lub indeksator przesłonięte akcesorów muszą być dostępne dla kodu nadrzędnych.Również poziom dostępności zarówno właściwość/indeksatorze oraz że akcesorów musi odpowiadać odpowiednich zastąpiona właściwość/indeksowania i akcesorów.Na przykład:

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

Implementowanie interfejsów.

Akcesor umożliwia implementować interfejs, akcesor może nie mieć modyfikatora dostępu.Jednakże jeśli implementacji interfejsu, przy użyciu jeden akcesor, takich jak get, inne akcesor mogą mieć modyfikatora dostępu, jak w poniższym przykładzie:

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

Domeny ułatwień dostępu akcesora

Użycie modyfikatora dostępu na akcesor, domeny dostępności z akcesor jest określana modyfikator.

Jeśli nie użyto modyfikatora dostępu na akcesor, domeny ułatwień dostępu akcesora jest określany przez właściwość lub indeksator poziom dostępności.

Przykład

Poniższy przykład zawiera trzy klasy, BaseClass, DerivedClass, i MainClass.Istnieją dwie właściwości na BaseClass, Name i Id na obu klas.W przykładzie pokazano, jak właściwość Id na DerivedClass mogą być ukrywane przez właściwość Id na BaseClass kiedy używać modyfikatora dostępu ograniczające takie jak chronione lub prywatnego.W związku z tym, kiedy można przypisać wartości tej właściwości, właściwość na BaseClass nosi nazwę zamiast klasy.Zastępowanie modyfikator dostępu przez publicznych będzie udostępnić właściwość.

W przykładzie pokazano również, że modyfikator ograniczających dostęp, takie jak private lub protected, z set akcesor Name właściwość w DerivedClass uniemożliwia dostęp do akcesor i generuje błąd podczas przypisywania do niego.

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