Einschränken des Zugriffsmethodenzugriffs (C#-Programmierhandbuch)Restricting Accessor Accessibility (C# Programming Guide)

Die Get- und Set-Teile einer Eigenschaft oder eines Indexers werden Zugriffsmethoden oder Accessoren genannt.The get and set portions of a property or indexer are called accessors. Standardmäßig weisen diese Zugriffsmethoden dieselbe Sichtbarkeit oder Zugriffsebene auf: nämlich die der Eigenschaft oder des Indexers, zu dem sie gehören.By default these accessors have the same visibility, or access level: that of the property or indexer to which they belong. Weitere Informationen finden Sie unter Zugriffsebenen.For more information, see accessibility levels. Allerdings ist es manchmal sinnvoll, den Zugriff auf eine der beiden Zugriffsmethoden einzuschränken.However, it is sometimes useful to restrict access to one of these accessors. Dies bedeutet in der Regel, dass der Zugriff auf den set-Accessor eingeschränkt wird, während der get-Accessor öffentlich zugänglich bleibt.Typically, this involves restricting the accessibility of the set accessor, while keeping the get accessor publicly accessible. Zum Beispiel:For example:

private string name = "Hello";

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

In diesem Beispiel definiert die Eigenschaft Name einen get- und einen set-Accessor.In this example, a property called Name defines a get and set accessor. Der get-Accessor erhält die Zugriffsebene der Eigenschaft selbst, in diesem Fall public. Der set-Accessor wird jedoch explizit durch Anwenden des Protected-Zugriffsmodifizierers auf den Accessor selbst eingeschränkt.The get accessor receives the accessibility level of the property itself, public in this case, while the set accessor is explicitly restricted by applying the protected access modifier to the accessor itself.

Einschränkungen für Zugriffsmodifizierer für AccessorenRestrictions on Access Modifiers on Accessors

Bei der Verwendung von Accessormodifizierern auf Eigenschaften oder Indexer muss Folgendes beachtet werden:Using the accessor modifiers on properties or indexers is subject to these conditions:

  • Accessormodifizierer können nicht bei einer Schnittstelle oder einer expliziten Schnittstellen-Member-Implementierung verwendet werden.You cannot use accessor modifiers on an interface or an explicit interface member implementation.

  • Accessormodifizierer können nur verwendet werden, wenn die Eigenschaft oder der Indexer sowohl einen set- als auch einen get-Accessor besitzt.You can use accessor modifiers only if the property or indexer has both set and get accessors. In diesem Fall ist der Modifizierer nur für einen der beiden Accessoren zulässig.In this case, the modifier is permitted on one only of the two accessors.

  • Besitzt die Eigenschaft oder der Indexer einen Override-Modifizierer, muss der Accessormodifizierer mit dem eventuell vorhandenen Accessor des überschriebenen Accessors übereinstimmen.If the property or indexer has an override modifier, the accessor modifier must match the accessor of the overridden accessor, if any.

  • Die Zugriffsebene des Accessors muss restriktiver sein als die Zugriffsebene der Eigenschaft oder des Indexers selbst.The accessibility level on the accessor must be more restrictive than the accessibility level on the property or indexer itself.

Zugriffsmodifizierer für Override-AccessorenAccess Modifiers on Overriding Accessors

Beim Überschreiben einer Eigenschaft oder eines Indexers müssen die überschriebenen Accessoren für den überschreibenden Code zugänglich sein.When you override a property or indexer, the overridden accessors must be accessible to the overriding code. Außerdem müssen die Zugriffsebenen der Eigenschaft/des Indexers als auch der Accessoren mit der entsprechenden überschriebenen Eigenschaft/dem Indexer und den Accessoren übereinstimmen.Also, the accessibility level of both the property/indexer, and that of the accessors must match the corresponding overridden property/indexer and the accessors. Zum Beispiel:For example:

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

Implementieren von SchnittsellenImplementing Interfaces

Bei der Verwendung eines Accessors zur Implementierung einer Schnittstelle darf der Accessor keinen Zugriffsmodifizierer besitzen.When you use an accessor to implement an interface, the accessor may not have an access modifier. Wird jedoch zur Implementierung der Schnittstelle nur ein Accessor verwendet, z.B. get, kann der andere Accessor einen Zugriffsmodifizierer besitzen. Hier ein Beispiel:However, if you implement the interface using one accessor, such as get, the other accessor can have an access modifier, as in the following example:

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

Zugriffsdomäne des AccessorsAccessor Accessibility Domain

Bei Verwendung eines Zugriffsmodifizierers für den Accessor wird die Zugriffsdomäne des Accessors durch diesen Modifizierer bestimmt.If you use an access modifier on the accessor, the accessibility domain of the accessor is determined by this modifier.

Andernfalls wird die Zugriffsdomäne des Accessors durch die Zugriffsebene der Eigenschaft oder des Indexers bestimmt.If you did not use an access modifier on the accessor, the accessibility domain of the accessor is determined by the accessibility level of the property or indexer.

BeispielExample

Das folgende Beispiel enthält drei Klassen: BaseClass, DerivedClass und MainClass.The following example contains three classes, BaseClass, DerivedClass, and MainClass. Für BaseClass gibt es zwei Eigenschaften, Name und Id für beide Klassen.There are two properties on the BaseClass, Name and Id on both classes. Das Beispiel veranschaulicht, wie die Eigenschaft Id in DerivedClass durch die Eigenschaft Id in BaseClass ausgeblendet werden kann, wenn ein restriktiver Zugriffsmodifizierer, wie z.B. protected oder private, verwendet wird.The example demonstrates how the property Id on DerivedClass can be hidden by the property Id on BaseClass when you use a restrictive access modifier such as protected or private. Daher wird beim Zuweisen von Werten zu dieser Eigenschaft stattdessen die Eigenschaft für die Klasse BaseClass aufgerufen.Therefore, when you assign values to this property, the property on the BaseClass class is called instead. Wird der Zugriffsmodifizierer durch public ersetzt, kann auf die Eigenschaft zugegriffen werden.Replacing the access modifier by public will make the property accessible.

Das Beispiel zeigt auch, dass die Verwendung eines restriktiven Zugriffsmodifizierers, wie z.B. private oder protected, auf den set-Accessor der Eigenschaft Name in DerivedClass den Zugriff auf den Accessor verhindert. Mit dem Zuweisen zu dem Accessor wird ein Fehler generiert.The example also demonstrates that a restrictive access modifier, such as private or protected, on the set accessor of the Name property in DerivedClass prevents access to the accessor and generates an error when you assign to it.

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

KommentareComments

Beachten Sie, dass beim Ersetzen der Deklaration new private string Id durch new public string Id Folgendes ausgegeben wird:Notice that if you replace the declaration new private string Id by new public string Id, you get the output:

Name and ID in the base class: Name-BaseClass, ID-BaseClass

Name and ID in the derived class: John, John123

Siehe auchSee Also

C#-ProgrammierhandbuchC# Programming Guide
EigenschaftenProperties
IndexerIndexers
ZugriffsmodifiziererAccess Modifiers