C # Protégé

Les modificateurs d'accès sont des mots clés en C # utilisés pour spécifier un niveau d'accessibilité pour toutes les classes, les membres de la classe et les types de données. Ceux-ci sont principalement utilisés pour éviter les changements de données involontaires par des programmes ou des classes tiers. Les modificateurs d'accès sont utilisés pour protéger les membres qui ne sont pas prêts à être utilisés par le public. Les développeurs apprécient les modificateurs d'accès car ils simplifient le code de lecture et d'écriture. De tous les modificateurs d'accès, le modificateur d'accès protégé est l'un des plus importants. Dans cet article, nous discuterons du modificateur d'accès fondamental qui est un modificateur «protégé». «Protégé» est un mot-clé en C # qui restreint l'accès aux membres d'une classe.

Quel est le modificateur protégé en C # dans Ubuntu 20.04?

Le modificateur protégé se situe entre les domaines du modificateur d'accès privé et public. C'est similaire à Private, mais il permet aux classes dérivées d'accéder au membre. D'autres classes et objets ne peuvent pas voir les variables et fonctions des membres du modificateur protégé. Toutes les classes enfants ont accès à ce type de variable ou de fonction. Pour partager des fonctionnalités utiles aux classes dérivées, nous utilisons des mots clés protégés.

Syntaxe du modificateur protégé en C # dans Ubuntu 20.04:

Le modificateur d'accès protégé a la syntaxe suivante:

Classe publique Classe_Name

Classe protégée Child_class

// corps de classe infantile

L'implémentation précédente du modificateur protégé est utilisée dans le langage de programmation C #. Nous devons utiliser des mots clés protégés avec la classe ou avec le membre de la classe. Nous ne pouvons que déclarer une classe comme protégée dans les classes imbriquées. Il n'est pas possible de le spécifier dans un espace de noms. Le modificateur d'accès protégé peut être utilisé de trois manières différentes en C #:

1. Protégé
2. Interne protégé
3. Privé protégé

Comment utiliser le modificateur protégé en C # dans Ubuntu 20.04?

Nous utilisons le mot-clé protégé dans le programme C # pour définir une classe comme protégé. Lorsque nous voulons fournir aux parents l'accès aux propriétés de leurs enfants, nous utilisons généralement le mot-clé protégé. Commençons à définir le mot-clé protégé en C #. Jetez un œil aux exemples fournis ci-dessous pour comprendre comment utiliser le modificateur protégé dans l'autre combinaison. Pour toutes les exécutions, nous avons utilisé Ubuntu 20.04.

Exemple n ° 1: Utilisation du modificateur d'accès protégé en C # dans Ubuntu 20.04

Nous pouvons utiliser le modificateur d'accès protégé pour limiter l'accès aux variables et aux méthodes pour programmer dans la même classe ou la même structure ou une classe dérivée. Le modificateur protégé permet aux classes qui étendent la classe pour accéder à ses membres, quel que soit l'assemblée. L'exemple suivant utilise un type de classe dérivé pour accéder aux membres protégés d'une classe de base dans une classe dérivée:

Le programme précédent a l'espace de noms «Program1» et, dans le bloc de l'espace de noms, nous avons défini la classe de nom «employé». La classe a exigé des variables créées avec le mot-clé «protégé». La première variable protégée a une chaîne de type définie avec le nom «empname». La deuxième variable protégée se voit attribuer le nom «Empdept», et la troisième variable protégée se voit attribuer le nom «Empage». Ensuite, la méthode «Employee» de classe est créée dans le bloc de classe et a donné le nom «GetEmployeedEtails».

Nous avons défini la méthode de classe avec le modificateur d'accès protégé. Dans le bloc de la méthode protégée, nous avons utilisé la méthode WriteLine, qui imprimera les valeurs des variables protégées utilisées dans la méthode protégée. Nous avons une autre classe, «SetInfo», définie comme la classe d'enfants de la classe parent «Employé». Dans la classe infantile, nous utilisons les membres protégés de la classe parent «employé» en le faisant référence à la classe infantile «SetInfo». L'objet «Employé» de classe parent «E» est défini comme invoqué par la classe parentale. L'objet pour la classe enfant «setInfo» est également créé comme «S». Les variables protégées sont initialisées avec les valeurs de la classe enfant. La méthode protégée de la classe parent est appelée la classe enfant et obtient les valeurs des variables.

