Introduction aux modificateurs d'accès en C #
Cet article couvre le concept le plus élémentaire de la programmation orientée objet du point de vue du langage de programmation C #. Le concept est connu sous le nom de - Modificateurs d'accès. La toute première question à laquelle répondre est la suivante: que sont les modificateurs d'accès? Autrement dit, les modificateurs d'accès contrôlent quels objets / variables / constantes / méthodes (pratiquement tout) sont accessibles dans quelle partie du code. Les modificateurs d'accès jouent un rôle important dans la vérification du concept d'abstraction dans la programmation orientée objet. Ils contrôlent quelle partie du programme doit être et ne doit pas être visible pour l'utilisateur final. Bien sûr, un utilisateur final est moins concerné par les constantes et les variables impliquées dans l'algorithme. Il se préoccupe uniquement de la méthode qu'il doit invoquer pour obtenir la sortie.
Types de modificateurs d'accès en C #
C # nous fournit quatre types de modificateurs d'accès:
- Privé (le modificateur d'accès par défaut, sauf les énumérations et les interfaces)
- Protégé (légèrement restreint)
- Public (sans restriction, le choix par défaut pour les énumérations et les interfaces)
- Interne (public au sein de la même assemblée)
Outre ces quatre modificateurs d'accès, il existe deux autres combinaisons de niveaux d'accès:
- Interne protégé
- Privé protégé
Entendons-nous chacun avec un exemple.
1. Privé
Privé est le niveau d'accès le plus restreint. C'est également le modificateur d'accès par défaut pour toutes les constantes, variables, objets définis par l'utilisateur, etc. Seuls les énumérations et les interfaces sont publiques par défaut. Donc, si vous ne spécifiez aucun modificateur d'accès, C # lui affecte le modificateur par défaut.
Les objets privés ne sont pas accessibles en dehors du corps de la classe ou de la section struct ou programme dans laquelle ils sont déclarés. Toute tentative d'accéder à l'objet en dehors de la portée du corps dans lequel il est déclaré entraîne une erreur de compilation.
Exemple 1
using System;
class Employee //private by default
(
string name; //private by default
public string GetName()
(
return name;
)
public void SetName(string name)
(
this.name = name;
)
)
public class Program
(
public static void Main()
(
Employee emp = new Employee();
emp.SetName("John");
Console.Write("Employee name is " + emp.GetName());
// compile time error - 'Employee.name' is inaccessible due to its protection level
// Console.Write("Employee name is " + emp.name);
)
)
Sortie 1:
Exemple # 2
using System;
public class Program
(
public static void Main()
(
int x = 5; //private to the Main method, accessible inside nested code blocks in the Main method
if (true)
(
int y = 10; //private to the if block, not accessible outside if block
Console.WriteLine("x = " + x);
Console.WriteLine("y = " + y);
)
Console.WriteLine("x = " + x);
// compile-time error - The name 'y' does not exist in the current context.
// Console.WriteLine("y = " + y);
)
)
Sortie 2:
2. Protégé
Le spécificateur d'accès protégé restreint un objet à être accessible uniquement à partir d'instances dérivées de la classe. Ainsi, si un objet de classe enfant essaie d'accéder aux objets protégés d'une classe parent, il est autorisé. Les classes non dérivées ne peuvent pas accéder aux membres protégés d'une classe. Bien sûr, les objets protégés sont accessibles aux méthodes de leur propre classe.
Exemple
using System;
class Parent
(
protected string x;
public Parent()
(
x = "abc"; //accessible to own class methods
)
)
class Child : Parent // derived class
(
public static void Main()
(
var parentObj = new Parent();
var childObj = new Child();
Console.WriteLine(childObj.x); //accessible to derived class object instances
// compile-time error - Cannot access protected member 'Parent.x' via a qualifier of type 'Parent'; the qualifier must be of type 'Child' (or derived from it)
// Console.WriteLine(parentObj.x);
)
)
Sortie 3:
3. Public
Il s'agit du modificateur d'accès le moins restreint. Les objets publics sont pratiquement accessibles à l'ensemble du monde extérieur, ce qui en fait le modificateur d'accès le plus élevé autorisé. Bien sûr, cela a un coût élevé - le coût de la moindre protection.
Les membres publics sont accessibles par n'importe quelle partie du code. Cela les rend moins sûrs. Toute logique de code peut modifier leur valeur, ce qui peut entraîner un comportement inattendu. Il faut donc être très prudent avant de rendre public un objet.
Dans la même classe Employee que nous avons créée dans notre exemple de modificateur d'accès privé, si nous modifions le niveau d'accès au public, nous n'aurions pas besoin de méthodes Getter et Setter. En fait, la meilleure pratique consiste à rendre l'objet privé et à utiliser les propriétés C # Getter et Setter.
Exemple
using System;
class Employee
(
public string name;
)
public class Program
(
public static void Main()
(
Employee emp = new Employee();
emp.name = "John";
Console.Write("Employee name is " + emp.name);
)
)
Sortie 4:
4. Interne
Les objets et méthodes internes ne sont accessibles que dans le même assembly. Il s'agit d'un modificateur d'accès très utile lorsque vous souhaitez rendre n'importe quel objet public et que vous souhaitez restreindre son accès uniquement au cadre que vous codez.
Ainsi, par essence, tous les objets internes sont accessibles par toutes les zones du même assemblage.
Créons deux applications console pour comprendre ce fonctionnement.
Exemple
Étape 1: Créez une application console C # et placez-y le code ci-dessous:
using System;
namespace ConsoleApp1
(
public class Parent
(
internal int x;
public Parent()
(
x = 10;
)
)
public class Program
(
public static void Main()
(
var parentObj = new Parent();
// accessible within the same assembly
Console.Write("The value of x = " + parentObj.x);
)
)
)
Étape 2: créez la solution pour obtenir le fichier .dll à partir du dossier bin.
Étape 3: créez une autre application de console et référencez le fichier d'assemblage à partir de ConsoleApp1. Cliquez sur Ajouter une référence dans l'image ci-dessous et recherchez l'emplacement du fichier .dll à partir de l'étape 2. Il doit être similaire à ~ / ConsoleApp1 / bin / Debug / ConsoleApp1.dll.
Après avoir ajouté le fichier .dll, vous devriez le trouver sous Assemblys.
Étape4: Placez le code ci-dessous dans ConsoleApp2.
using System;
using ConsoleApp1; //referencing the first assembly
namespace ConsoleApp2
(
class Program
(
static void Main(string() args)
(
var parentObj = new Parent();
//not accessible outside the assembly
Console.Write(parentObj.x);
)
)
)
Étape 5: lorsque vous créez ConsoleApp2, vous obtenez une erreur de compilation indiquant que «x» de ConsoleApp1 n'est pas accessible dans d'autres assemblys en raison de son niveau de protection.
5. Interne protégé
Il s'agit d'une combinaison de modificateurs d'accès protégés et internes. Un concept important à comprendre ici est que Protégé Interne signifie Protégé OU Interne. Il s'agit d'une union des deux modificateurs d'accès. Il ne faut jamais penser qu'il s'agit d'une intersection.
Ainsi, les objets internes ne sont pas accessibles en dehors de l'assembly, tandis que les objets protégés sont accessibles à toute classe dérivée dans n'importe quel assembly. Que faire si je souhaite protéger mon objet uniquement dans d'autres assemblages et non dans le même assemblage? Solution simple - déclarez-la comme protégée en interne.
Exemple
Étape 1: Modifions notre ConsoleApp1 pour refléter le code ci-dessous. Notez que nous avons changé le niveau d'accès de notre variable «x» en interne protégé.
using System;
namespace ConsoleApp1
(
public class Parent
(
protected internal int x;
public Parent()
(
x = 10;
)
)
public class Program
(
public static void Main()
(
var parentObj = new Parent();
// accessible within the same assembly
Console.Write("The value of x = " + parentObj.x);
)
)
)
Étape 2: Générez à nouveau la solution et remplacez le .dll dans ConsoleApp2 par celui mis à jour.
Étape 3: Mettez à jour le code dans ConsoleApp2 comme ci-dessous:
using System;
using ConsoleApp1; //referencing the first assembly
namespace ConsoleApp2
(
class Program: Parent
(
static void Main(string() args)
(
var progObj = new Program();
//accessible only via an object of the derived class.
Console.Write(progObj.x);
Console.Read();
)
)
)
Étape 4: Exécutez ConsoleApp2 pour voir la sortie.
6. Privé protégé
Il s'agit d'une combinaison d'union de modificateurs d'accès privé et protégé. Protégé Interne signifie Protégé OU Interne. Ainsi, les objets privés ne sont pas accessibles en dehors du bloc de code dans lequel il est déclaré, tandis que les objets protégés sont accessibles à toute classe dérivée dans n'importe quel assembly. Que faire si je souhaite restreindre l'accès à mon objet même dans les classes dérivées d'autres assemblys? Solution simple - déclarez-la comme protégée en interne.
Exemple
Modifions le niveau d'accès de 'x' dans ConsoleApp1 à Private Protected.
using System;
namespace ConsoleApp1
(
public class Parent
(
private protected int x;
public Parent()
(
x = 10;
)
)
public class Child: Parent (
public void DisplayX() (
// accessible only via derived class objects
Console.Write("Value of x = " + x);
)
)
public class Program
(
public static void Main()
(
var childObj = new Child();
childObj.DisplayX();
Console.Read();
)
)
)
Production:
Comparaison tabulaire
| Spécificateur d'accès | Même assemblage | Autre Assemblée | |||
| Même classe | Classe dérivée | Classe non dérivée | Classe dérivée | Classe non dérivée | |
| Privé | Oui | Non | Non | Non | Non |
| Publique | Oui | Oui | Oui | Oui | Oui |
| Protégé | Oui | Oui | Non | Oui | Non |
| Interne | Oui | Oui | Oui | Non | Non |
| Interne protégé | Oui | Oui | Oui | Oui | Non |
| Privé protégé | Oui | Oui | Non | Non | Non |
Conclusion
Nous avons vu dans l'article ci-dessus que les modificateurs d'accès contrôlent l'accès à tout dans le projet. Différentes combinaisons de niveaux d'accès couvrent les besoins de divers types d'accessibilité. Les développeurs doivent choisir judicieusement en gardant à l'esprit la sécurité et la nécessité absolue que l'objet soit accessible dans un certain bloc de code.
Articles recommandés
Ceci est un guide des modificateurs d'accès en C #. Ici, nous avons discuté des types d'introduction des modificateurs d'accès en C # ainsi que des exemples et des sorties. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus–
- Compilateurs C #
- Destructeur en C #
- Qu'est-ce que TypeScript?
- Qu'est-ce que les services Web ASP.Net?
- Modificateurs d'accès en PHP
- Méthodes de travail et Top 3 Enum en C #