Partager via

protégé interne (référence C#)

La combinaison de protected internal mots clés est un modificateur d’accès aux membres. Vous pouvez accéder à un membre interne protégé à partir de l’assembly actuel ou à partir de types dérivés de la classe conteneur. Pour obtenir une comparaison des protected internal 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#.

Tout type dans l’assembly conteneur peut accéder à un membre interne protégé d’une classe de base. Une classe dérivée située dans un autre assembly peut accéder au membre 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é, myValueauquel le TestAccess type accède, car il se trouver dans le même assembly. Dans le deuxième fichier, une tentative d’accès myValue via une instance de produit BaseClass une erreur, tandis qu’un accès à ce membre via une instance d’une classe DerivedClass dérivée réussit. Cette règle d’accès montre qu’elle 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

Lorsque vous remplacez un membre virtuel, le modificateur d’accessibilité de la méthode substituée dépend de l’assembly où vous définissez la classe dérivée.

Lorsque vous définissez la classe dérivée dans le même assembly que la classe de base, tous les membres substitués ont protected internal accès. Si vous définissez la classe dérivée dans un assembly différent de la classe de base, les membres substitués ont protected accès.

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