protected internal (Référence C#)

  • Article

La combinaison de mots clés protected internal est un modificateur d’accès de membre. Un membre interne protégé est accessible depuis l’assembly actif ou depuis des types dérivés de la classe conteneur. Pour obtenir une comparaison de protected internal et des autres modificateurs d’accès, consultez Niveaux d’accessibilité.

Exemple

Un membre interne protégé d’une classe de base est accessible depuis n’importe quel type au sein de son assembly conteneur. Il est également accessible dans une classe dérivée qui se trouve dans un autre assembly seulement si l’accès s’effectue via une variable du type de la classe dérivée. Prenons l’exemple de l’extrait de code suivant :

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

class TestAccess
{
    void Access()
    {
        var baseObject = new BaseClass();
        baseObject.myValue = 5;
    }
}

// Assembly2.cs
// Compile with: /reference:Assembly1.dll
class DerivedClass : BaseClass
{
    static void Main()
    {
        var baseObject = new BaseClass();
        var derivedObject = new DerivedClass();

        // Error CS1540, because myValue can only be accessed by
        // classes derived from BaseClass.
        // baseObject.myValue = 10;

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

Cet exemple contient deux fichiers : Assembly1.cs et Assembly2.cs. Le premier fichier contient une classe de base publique, BaseClass, et une autre classe, TestAccess. BaseClass possède un membre interne protégé, myValue, à laquelle le type TestAccess accède. Dans le deuxième fichier, une tentative d’accès à myValue via une instance de BaseClass génère une erreur, tandis qu’un accès à ce membre via une instance d’une classe dérivée, DerivedClass, réussit.

Les membres de struct ne peuvent pas être protected internal, car le struct ne peut pas être hérité.

Remplacement des membres internes protégés

Lors de la substitution d'un membre virtuel, le modificateur d'accessibilité de la méthode remplacée dépend de l’assemblée dans lequel la classe dérivée est définie.

Lorsque la classe dérivée est définie dans le même assemblée que la classe de base, tous les membres remplacés y ont accès protected internal. Si la classe dérivée est définie dans un assemblée différent de la classe de base, les membres remplacés ont accès protected.

// Assembly1.cs
// Compile with: /target:library
public class BaseClass
{
    protected internal virtual int GetExampleValue()
    {
        return 5;
    }
}

public class DerivedClassSameAssembly : BaseClass
{
    // Override to return a different example value, accessibility modifiers remain the same.
    protected internal override int GetExampleValue()
    {
        return 9;
    }
}

// Assembly2.cs
// Compile with: /reference:Assembly1.dll
class DerivedClassDifferentAssembly : BaseClass
{
    // Override to return a different example value, since this override
    // method is defined in another assembly, the accessibility modifiers
    // are only protected, instead of protected internal.
    protected override int GetExampleValue()
    {
        return 2;
    }
}

spécification du langage C#

Pour plus d'informations, voir 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