Modificateurs d'accès C#
Modificateurs d'accès C#
Dans ce didacticiel, nous découvrirons les modificateurs d'accès public, privé, protégé et interne en C# à l'aide d'exemples.
En C#, les modificateurs d'accès spécifient l'accessibilité des types (classes, interfaces, etc.) et des membres de type (champs, méthodes, etc.). Par exemple,
class Student {
public string name;
private int num;
}
Ici,
- nom - champ public accessible de n'importe où
- nombre - le champ privé n'est accessible qu'au sein de l'étudiant classe
Types de modificateurs d'accès
En C#, il existe 4 types de base de modificateurs d'accès.
- public
- privé
- protégé
- interne
1. modificateur d'accès public
Lorsque nous déclarons un type ou un membre de type public
, il est accessible de n'importe où. Par exemple,
using System;
namespace MyApplication {
class Student {
public string name = "Sheeran";
public void print() {
Console.WriteLine("Hello from Student class");
}
}
class Program {
static void Main(string[] args) {
// creating object of Student class
Student student1 = new Student();
// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);
// accessing print method from Student
student1.print();
Console.ReadLine();
}
}
}
Sortie
Name: Sheeran Hello from Student class
Dans l'exemple ci-dessus, nous avons créé une classe nommée Student avec un champ nom et une méthode print() .
// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);
// accessing print method from Student
student1.print();
Comme le champ et la méthode sont publics, nous pouvons y accéder depuis le Programme classe.
Remarque :Nous avons utilisé l'objet student1 de l'étudiant classe pour accéder à ses membres. Pour en savoir plus, visitez la Classe et objets C# .
2. modificateur d'accès privé
Lorsque nous déclarons un membre de type avec le private
modificateur d'accès, il n'est accessible qu'au sein du même class
ou struct
. Par exemple,
using System;
namespace MyApplication {
class Student {
private string name = "Sheeran";
private void print() {
Console.WriteLine("Hello from Student class");
}
}
class Program {
static void Main(string[] args) {
// creating object of Student class
Student student1 = new Student();
// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);
// accessing print method from Student
student1.print();
Console.ReadLine();
}
}
}
Dans l'exemple ci-dessus, nous avons créé une classe nommée Student avec un champ nom et une méthode print() .
// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);
// accessing print method from Student
student1.print();
Étant donné que le champ et la méthode sont privés, nous ne pouvons pas y accéder depuis le Programme classer. Ici, le code générera l'erreur suivante.
Error CS0122 'Student.name' is inaccessible due to its protection level
Error CS0122 'Student.print()' is inaccessible due to its protection level
3. modificateur d'accès protégé
Lorsque nous déclarons un membre de type comme protected
, il n'est accessible qu'à partir de la même classe et de ses classes dérivées. Par exemple,
using System;
namespace MyApplication {
class Student {
protected string name = "Sheeran";
}
class Program {
static void Main(string[] args) {
// creating object of student class
Student student1 = new Student();
// accessing name field and printing it
Console.WriteLine("Name: " + student1.name);
Console.ReadLine();
}
}
}
Dans l'exemple ci-dessus, nous avons créé une classe nommée Student avec un champ nom . Comme le champ est protégé, nous ne pouvons pas y accéder depuis le Programme classe.
Ici, le code générera l'erreur suivante.
Error CS0122 'Student.name' is inaccessible due to its protection level
Maintenant, essayons d'accéder au protected
membre d'une classe dérivée.
using System;
namespace MyApplication {
class Student {
protected string name = "Sheeran";
}
// derived class
class Program : Student {
static void Main(string[] args) {
// creating object of derived class
Program program = new Program();
// accessing name field and printing it
Console.WriteLine("Name: " + program.name);
Console.ReadLine();
}
}
}
Sortie
Name: Sheeran
Dans l'exemple ci-dessus, nous avons créé une classe Student avec un champ protégé nom . Notez que nous avons hérité du Programme classe de l'Étudiant classe.
// accessing name field and printing it
Console.WriteLine("Name: " + program.name);
Depuis le protected
le membre est accessible à partir des classes dérivées, nous pouvons accéder à nom du Programme classe.
4. modificateur d'accès interne
Lorsque nous déclarons un type ou un membre de type comme internal
, il n'est accessible qu'au sein du même assemblage.
Un assemblage est une collection de types (classes, interfaces, etc.) et de ressources (données). Ils sont conçus pour fonctionner ensemble et former une unité logique de fonctionnalité.
C'est pourquoi, lorsque nous exécutons un assemblage, toutes les classes et interfaces à l'intérieur de l'assemblage s'exécutent ensemble. Pour en savoir plus, visitez l'assembly C#.
Exemple :interne au sein d'une même Assemblée
using System;
namespace Assembly {
class Student {
internal string name = "Sheeran";
}
class Program {
static void Main(string[] args) {
// creating object of Student class
Student theStudent = new Student();
// accessing name field and printing it
Console.WriteLine("Name: " + theStudent.name);
Console.ReadLine();
}
}
}
Sortie
Name: Sheeran
Dans l'exemple ci-dessus, nous avons créé une classe nommée Student avec un champ nom . Puisque le champ est internal
, nous pouvons y accéder depuis le Programme classe car ils sont dans le même assembly.
Si nous utilisons internal
au sein d'un seul assemblage, il fonctionne exactement comme le public
modificateur d'accès.
Exemple :interne dans un assemblage différent
Commençons par créer un assemblage.
// Code on Assembly1
using System;
namespace Assembly1 {
public class StudentName {
internal string name = "Sheeran";
}
class Program {
static void Main(string[] args) {
}
}
}
Ici, ce code est dans Assembly1 . Nous avons créé un champ interne nom à l'intérieur de la classe StudentName . Désormais, ce champ n'est accessible qu'à partir du même assembly Assembly1 .
Maintenant, créons un autre assemblage.
// Code on Assembly2
using System;
// access Assembly1
using Assembly1;
namespace Assembly2 {
class Program {
static void Main(string[] args) {
StudentName student = new StudentName();
// accessing name field from Assembly1
Console.Write(student.name);
Console.ReadLine();
}
}
}
Ici, ce code est dans Assembly2 . Nous essayons d'accéder au nom champ du StudentName classe(Assembly1 ).
Pour accéder aux champs de Assembly1 , nous devons d'abord définir la référence de Assembly1 dans Assembly2 . Maintenant le code
using Assembly1;
nous permet d'utiliser le code de Assembly1 à Assemblée2 .
Ici, lorsque nous essayons d'accéder au nom champ de Assembly2 , nous obtenons une erreur.
Error CS0122 'StudentName.name' is inaccessible due to its protection level
C'est parce que nom est un champ interne présent dans Assembly1 .
5. modificateur d'accès interne protégé
Le protected internal
est une combinaison de protected
et internal
modificateurs d'accès.
Quand on déclare un membre protected internal
, il est accessible depuis le même assembly et la classe dérivée de la classe conteneur depuis n'importe quel autre assembly.
// Code on Assembly1
using System;
namespace Assembly1 {
public class Greet {
protected internal string msg="Hello";
}
class Program {
static void Main(string[] args) {
Greet greet = new Greet();
Console.WriteLine(greet.msg);
Console.ReadLine();
}
}
}
Sortie
Hello
Le code ci-dessus est dans Assembly1 .
Dans l'exemple ci-dessus, nous avons créé une classe nommée Greet avec un champ msg . Étant donné que le champ est protégé en interne, nous pouvons y accéder depuis le Programme classe car ils sont dans le même assembly.
Dérivons une classe de Greet dans un autre assembly et essayez d'accéder au champ interne protégé msg d'elle.
// Code on Assembly2
using System;
// access Assembly1
using Assembly1;
namespace Assembly2 {
// derived class of Greet
class Program: Greet {
static void Main(string[] args) {
Program greet = new Program();
// accessing name field from Assembly1
Console.Write(greet.msg);
Console.ReadLine();
}
}
}
Sortie
Hello
Le code ci-dessus est dans Assembly2 .
Dans l'exemple ci-dessus, nous avons hérité du Programme classe du Greet classe (de Assembly1 ).
// accessing name field from Assembly1
Console.Write(greet.msg);
Nous pouvons accéder au msg du salut classe de Assembly1 de Assemblée2 .
C'est parce que le msg est un champ interne protégé et nous essayons d'y accéder à partir de la classe enfant de Greet .
6. modificateur d'accès protégé privé
Le private protected
le modificateur d'accès est une combinaison de private
et protected
. Il est disponible à partir de la version 7.2 de C# et des versions ultérieures.
Quand on déclare un membre private protected
, il n'est accessible qu'au sein de la même classe et sa classe dérivée au sein du même assembly. Par exemple,
// Code in Assembly1
using System;
namespace Assembly1 {
public class StudentName {
private protected string name = "Sheeran";
}
//derived class of StudentName class
class Program1 : StudentName {
static void Main(string[] args) {
Program1 student = new Program1();
// accessing name field from base class
Console.Write(student.name);
Console.ReadLine();
}
}
}
Sortie
Sheeran
Le code ci-dessus est dans Assembly1
Dans l'exemple ci-dessus, nous avons créé une classe StudentName avec un private protected
champ nom .
Notez que nous avons hérité du Program1 classe de StudentName classe.
Depuis le private protected
membre est accessible à partir de classes dérivées au sein du même assembly, nous pouvons accéder à nom du Program1 classe.
Dérivons une classe de StudentName dans un autre assembly et essayez d'accéder au champ protégé privé nom à partir de cela. Par exemple,
// Code in Assembly2
using System;
//access Assembly1
using Assembly1;
namespace Assembly2 {
//derived class of StudentName
class Program : StudentName {
static void Main(string[] args) {
Program student = new Program();
// accessing name field from Assembly1
Console.Write(student.name);
Console.ReadLine();
}
}
}
Le code ci-dessus est dans Assembly2
Dans l'exemple ci-dessus, lorsque nous essayons d'accéder au nom champ de la classe dérivée de StudentName , nous obtenons une erreur.
Error CS0122 'StudentName.name' is inaccessible due to its protection level
C'est parce que le nom le champ est dans Assembly1 et la classe dérivée est dans Assembly2 .
Remarque :On peut aussi utiliser des modificateurs d'accès avec des types (classes, interface, etc). Cependant, nous ne pouvons utiliser que des types avec des modificateurs d'accès publics et internes.
Langue C