Partager via

protected internal (Référence C#)

La combinaison de protected internal mots clés est un modificateur d’accès aux membres. 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 des protected internal 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 située dans un autre assembly uniquement si l’accès se produit via une variable du type de classe dérivé. Par exemple, considérez le segment 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, BaseClasset une autre classe. TestAccess BaseClass possède un membre interne protégé, myValue, accessible par le type TestAccess, car ils se trouvent dans le même assembly. Dans le deuxième fichier, une tentative d’accès myValue via une instance de BaseClass générera une erreur, tandis qu’un accès à ce membre via une instance d’une classe DerivedClass dérivée réussira. Cela montre qu’il protected internal autorise l’accès à partir de n’importe quelle classe au sein du même assembly ou des classes dérivées dans n’importe quel assembly, ce qui en fait le plus permissif des modificateurs d’accès protégés.

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

Substitution de membres internes protégés

Lors de la substitution d’un membre virtuel, le modificateur d’accessibilité de la méthode substituée dépend de l’assembly où la classe dérivée est définie.

Lorsque la classe dérivée est définie dans le même assembly que la classe de base, tous les membres remplacés ont un accès protected internal. Si la classe dérivée est définie dans un assembly différent de la classe de base, les membres substitués ont un 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

  • Last updated on