Restriction d’accessibilité de l’accesseur (Guide de programmation C#)Restricting Accessor Accessibility (C# Programming Guide)

Les parties get et set d’une propriété ou d’un indexeur sont appelées accesseurs.The get and set portions of a property or indexer are called accessors. Par défaut, ces accesseurs ont la visibilité ou le niveau d’accès de la propriété ou de l’indexeur auquel ils appartiennent.By default these accessors have the same visibility or access level of the property or indexer to which they belong. Pour plus d’informations, consultez Niveaux d’accessibilité.For more information, see accessibility levels. Toutefois, il peut parfois s’avérer utile de restreindre l’accès à l’un de ces accesseurs.However, it is sometimes useful to restrict access to one of these accessors. En général, cela implique de restreindre l’accessibilité de l’accesseur set, tout en gardant l’accesseur get publiquement accessible.Typically, this involves restricting the accessibility of the set accessor, while keeping the get accessor publicly accessible. Par exemple :For example:

private string _name = "Hello";

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

Dans cet exemple, une propriété appelée Name définit un accesseur get et set.In this example, a property called Name defines a get and set accessor. L’accesseur get reçoit le niveau d’accessibilité de la propriété elle-même, public dans le cas présent, alors que l’accesseur set est restreint explicitement par l’application du modificateur d’accès protected à l’accesseur lui-même.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.

Restrictions sur les modificateurs d’accès sur les accesseursRestrictions on Access Modifiers on Accessors

L’utilisation de modificateurs d’accesseurs sur les propriétés ou les indexeurs est soumise aux conditions suivantes :Using the accessor modifiers on properties or indexers is subject to these conditions:

  • Vous ne pouvez pas utiliser de modificateurs d’accesseur sur une interface ou sur une implémentation de membre d’interface explicite.You cannot use accessor modifiers on an interface or an explicit interface member implementation.

  • Vous pouvez utiliser les modificateurs d’accesseur uniquement si la propriété ou l’indexeur dispose à la fois d’accesseurs set et get.You can use accessor modifiers only if the property or indexer has both set and get accessors. Dans ce cas, le modificateur est autorisé uniquement sur l’un des deux accesseurs.In this case, the modifier is permitted on only one of the two accessors.

  • Si la propriété ou l’indexeur possède un modificateur override, le modificateur d’accesseur doit correspondre à l’accesseur de l’accesseur substitué, le cas échant.If the property or indexer has an override modifier, the accessor modifier must match the accessor of the overridden accessor, if any.

  • Le niveau d’accessibilité sur l’accesseur doit être plus restrictif que le niveau d’accessibilité sur la propriété ou l’indexeur eux-mêmes.The accessibility level on the accessor must be more restrictive than the accessibility level on the property or indexer itself.

Modificateurs d’accès sur les accesseurs de substitutionAccess Modifiers on Overriding Accessors

Quand vous substituez une propriété ou un indexeur, les accesseurs remplacés doivent être accessibles au code de substitution.When you override a property or indexer, the overridden accessors must be accessible to the overriding code. Par ailleurs, l’accessibilité de la propriété/l’indexeur et de ses accesseurs doivent correspondre à la propriété/l’indexeur et à ses accesseurs substitués.Also, the accessibility of both the property/indexer and its accessors must match the corresponding overridden property/indexer and its accessors. Par exemple :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; }
    }
}

Implémentation des interfacesImplementing Interfaces

Quand vous utilisez un accesseur pour implémenter une interface, l’accesseur peut ne pas avoir de modificateur d’accès.When you use an accessor to implement an interface, the accessor may not have an access modifier. Toutefois, si vous implémentez l’interface à l’aide d’un accesseur, tel que get, l’autre accesseur peut avoir un modificateur d’accès, comme dans l’exemple suivant :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 { }
    }
}

Domaine d’accessibilité de l’accesseurAccessor Accessibility Domain

Si vous utilisez un modificateur d’accès sur l’accesseur, le domaine d’accessibilité de l’accesseur est déterminé par ce modificateur.If you use an access modifier on the accessor, the accessibility domain of the accessor is determined by this modifier.

Si vous n’avez pas utilisé un modificateur d’accès sur l’accesseur, le domaine d’accessibilité de l’accesseur est déterminé par le niveau d’accessibilité de la propriété ou de l’indexeur.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.

ExemplesExample

L’exemple suivant contient trois classes, BaseClass, DerivedClass et MainClass.The following example contains three classes, BaseClass, DerivedClass, and MainClass. Il y a deux propriétés sur BaseClass, Name et Id sur les deux classes.There are two properties on the BaseClass, Name and Id on both classes. L’exemple montre comment la propriété Id sur DerivedClass peut être masquée par la propriété Id sur BaseClass quand vous utilisez un modificateur d’accès restrictif tel que protected ou private.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. Par conséquent, quand vous affectez des valeurs à cette propriété, la propriété sur la classe BaseClass est appelée à la place.Therefore, when you assign values to this property, the property on the BaseClass class is called instead. Le remplacement du modificateur d’accès par public rend la propriété accessible.Replacing the access modifier by public will make the property accessible.

L’exemple montre également qu’un modificateur d’accès restrictif, tel que private ou protected, sur l’accesseur set de la propriété Name dans DerivedClass empêche l’accès à l’accesseur et génère une erreur quand vous lui affectez une valeur.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
*/

CommentairesComments

Notez que si vous remplacez la déclaration new private string Id par new public string Id, vous obtenez la sortie suivante :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

Voir aussiSee also