Introduction aux variables en C #
En C #, une variable est un nom que nous donnons à l'emplacement de la mémoire et chaque variable a un type spécifié qui spécifie le type de valeurs qui peuvent être stockées dans une variable. Toutes les variables doivent être déclarées avant d'être utilisées; chaque variable a un type spécifique qui décide de la taille et de la plage des variables. Pour effectuer une opération sur des variables, il est essentiel de définir une variable avec un type de données particulier pour spécifier le type de données que la variable peut contenir dans notre application. Voyons quelques choses de base sur les variables,
- Les variables ne sont rien d'autre qu'un nom donné à la valeur des données.
- Les variables peuvent contenir la valeur de types de données particuliers, par exemple, int, string, float, etc.
- La déclaration et l'initialisation des variables sont dans des instructions distinctes.
- Les variables peuvent être définies par plusieurs séparées par une virgule et également en une seule ligne et sur plusieurs lignes jusqu'à la fin du point-virgule.
- Les valeurs doivent être attribuées à une variable avant de l'utiliser; sinon, il affichera une erreur de compilation.
- La valeur d'une variable peut être modifiée à tout moment jusqu'à l'accessibilité du programme.
Comment déclarer des variables en C #?
Il existe certaines règles pour déclarer des variables C #:
- Nous devons définir un nom de variable avec la combinaison de chiffres, d'alphabets et de soulignements.
- Chaque nom de variable doit commencer par des alphabets ou un trait de soulignement.
- Aucun espace blanc ne doit être autorisé entre le nom de la variable.
- Les noms de variable ne doivent contenir aucun mot clé de réserve comme int, char, float, etc.
La syntaxe de définition des variables en C #
;
=value;
=value;
Ici le est un type de données dans lequel la variable peut contenir les types dont ils sont un entier, Sting, float, etc. est le nom d'une variable qui contient la valeur dans notre application et attribue une valeur spécifique à la variable et enfin est utilisé pour donner l'autorisation d'accès à la variable. Ce sont des méthodes appropriées pour décrire les noms de variables dans le langage de programmation c #.
int name;
float value;
char _firstname;
Vous pouvez également initialiser une variable au moment de la définition comme suit,
int value = 100;
Comment initialiser des variables en C #?
Pour affecter une valeur à une variable appelée initialisation, les variables peuvent être initialisées avec un signe égal par l'expression constante, les variables peuvent également être initialisées lors de leur déclaration.
Syntaxe :
= value;
Ou
variable_name = value;
Par exemple,
int value1=5, value2= 7;
double pi= 3.1416;
char name='Rock';
Types de variables en C # avec des exemples
Il existe plusieurs types de variables, telles que
- Variables locales
- Variables d'instance ou variables non statiques
- Variables statiques ou variables de classe
- Variables constantes
- Variables en lecture seule
1. Variables locales
Variable locale définie dans une méthode, un bloc ou un constructeur. Une fois la variable déclarée, ces variables n'existent qu'au sein du bloc et nous ne pouvons accéder à ces variables qu'au sein du bloc. La variable est créée lorsque la fonction est appelée ou le bloc est entré et elle sera démolie une fois après avoir existé du bloc ou pendant que l'appel revient de la fonction.
Dans l'exemple de programme, la variable «customer_age» est une variable locale de la fonction GetAge (). Le compilateur générera une erreur, une fois que nous aurons appliqué la variable customer_age en dehors de la fonction GetAge ().
Exemple de programme - Variables locales
using System;
class CustomerEntry
(
Public void GetAge()
(
int customer_age=0; // local variable
customer_age= customer_age+28;
Console. WriteLine("Customer Age: "+ customer_age);
)
public static void Main(String() args)
(
CustomerEntry _customerObj=new CustomerEntry();
_customerObj.GetAge();
)
)
Production:
Âge du client: 28
2. Variables d'instance ou variables non statiques
Les variables d'instance sont appelées variables non statiques; les variables d'instance sont déclarées dans une classe mais déclarées en dehors de toute méthode, bloc ou constructeur. Ces variables sont créées une fois l'objet d'une classe créé et elles seront détruites lorsque l'objet sera détruit. Pour les variables d'instance, nous pouvons utiliser les spécificateurs d'accès.
Dans le programme, les variables d'instance sont markEnglish, markMaths. Nous pouvons créer plusieurs objets chacun des objets a sa copie de variable d'instance.
Exemple de programme - Variables d'instance
using System;
class StudentMarks (
// instance variables
int markEnglish;
int markMaths;
int markPhysics;
public static void Main(String() args) // Main Method
(
StudentMarks obj1 = new StudentMarks (); //Object creation 1
obj1. markEnglish = 90;
obj1. markMaths = 80;
obj1. markPhysics = 93;
StudentMarks obj2 = new StudentMarks (); //Object creation 1
obj2. markEnglish = 95;
obj2. markMaths = 70;
obj2. markPhysics = 90;
Console.WriteLine("Marks Obtained from first object:");
Console.WriteLine(obj1. markEnglish);
Console.WriteLine(obj1. markMaths);
Console.WriteLine(obj1. markPhysics);
Console.WriteLine("Marks obtained from second object:");
Console.WriteLine(obj2. markEnglish);
Console.WriteLine(obj2. markMaths);
Console.WriteLine(obj2. markPhysics);
)
)
Production:
Marques obtenues du premier objet:
90
80
93
Marques obtenues du deuxième objet:
95
70
90
3. Variables statiques ou variables de classe
Une variable statique est créée au début de l'exécution du programme et détruit à la fin de l'exécution. Les variables statiques sont également appelées variables de classe. Pour accéder aux variables statiques, nous n'avons pas besoin de créer un objet de la classe; nous pouvons simplement accéder à la variable comme,
Class_name.variable_name;
Une variable statique est déclarée à l'aide du mot clé static dans une classe ou en dehors de toute méthode ou constructeur.
Exemple de programme - Variable statique
using System;
class Employee
(
static double empSalary;
static StringempName="Smith";
public static void main(String() args)
(
Employee.empSalary=100000; // accessing the static variable
Console. WriteLine(Employee.empName+ "'s Salary:" + Employee.empSalary);
)
)
Production:
Smith's Salary: 100000
4. Variables des constantes
Les variables constantes sont similaires aux variables statiques, une fois initialisées et au cycle de vie unique d'une classe et il n'a pas besoin de l'instance de la classe pour l'initialisation ou l'accès. La variable constante est déclarée à l'aide du mot-clé 'const', ces variables ne peuvent pas être modifiées une fois déclarées et doivent être initialisées au moment de la partie déclaration uniquement.
Exemple de programme - Variable constante
Using System;
Class Program_A
(
int x= 25; // instance variable
static int y= 35; // static variable
const float maxValue =75; // constant variable
public static void main()
(
Program_A classObject= new Program_A(); // object creation
Console.WriteLine("Value of x : " + classObject.x);
Console.WriteLine("Value of y : " + Program_A.y);
Console.WriteLine("Value of max " " + Program_A. maxValue);
)
)
Production:
Valeur de x: 25
Valeur de y: 35
Valeur max: 75
5. Variables en lecture seule
Une variable en lecture seule est déclarée à l'aide du mot clé " lecture seule " et ces variables ne peuvent pas être modifiées comme des variables constantes. La variable constante est une valeur immuable pour toute la classe tandis que la lecture seule est une valeur permanente pour une instance spécifique d'une classe. Il n'y a pas de contrainte pour initialiser une variable en lecture seule à la déclaration de temps, elle peut être initialisée sous constructeur. La valeur par défaut définie sur la variable est 0.
Exemple de programme - Lecture seule
using System;
class Program_B
(
const float maxValue =75; // constant variable
readonly int x; // read-only variable
public static void main()
(
Program_B classObject= new Program_B(); // object creation
Console.WriteLine("Value of max: " + Program_A. maxValue);
Console.WriteLine("Value of x : " + classObject.x);
)
)
Production:
Valeur max: 75
Valeur de x: 0
Conclusion
Enfin, vous savez comment les variables vous permettent de stocker des données de différentes manières. Dans cet article, nous avons appris comment déclarer et initialiser des variables et comment les utiliser. J'espère que cet article vous aurait aidé avec le processus de travail des variables.
Articles recommandés
Ceci est un guide des variables en C #. Nous discutons ici de ce que sont les variables en C #, comment déclarons-nous les variables, comment initialisons-nous les variables, et enfin quels sont les différents types de variables en C # avec ses exemples. Vous pouvez également consulter les articles suivants pour en savoir plus -
- Comment fonctionne Copy Constructor en C #?
- Fonctions de chaîne C # avec des exemples
- Comment déclarer des variables en PHP?
- Différentes fonctions C #
- Variables en JavaScript