Dans un programme les différentes propriété d’une classe sont accessible de différentes manière selon leur utilisation. L’encapsulation définit que les membres propres au fonctionnement interne d’une classe ne doivent pas être exposé. Voici donc les mots-clé, ou modificateur de membre, permettant de définir l’accessibilité d’un membre.
Modificateurs d’accès
Comme évoque, le principe de l’encapsulation amène à déclarer différemment les propriétés et méthodes propre au fonctionnement interne d’une méthode. Au mot clé « public » fait donc opposition le mot-clé « private », mais aussi « protected ».
Public
Un membre public est exposé à l’extérieur de l’ensemble qui le déclare.
class Player {
public int number;
}
//--somewhere in program
Player player = new Player();
Console.Write(player.number);
//--
Ici, aucune restriction n’empêche d’accéder à number.
Internal
Un membre (ou une classe) internal est accessible à l’extérieur comme à l’intérieur d’une classe qui le déclare mais qu’au sein de l’assembly où il est déclaré. Elle se comportera comme un membre public mais ne sera pas accessible si elle provient d’une bibliothèque de classe par exemple.
La combinaison protected internal permet quant à elle d’étendre le comportement internal jusqu’à l’utilisation au sein des classe dérivées, même si celles-ci ont été déclarée dans une autre assembly.
Protected
Un membre protected n’est exposé qu’à l’intérieur de la classe qui le déclare et à l’intérieur des classes qui en dérive.
Toutefois, le membre d’instance pourra être accédé mais seulement à travers un objet d’une des classes dérivées et du type de cette dernière.
class Player {
protected int score=0;
public Player(){}
public GetScore(){
return score; //possible, inside base class
}
}
class Expert : Player {}
class Newbie : Player {
public Newbie (){}
public GetScore(){
return score; //possible, inside derived class
}
public GetMateScore(){
Newbie newbieMate = new Newbie ();
return newbieMate.score;//possible, same instance of derived class and in derived class scope
Expert expertMate = new Expert();
//return expertMate.score;//Impossible, other derived class
Player mate = new Player();
//return mate.score;//Impossible, base class
}
}
//--somewhere in program
Player player = new Player();
Newbie newbie = new Newbie();
//Console.Write(player.score); //Impossible, outside
//Console.Write(newbie.score); //Impossible, outside
//--
Protected répond notamment au besoin du principe d’encapsulation qui veut restreindre à l’utilisateur l’accès au code qui n’est pas nécessaire dans le reste de l’application.
La combinaison private protected (C# 7.2) permet quant à elle de limiter l’utilisation d’un membre protected à l’assembly où est présente la classe conteneur. Si on tente d’accéder au membre private protected dans une classe dérivée mais déclarée dans une autre assembly, une erreur d’accès sera affichée.
Private
Un membre private n’est accessible que dans la classe qui le déclare.
Toutefois, de la même manière que protected, le membre pourra être manipuler s’il est accédé depuis une instance de la classe qui la contient.
class Player {
private int age;
public Player(){}
public GetAge(){
Player otherPlayer = new Player();
return otherPlayer.age;//possible, instance of same class
return age; //possible, inside class
}
}
//--somewhere in program
Player player = new Player();
//Console.Write(player.age); //Impossible, outside
//--
Private répond notamment au besoin du principe d’encapsulation qui veut restreindre à l’utilisateur l’accès au code qui n’est pas nécessaire dans le reste de l’application.
Modificateurs spéciaux
D’autres modificateurs viennent agir sur différents éléments de code.
Virtual/Override
Le modificateur virtual laisse la possibilité, pour le membre ciblé, d’être substitué dans une classe dérivé. Dans cette dernière, il faudra précédé la déclaration du membre de override et lui définir un nouveau corps.
class Player {
protected string name;
public Player(){}
public virtual string GetName(){
return name;
}
}
class AnonymousPlayer : Player {
public Player(){}
public override string GetName(){
return "Anonymous";
}
}
Abstract
Le mot-clé abstract fonctionne de la même façon que virtual (et donc s’utilise avec ovveride) mais permet de ne pas avoir à définir une première implémentation de la méthode. Ce sera donc obligatoirement à un des enfants de définir la dite méthode. La déclaration de membre abstract impose que la méthode qui les contiennent soit aussi abstract.
abstract class Player {
protected string name;
public Player(){}
public abstract string GetName();
}
class PlayerChild : Player {
public PlayerChild(){}
public override string GetName(){
return "ChildClass";
}
}
Lorsque abstract est utiliser pour identifier une classe (contenant ou pas des membres abstract), elle ne pourra être instanciée : son utilisation sera limité à la dérivation.
Sealed
A l’inverse de l’utilisation de abstract ClassName qui impose l’instanciation, sealed ClassName empêche toute dérivation de la-dite classe.
Volatile (et Instruction Lock)
Dans le cas d’accès multithead, volatile vient identifier un membre susceptible d’être accéder via plusieurs thread. Initialement, une réorganisation non maitrisé vient ordonné la manière dont un objet est modifié par différents thread, ce qui peut donner des résultat aléatoire.
L’utilisation de volatile permet aux différents thread d’observer les écriture d’autres threads et d’assurer un comportement non aléatoire.
Pour terminer sur le Multithreading, et bien qu’il ne s’agisse pas d’un modificateur, l’instruction lock(obj){} permet de verrouiller un objet et d’exécuter le code contenu ; si un autre thread arrive au même point et constate qu’obj est verrouillé par un autre thread, il n’executera pas le code.
Sources
- https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/keywords/accessibility-levels
- https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/keywords/accessibility-domain
- https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/keywords/volatile
- https://docs.microsoft.com/fr-fr/dotnet/csharp/language-reference/keywords/index