Partager via

protected (référence C#)

Le protected mot clé est un modificateur d’accès membre.

Remarque

Cet article traite de protected l’accès. Le mot-clé protected fait également partie des modificateurs d’accès protected internal et private protected.

Vous pouvez accéder à un membre protégé au sein de sa classe et par des instances de classe dérivées.

Pour obtenir une comparaison des protected autres modificateurs d’accès, consultez Niveaux d’accessibilité.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

Vous pouvez accéder à un membre protégé d’une classe de base dans une classe dérivée uniquement si l’accès se produit via le type de classe dérivé. Par exemple, considérez le segment de code suivant :

namespace Example1
{
    class BaseClass
    {
        protected int myValue = 123;
    }

    class DerivedClass : BaseClass
    {
        static void Main()
        {
            var baseObject = new BaseClass();
            var derivedObject = new DerivedClass();

            // Error CS1540, because myValue can only be accessed through
            // the derived class type, not through the base class type.
            // baseObject.myValue = 10;

            // OK, because this class derives from BaseClass.
            derivedObject.myValue = 10;
        }
    }
}

L’instruction baseObject.myValue = 10 génère une erreur, car elle accède au membre protégé via une référence de classe de base (baseObject est de type BaseClass). Vous pouvez uniquement accéder aux membres protégés par le biais du type de classe ou des types dérivés de celui-ci.

Contrairement à private protected, le modificateur d’accès protected autorise l’accès à partir de classes dérivées dans n’importe quel assembly. Contrairement protected internalà , il n’autorise pas l’accès à partir de classes non dérivées dans le même assembly.

Vous ne pouvez pas déclarer de membres de struct comme protégés, car les structs ne peuvent pas être hérités.

Dans cet exemple, la classe DerivedPoint est dérivée de Point. Par conséquent, vous pouvez accéder aux membres protégés de la classe de base directement à partir de la classe dérivée.

namespace Example2
{
    class Point
    {
        protected int x;
        protected int y;
    }

    class DerivedPoint: Point
    {
        static void Main()
        {
            var dpoint = new DerivedPoint();

            // Direct access to protected members.
            dpoint.x = 10;
            dpoint.y = 15;
            Console.WriteLine($"x = {dpoint.x}, y = {dpoint.y}");
        }
    }
    // Output: x = 10, y = 15
}

Si vous modifiez les niveaux d’accès et y les niveaux d’accès xprivés, le compilateur retourne les messages d’erreur :

'Point.y' is inaccessible due to its protection level.

'Point.x' is inaccessible due to its protection level.

L’exemple suivant montre que protected les membres sont accessibles à partir de classes dérivées même lorsqu’ils se trouvent dans différents assemblages :

// Assembly1.cs
// Compile with: /target:library
namespace Assembly1
{
    public class BaseClass
    {
        protected int myValue = 0;
    }
}

// Assembly2.cs
// Compile with: /reference:Assembly1.dll
namespace Assembly2
{
    using Assembly1;
    
    class DerivedClass : BaseClass
    {
        void Access()
        {
            // OK, because protected members are accessible from
            // derived classes in any assembly
            myValue = 10;
        }
    }
}

Cette accessibilité inter-assemblys est ce qui distingue protected de private protected (qui limite l'accès au même assembly), mais elle est similaire à protected internal (bien que protected internal autorise également l'accès au même assembly à partir de classes non dérivées).

Spécification du langage C#

Pour plus d’informations, consultez Accessibilité déclarée dans la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi

  • Last updated on