C # Passe par référence

Tout en travaillant dans une programmation orientée objet, vous avez peut-être essayé le concept de valeur passant par référence dans les codes, je.e. C, C++. Passer par des moyens de référence pour indiquer l'emplacement de la mémoire d'une certaine variable sans créer ses copies. Les références sont très probablement utilisées pour effectuer certains changements et les faire réfléchir à l'emplacement de la mémoire d'origine sans aucun problème. Nous avons tendance à utiliser le caractère «&» dans les langues orientées objet pour effectuer des références passes.

Dans C #, nous effectuons les valeurs de passage par référence en utilisant le mot clé «Ref». Voyons voir comment ça fonctionne. En commençant par l'implémentation de ce guide, nous devons avoir un fichier C # pour y créer des codes de programmation. Jusqu'ici, tout va bien; Nous utilisons la requête «Touch» d'Ubuntu pour générer un nouveau fichier C # dans le répertoire de travail actuel de notre système Linux.

Exemple 01

Nous commencerons notre premier exemple de ce code avec la définition de la structure du programme C #. Nous avons donc ouvert le C #, créé un fichier dans l'éditeur de texte intégré d'Ubuntu 20.04, et a ajouté la bibliothèque «système» à sa première ligne. Cette bibliothèque est la principale source d'entrée et de sortie dans les codes C #. Sans cette bibliothèque, notre code ne nous est pas utilisé car il ne fonctionnera pas comme nous le voulons. Ainsi, après avoir ajouté la bibliothèque, nous avons créé un espace de noms aléatoire «référence» dans ce code. Cet espace de noms est défini par l'utilisateur.

Nous avons également créé une nouvelle classe définie par l'utilisateur, «Référence», dans ce programme pour initialiser notre code avec une certaine implémentation. Cette classe «référence» définie par l'utilisateur contient un total de 2 fonctions dedans. La première fonction est la fonction main () intégrée avec le type de retour «Static void», qui serait également la fonction du pilote de notre code C #, i.e. Toute l'exécution commence à partir de lui. L'autre fonction est une fonction aléatoire définie par l'utilisateur nommé «Mise à jour», ayant le type de retour «public static void».

La console.La fonction writeLine () est là pour afficher la valeur d'origine d'une variable «n» en utilisant ses paramètres comme indiqué ci-dessous dans l'image. Après cela, nous avons appelé la fonction «mise à jour» de la variable principale «n» comme valeur paramétrique. Maintenant, le contrôle va à la fonction «Mise à jour», qui a pris la valeur de la variable «n» comme référence en utilisant la nouvelle variable «Val» de type entier. Cette variable «Val» multipliera sa valeur passée «5» de la fonction principale () par «3» et écrasera la variable «Val».

Il n'y a pas de déclaration de retour ici. L'exécution de la fonction de mise à jour est terminée et le contrôle est de retour à la fonction «principale». La fonction Main () exécute sa prochaine console.Fonction WriteLine () Pour afficher la valeur mise à jour de la variable «n» en utilisant «n» dans ses paramètres. La fonction Main () et notre code C # sont complets et prêts à être utilisés. Enregistrons-le par Ctrl + S et sortons-le avec Ctrl + X.

Après avoir enregistré le fichier C #, la première étape que nous devons faire est de compiler ce code avec le compilateur «MCS» de C # déjà configuré dans notre Ubuntu 20.04 Système. Nous l'avons donc fait, et le fichier «exe» pour ce code compilé a été automatiquement créé au même endroit. Nous avons utilisé l'instruction d'exécution de l'exécution «mono» pour les codes C # pour exécuter ce fichier «exe» et obtenu le résultat affiché. Il s'avère que la valeur d'origine et la valeur mise à jour sont les mêmes, je.e. Aucune modification n'a été apportée jusqu'à présent.

Voyons le problème maintenant. Lorsque nous essayons de mettre à jour la valeur de la variable «n» en le faisant passer en référence, il ne localise pas l'adresse mémoire de la variable d'origine «n». Au lieu de cela, il a créé un autre objet réplique avec le même nom et la même valeur et l'a passé à la fonction de mise à jour. Ainsi, les modifications apportées au nouvel objet n'affectent pas la valeur «n» de la variable d'origine.

Pour éviter ce problème, le framework C # a proposé le nouveau mot clé «ref» pour transmettre les valeurs en référence à tout paramètre de fonction. En utilisant ce mot clé «Ref», l'emplacement de mémoire de variable d'origine a été utilisé à la place de la nouvelle adresse mémoire, je.e. pointant vers l'emplacement de la mémoire de la variable d'origine. Ainsi, nous avons mis à jour notre code et utilisé le mot-clé «ref» tout en passant la variable «n» comme référence à la fonction de mise à jour. Ce mot-clé a été utilisé dans la fonction principale () tandis que l'appel de la fonction à la fonction «Mise à jour» et dans les paramètres de fonction «Update ()» comme affiché.

Après avoir compilé le fichier C # mis à jour et exécuté son «exe» juste après cela, nous avons été présentés avec la sortie montrée. Cette fois, la valeur «5» de la variable «n» a été mise à jour vers «15» en raison de l'utilisation du mot-clé «ref» pour transmettre une valeur en tant que référence.

Exemple 02

Regardons un autre exemple pour effectuer des échanges en passant des valeurs dans les paramètres. La classe «test» a utilisé une fonction «échanger» définie par l'utilisateur et la fonction du pilote principal (). L'exécution a commencé à partir de la méthode principale () où nous avons créé un objet «t» de test de classe et initialisé deux variables entières, V1 et V2, avec des valeurs entières - la console.Instructions de fonction writeLine () affichez les valeurs des variables v1 et v2 avant l'échange.

Après cela, la fonction d'échange est appelée en passant les variables V1 et V2 dans ses paramètres comme référence. Le mot-clé «ref» a été utilisé ici pour les deux variables. Dans l'implémentation de la fonction «Mise à jour», nous avons également utilisé le mot-clé «ref» pour les deux variables N1 et N2 pour transmettre les valeurs par référence. Pour échanger les valeurs d'une variable à une autre, nous devons avoir une troisième valeur pour effectuer ce. La nouvelle variable «V» a été initialisée dans cette fonction, prenant la valeur de la variable N1 comme première partie. La valeur de N2 a été écrasée en variable N1, et la valeur de la variable V a été enregistrée en variable n2. L'échange de valeur N1 avec N2 a été fait ici. La console de fonction principale ().La fonction writeLine () est là pour afficher maintenant les valeurs nouvellement échangées de N1 et N2.

Après la compilation et l'exécution de cet exemple de code, nous avons des valeurs de V1 et V2 comme 14 et 7 avant l'échange. Après l'échange, il se révèle être le contraire, je.e. v1 = 7 et v2 = 14.

Si nous supprimons le mot-clé «ref» de l'appel de fonction et la définition de la fonction de la fonction «mise à jour» comme nous l'avons fait ci-dessous, l'échange ne sera pas effectué.

Ici, vous pouvez voir que la sortie montre que les valeurs de V1 et V2 sont les mêmes même après avoir utilisé la fonction d'échange.

Conclusion

Ce guide consiste à utiliser le mot-clé «ref» en C # pour effectuer des valeurs de passage par une référence. Ce référence a été effectué en utilisant l'emplacement de la mémoire exacte de certaines variables. Dans ce guide, nous avons discuté de l'utilisation du mot-clé «ref» pour mettre à jour la valeur d'origine d'une variable en la multipliant avec un certain nombre et en échangeant les valeurs de deux variables dans deux exemples différents. Cela a été exécuté très bien avec "Ref".