C # Modificateur d'accès
Exemple # 01:
Avant de regarder l'utilisation du modificateur d'accès interne, nous devons examiner le modificateur d'accès «privé» dans le programme C # d'abord. Nous avons lancé notre première illustration avec l'utilisation de la bibliothèque «système». Nous avons donc utilisé l'espace de noms défini par l'utilisateur nommé «nouveau» contenant un total de deux classes dedans.
La classe «test» contient la fonction principale () pour démarrer l'exécution de ce code. La console.L'instruction writeLine () dans cette fonction du pilote Main () est utilisée pour afficher le texte «Méthode principale de la classe de test» sur nos écrans. Un objet «obj» pour la classe «Nouveau» a été créé en utilisant le nom de classe. La classe «nouvelle», contient un membre de données privé «x» de type entier avec la valeur «14». Cela signifie que la valeur de la variable «x» ne peut être accessible par aucune autre fonction d'autres classes même si elles sont dérivées.
La fonction Main () utilise l'objet «Obj» de la nouvelle classe pour mettre à jour la valeur du membre de données privé «X» de la classe «Nouveau» I.e. Pas possible pour le moment. Après avoir appelé la fonction show () avec l'objet «obj» dans la méthode principale (), l'exécution de la méthode show () avec le modificateur d'accès «public» doit être effectuée. Il ne semble pas que cela à cause du modificateur d'accès privé avec la variable «x». Les deux classes sont terminées et le code est prêt à l'usage. Nous devons l'enregistrer d'abord avec Ctrl + S et quitter l'éditeur en le fermant en utilisant le signe croisé de l'éditeur de texte.
Une fois le code enregistré, vous devez le compiler grâce à l'utilisation du compilateur C # «MCS» déjà configuré dans Linux. Cette étape nous montre l'erreur qui s'est produite à la ligne 12 de notre code C #, i.e. La variable «X» ne peut pas être accessible dans la classe de test telle qu'elle a été définie avec le modificateur d'accès privé. Donc, nous devons corriger cette erreur.
Nous avons recommencé le fichier C # dans l'éditeur de texte et mis à jour le code en remplaçant le modificateur d'accès privé de la variable «X» par le modificateur d'accès public. Nous ne modifierons pas le code restant car il n'est pas nécessaire. Alors, enregistrez à nouveau le code nouvellement mis à jour.
Lorsque nous avons utilisé la commande du compilateur MCS sur le shell suivi du nom d'un fichier C #, le code a été compilé avec succès. Après cela, nous avons exécuté le fichier «exe» créé par le compilateur de C # sur le shell et la sortie a été affichée i.e. Une valeur de «x» a été mise à jour.
Exemple # 02:
Maintenant, nous allons examiner l'utilisation des modificateurs d'accès internes pour définir la portée de certaines variables dans les classes de code C #. Nous avons donc commencé cet exemple C # avec l'utilisation de la bibliothèque système et créé un espace de noms «nouveau» dedans. Cet espace de noms contient deux classes indépendantes nommées «New» et «Tester» dedans. La classe «test» contient la fonction de code du pilote principal (), tandis que la «nouvelle» classe contient la variable entière «x» ayant une valeur de 14 définie avec le modificateur d'accès interne et la fonction show ().
Le nouvel objet de classe «OBJ» a été généré avec l'utilisation du «nouveau» mot-clé suivi du nom d'une classe. Cet objet de la nouvelle classe a été utilisé sur la ligne suivante pour mettre à jour la valeur de la variable «x» par «0». Maintenant, la variable «x» sera mise à jour avec succès car la variable «x» est définie avec le modificateur d'accès interne dans le même assemblage d'espace de noms «Nouveau». La fonction show () a été appelée avec ce même objet «obj». Lorsque la fonction show () sera exécutée, elle affichera la valeur mise à jour de "x" sur le shell via la console.Instruction de fonction writeLine ().
Il est temps d'enregistrer rapidement notre fichier de code avec Ctrl + S et de revenir à nouveau au terminal. Dans le shell, nous avons exécuté la commande «MCS» pour la compilation de code C # pour exécuter le «interne.Fichier CS ". Cette compilation a été réussie et le fichier «EXE» compilé pour l'internes.CS a été créé dans notre répertoire de travail actuel. Nous utilisons ce fichier «exe» pour l'exécuter avec la commande «mono» d'exécution dans le shell. La sortie a été affichée avec succès comme ci-dessous. La fonction main () a été exécutée en premier selon la chaîne affichée et après cela, la valeur mise à jour «0» de la variable «x» s'affiche avec succès.
C'est ainsi qu'un modificateur d'accès interne fonctionne dans le code C # lorsqu'il a été utilisé dans le même espace de noms. Apportons des modifications à notre code pour voir comment un modificateur d'accès interne affecte l'exécution du code C # lorsqu'il est utilisé parmi plus d'un assemblage. Disons que vous avez créé deux espaces de noms dans votre même code C # I.e. Nouveau et test.
Dans le nouvel espace de noms, nous avons créé une classe nouvelle et initialisé une variable «x» de modificateur d'accès interne avec la valeur 14. La même classe d'espace de noms New contient la fonction show () pour afficher la valeur de "x". D'un autre côté, le test de l'espace de noms contient un test de classe ayant une fonction Main (). Cette fonction Main () crée un objet de classe nouveau à partir de l'autre espace de noms «nouveau». Le même objet a été utilisé pour modifier la valeur de la variable «x» et appeler la fonction show () pour afficher la valeur mise à jour de la variable «x». Maintenant, la variable «x» est définie dans l'espace de noms «nouveau», tandis que l'objet essaie d'y accéder dans l'autre espace de noms «test». En raison du modificateur d'accès interne avec une variable «x», nous pouvons rencontrer une erreur. Voyons ça maintenant.
Après avoir compilé ce code, nous avons eu l'erreur comme prévu, je.e. Type protégé.
Pour éviter cette erreur sur la compilation, nous devons faire quelques mises à jour du code comme nous l'avons fait dans le code ci-dessus à partir du dernier code. Nous avons donc supprimé l'espace de noms «nouveau» du code et n'avons pas supprimé l'espace de noms de test du code comme indiqué sous.
Après la compilation et l'exécution du code, il a été exécuté avec succès et affiché la valeur modifiée de la variable «x» sur le shell, quel que soit son type interne.
Conclusion
Nous avons terminé d'implémenter les exemples du modificateur d'accès interne en C #. Nous avons commencé cet article avec l'exemple de la discussion du modificateur d'accès privé pour le comparer avec les modificateurs d'accès internes, car les deux font le même travail à différents niveaux de programmation. Nous avons essayé d'utiliser le modificateur d'accès interne dans le même espace de noms, deux espaces de noms différents et dans la classe n'ayant aucun espace de noms défini. De cette façon, nous avons élaboré son utilisation pour la protection des variables et fonctions des membres de données dans C #.