C # interne
Exemple 01
Avant d'utiliser le modificateur d'accès interne, nous devons d'abord regarder le modificateur d'accès «privé» en programmation C #. Nous avons donc utilisé l'espace de noms défini par l'utilisateur nommé «Nouveau», contenant deux classes. 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és «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 avoir lieu. 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 à l'aide du compilateur C # «MCS» déjà configuré dans Linux. Cette étape incontournable nous montre que l'erreur 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 que 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. Donc, nous avons encore enregistré 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, je.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 lancé cet exemple C # avec l'ajout 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 «Test.«La classe« test »contient la fonction de code de pilote main (), 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é en utilisant le «nouveau» mot-clé suivi du nom d'une classe. Ce nouvel objet de 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 un 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. Nous avons exécuté la commande «MCS» pour la compilation de code C # pour exécuter le «interne.Fichier CS »dans le shell. 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 () est 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 est 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. Vous avez créé deux espaces de noms dans votre même code C #, je.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" Tester.»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 mettre à jour le 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 après cette mise à jour, 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 aucun espace de noms défini dans la classe. Nous avons élaboré son utilisation pour protéger les variables des membres de données et fonctionner dans C #.