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.

Méthode C# Portée des variables C#

Langue C