Comment utiliser «var» dans la langue C #

En travaillant dans la programmation, nous devons utiliser de nombreux types de variables et de fonctions dans le code pour la rendre compréhensible pour les utilisateurs et pratique de rechercher. Le but principal de l'utilisation des variables et des fonctions dans n'importe quel code est d'éviter la complexité et l'ambiguïté et de le rendre plus pratique à utiliser. Dans C #, nous pouvons déclarer des variables implicitement et explicitement. La déclaration implicite n'a pas besoin de déclarer le type de variable avec son nom. En revanche, la déclaration explicite vous oblige à inclure le type de variable.

La déclaration implicite a besoin du mot-clé «var» pour déclarer toute variable, et le compilateur lui-même interprétera et déterminera le type d'une variable requise à un moment donné. Pendant que dans la déclaration explicite, vous déclarerez le type, et le compilateur le validera uniquement. Dans cet article, nous nous concentrerons sur l'utilisation du mot-clé «var» pour déclarer implicitement les variables en C #. Assurez-vous de mettre à jour votre système Linux. Le processus de mise à jour vous aidera à vous assurer que votre système à jour avec les dernières fonctionnalités et sans erreur en raison de ces mises à jour.

Exemple # 01:

Nous ferons un nouveau début pour notre premier exemple en créant un fichier C # pour le code du programme. Vous devez exécuter l'instruction «Touch» Linux sur votre application Shell Console. Ce fichier sera généré dans votre répertoire de travail actuel, très probablement «à la maison».

Nous commencerons notre première illustration pour démontrer la syntaxe simple de déclarer et d'initialiser toute variable en C #. Démarrez votre code C # avec l'utilisation générale de l'espace de noms «système» dans le code. Cet espace de noms est un must dans chaque code C # pour l'utilisation de fonctions intégrées à usage général. Après cela, nous avons créé une classe simple et aléatoire nommée «Test» et commencé une méthode de pilote Main ().

Notre méthode principale () a initialisé une variable entière «x» avec la valeur 12. Le mot-clé «int» montre le type «entier» d'une variable «x». La ligne suivante utilise la fonction writeLine () du système d'espace de noms et de sa «console» de classe pour afficher la valeur de la variable «x» sur le shell.

À l'aide du compilateur MCS pour C, exécutez le fichier var.CS compilé ou code très efficacement. Le var.Le fichier EXE a été créé, et nous utilisons le «mono-runtime» pour exécuter ce fichier EXE. La sortie suivante montre l'affichage simple de la variable «x» avec sa valeur:

L'illustration précédente montre la définition et l'initialisation de tout type de variable en C #. Au contraire, C # vous permet d'éviter d'utiliser le type de données avec la variable et d'utiliser plutôt le mot-clé «var». L'utilisation du mot clé «var» fait interpréter le compilateur le type d'une variable elle-même, et nous n'avons pas besoin d'informer le compilateur. Donc, nous avons mis à jour notre code ci-dessous. En utilisant le mot clé «var», nous avons initialisé deux variables, «x» et «y», avec des valeurs entières positives et en entier négative, respectivement. Ensuite, la fonction WriteLine () a été utilisée pour afficher les valeurs des deux variables «x» et «y» sur la coque de la console. Enregistrez et quittez votre éditeur de texte.

Nous avons compilé ce code avec le compilateur «MCS» et créé son fichier EXE. Ce var.Le fichier EXE a été utilisé pour l'exécution à l'aide d'un mono-runtime. Les deux variables sont affichées, et nous n'avons aucune erreur. Cet exemple montre comment le mot-clé «var» est précieux pour déclarer les variables:

Après avoir défini les variables implicitement, nous examinerons le type de variable en utilisant la fonction «GetType» de C #. Pour cela, vous devez implémenter la classe «texte» de l'espace de noms «système» dans votre code C # après l'utilisation de l'espace de noms «système» séparément. Dans la classe «test», la même méthode principale () a été utilisée. Nous avons utilisé les mêmes variables, «X» et «Y». Dans la fonction «écriture ()» de la classe de console, nous utilisons le «getType» appelé par les noms de variables pour afficher le type de variables avec leurs valeurs. Nous avons utilisé le format de supports bouclés dans la chaîne pour afficher les valeurs.

Après avoir compilé et exécuté ce programme, nous devons connaître le type de variables, «X» et «Y», séparément. Les deux variables sont du même type, je.e., «INT32», selon le compilateur C # Compilateur.

Exemple # 02:

Dans l'exemple précédent, nous avons vu comment la variable «var» et la fonction getType () peuvent afficher la variable de type entier et son type sur la coque de la console, respectivement. Maintenant, nous allons jeter un œil à certains autres types de variables en utilisant le mot-clé «var». Nous avons donc initialisé trois variables, «X», «Y» et «Z», avec le mot-clé «var» dans le code du pilote principal () de ce programme.

Utilisez le «système.Testez la ligne de l'espace de noms en haut de ce code. Ces trois variables contiennent différents types de valeurs, comme le flotteur, le caractère et la chaîne. Nous utilisons la même console.Fonction writeLine () pour afficher chaque variable avec son type en utilisant la fonction "getType ()" avec des noms de variables. Comme toutes les variables sont de types différents, nous nous attendons à la sortie unique sur notre écran.

Économions et compilons notre code avec le compilateur «MCS». La compilation a été assez réussie et aucune erreur n'a été trouvée. Le fichier EXE de ce code de programme a été utilisé dans l'instruction mono pour exécuter le code compilé. La sortie affichait trois valeurs variables, «x», «y» et «z», ainsi que leurs types. Il montre que «x» a le type «double», «y» a le type de caractère et «z» a le type de chaîne.

Exemple # 03:

Nous avons examiné la plupart des types trouvés dans C # pour démontrer l'utilisation du mot-clé «VAR» pour des variables différentes et uniques. Jetons un coup d'œil à la valeur variable de type booléen maintenant. Nous avons donc mis à jour les variables dans la fonction principale () et remplacé X, Y et Z par B1, B2 et B3. Nous les avons implicitement déclarés avec le mot-clé «var» sans indiquer leur type.

Les deux premières variables contiennent des valeurs booléennes «vraies» et «false», et la dernière variable est vide. La même fonction écriture () est utilisée ici pour afficher la valeur variable avec leurs types en utilisant la fonction «getType» dans cette ligne.

Après avoir utilisé ce code dans la compilation et l'exécuter avec l'exécuteur C # Runtime «Mono», nous avons le résultat de souffle montré. Il affiche les deux premières variables sont de type «booléen» tandis que le troisième est de type de chaîne. Cela montre que toute valeur qui contient des caractères spéciaux, des espaces ou du vide sera considéré comme une chaîne.

Conclusion:

Dans le paragraphe d'introduction de notre article, nous avons brièvement discuté de l'idée d'une déclaration de variables implicites et explicites et fait une comparaison entre eux. Nous avons exposé à l'utilisation du mot-clé «var» à l'aide de la fonction C # «GetType» de la classe «texte» de l'espace de noms «Système» qui a énoncé le type de variables sur la sortie. Nous avons essayé ces exemples pour entier positif et négatif, le caractère, le flotteur, la chaîne, le booléen et le type de variables vides séparément. Les illustrations du mot clé «var» montrent qu'il n'y aura aucun problème à effectuer aucune opération sur les variables avec la déclaration de mots clés «var». Nous espérons que vous avez trouvé cet article utile. Consultez les autres articles sur les conseils pour plus de conseils et de tutoriels.