Partager via

private protected (Référence C#)

La combinaison de private protected mots clés est un modificateur d’accès aux membres. Un membre protégé privé est accessible par les types dérivés de la classe conteneur, mais seulement au sein de son assembly conteneur. Pour obtenir une comparaison des private protected autres modificateurs d’accès, consultez Niveaux d’accessibilité.

Remarque

Le private protected modificateur d’accès est valide en C# version 7.2 et ultérieure.

Exemple :

Un membre protégé privé d’une classe de base est accessible à partir de types dérivés dans son assembly contenant uniquement si le type statique de la variable est le type de classe dérivé. Par exemple, considérez le segment de code suivant :

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

public class DerivedClass1 : BaseClass
{
    void Access()
    {
        var baseObject = new BaseClass();

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

        // OK, accessed through the current derived class instance
        myValue = 5;
    }
}

// Assembly2.cs
// Compile with: /reference:Assembly1.dll
class DerivedClass2 : BaseClass
{
    void Access()
    {
        // Error CS0122, because myValue can only be
        // accessed by types in Assembly1
        // myValue = 10;
    }
}

Cet exemple contient deux fichiers, Assembly1.cs et Assembly2.cs. Le premier fichier contient une classe de base publique, BaseClasset un type dérivé de celui-ci. DerivedClass1 BaseClass possède un membre protégé privé, myValue, qui DerivedClass1 peut accéder en tant que membre hérité dans le même assembly.

Dans le deuxième fichier, une tentative d’accès myValue en tant que membre DerivedClass2 hérité génère une erreur, car private protected les membres sont uniquement accessibles par les types dérivés dans le même assembly. Il s’agit de la différence clé par rapport à protected (qui autorise l’accès à partir de classes dérivées dans n’importe quel assembly) et protected internal (qui autorise l’accès depuis n’importe quelle classe au sein du même assembly ou des classes dérivées dans n’importe quel assembly).

Si Assembly1.cs contient un InternalsVisibleToAttribute qui nomme Assembly2, la classe dérivée DerivedClass2 aura accès à private protected membres déclarés dans BaseClass. InternalsVisibleTo rend les membres de private protected visibles par les classes dérivées dans d’autres assemblys.

Comparaison avec d’autres modificateurs d’accès protégés

Le tableau suivant résume les principales différences entre les trois modificateurs d’accès protégés :

Modificateur d'accès Même Assembly, classe dérivée Classe non dérivée, même assembly Assemblage différent, classe dérivée
protected ✔️ ❌ ✔️
protected internal ✔️ ✔️ ✔️
private protected ✔️ ❌ ❌
  • Utiliser protected lorsque vous souhaitez que des classes dérivées dans n’importe quel assembly accèdent au membre
  • Utilisez protected internal quand vous souhaitez l’accès le plus permissif (n’importe quelle classe dans le même assembly OU classes dérivées n’importe où)
  • Utilisez private protected quand vous souhaitez l’accès protégé le plus restrictif (uniquement les classes dérivées dans le même assembly)

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

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