Le résultat de l'utilisation des modificateurs protégés dans notre programme C # est affiché sur l'écran suivant qui montre un accès restreint à des types ou à des membres de la même classe ou de la classe infantile en fonction de nos besoins:

Exemple n ° 2: Utilisation du modificateur d'accès interne en C # dans Ubuntu 20.04

Le modificateur interne spécifie que l'accès est limité à l'assemblage existant dans le langage de programmation C #. Tout programme dans le même assemblage peut accéder au type ou au membre, mais pas à partir d'un autre assemblage.

Le programme précédent a l'espace de noms défini comme «programme2» dans lequel nous avons créé une classe «complexNumber» avec le mot-clé interne. La classe interne a deux déclarations variables en tant que «Real_number» et «img_number» de type entier. La classe interne a également déclaré une méthode publique comme «setvalues» et a créé un constructeur dans lequel nous avons dépassé deux objets comme «R» et «I». Ensuite, nous avons une autre méthode publique représentée avec le nom «Showvalues», où nous avons imprimé les variables «Real_number» et «IMG_NUMBER». Après cela, la classe dérivée est déclarée «attribution d'attribution» dans le même assemblage où nous instancons la classe «complexNumber» dans l'objet «C». Les méthodes «setvalues» et «showvalues» sont accessibles dans cette classe dérivée.

Lors de l'exécution du programme C # précédent, nous avons reçu le résultat suivant:

Exemple # 3: Utilisation du modificateur d'accès interne protégé en C # dans Ubuntu 20.04

Le modificateur interne protégé restreint l'accès à l'assemblage actuel ou les types hérités de la classe contenue.

La classe publique est définie comme «Parentclass» dans le programme précédent. Nous avons déclaré une «valeur» variable en tant qu'interne protégé de type entier dans la classe. Ensuite, une classe d'enfants est créée, qui hérite de la propriété de la classe parentale. Nous avons généré un objet appelé «OBJ2» pour la classe enfant. En utilisant une référence d'objet «Obj2» à la classe parent, nous accédons aux variables et méthodes de la classe enfant.

La sortie est affichée sur le terminal suivant du programme précédent:

Exemple n ° 4: Utilisation du modificateur d'accès privé protégé en C # dans Ubuntu 20.04

Dans le modificateur protégé privé, la classe d'encluse de l'assemblage actuel et ses types dérivés ont accès. Voici un exemple de déclaration des membres avec le modificateur protégé privé:

La classe de base est créée comme «ordre» dans le programme précédent. Dans la classe de base, nous avons déclaré deux variables du modificateur protégé privé. Les deux variables sont représentées par «article» et «emplacement». La méthode est également créée avec le mot clé protégé privé et le représente avec le nom «GetOrderDetails». La méthode protégée privée a la méthode WriteLine dans laquelle nous avons réglé les deux variables précédentes. Ensuite, nous avons une classe dérivée «setorder» dans laquelle nous accédons au membre de la classe de base par la référence de l'objet de classe dérivé «S».

L'exécution du programme précédent a les résultats suivants:

Conclusion

Enfin, dans l'article C # Protected Modifier, nous avons passé en revue les bases d'être protégés en C # et quelques illustrations de la façon d'utiliser les modificateurs d'accès protégées. Le modificateur protégé spécifie comment les autres types dans un programme C #, tels que les types dérivés, peuvent accéder à un type et à ses membres. Nous avons différents exemples d'utilisation des modificateurs protégés et des modificateurs internes et privés avec le mot-clé protégé. En outre, le modificateur d'accès protégé nous permet de maintenir un niveau élevé de dissimulation d'informations tout en maintenant une structure d'objet riche.