Variables en C#

En C#, une variable est un nom que nous donnons à l'emplacement 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 toute 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 éléments 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 se font dans des instructions distinctes.
• Les variables peuvent être définies par plusieurs séparés par une virgule et également sur une seule et plusieurs lignes jusqu'à la fin du point-virgule.
• Les valeurs doivent être attribuées à une variable avant de l'utiliser ; sinon, une erreur de compilation s'affichera.
• 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 quelques règles pour déclarer les variables C# :

• Nous devons définir un nom de variable avec la combinaison de chiffres, d'alphabets et de trait de soulignement.
• Chaque nom de variable doit commencer par des alphabets ou un trait de soulignement.
• Il ne doit y avoir aucun espace blanc entre le nom de la variable.
• Les noms de variables ne doivent contenir aucun mot-clé de réserve comme int, char, float, etc.

La syntaxe de définition des variables en C#

<data_type> <variable_name>;
<data_type> <variable_name>=value;
<access_specifier><data_type> <variable_name>=value;

Ici, le est un type de données dans lequel la variable peut contenir les types qu'il s'agit d'un entier, Sting, float et ainsi de suite. 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 accorder l'autorisation d'accès à la variable. Il s'agit de 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 attribuer 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 :

<data_type> <variable_name> = 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 exemples

Il existe plusieurs types de variables, telles que

1. Variables locales
2. Variables d'instance ou variables non statiques
3. Variables statiques ou variables de classe
4. Variables constantes
5. Variables en lecture seule

1. Variables locales

Une variable locale définie dans une méthode, un bloc ou un constructeur. Une fois la variable déclarée, ces variables n'existent que dans le bloc et nous ne pouvons accéder à ces variables que dans le bloc. La variable est créée lorsque la fonction est appelée ou que le bloc est entré et elle sera démolie une fois après avoir existé du bloc ou pendant le retour de l'appel 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 appliquerons 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();
}
}

Sortie :

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. Par exemple des variables, 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 ayant sa copie de la 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);
}
}

Sortie :

3. Variables statiques ou variables de classe

Une variable statique est créée au début de l'exécution du programme et détruite à 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 au sein d'une classe ou en dehors de toute méthode ou constructeur.

Sample Program – Static Variable

using System;
class Employee
{
static double empSalary;
static string empName="Smith";
public static void Main(String[] args)
{
Employee.empSalary=100000;  // accessing the static variable
Console. WriteLine(Employee.empName+ "'s Salary:" + Employee.empSalary);
}
}

Output:

4. Constants Variables

Constant variables are similar to the static variables, once initialized and the one-time life cycle of a class and it does not need the instance of the class for initializing or accessing. The constant variable is declared by using the ‘const’ keyword, these variables cannot be altered once it declared, and it should be initialized at the time of the declaration part only.

Sample Program – Constant Variable

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);
}
}

Output:

5. Read-Only Variables

A read-only variable is declared using the keyword ‘read-only‘ and those variables cannot be altered like constant variables. The constant variable is an unchanging value for the entire class whereas read-only is a permanent value for a specific instance of a class. There is no compulsion to initialize a read-only variable at the time declaration, it can be initialized under constructor. The default value set to the variable is 0.

Sample Program – Read-Only

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_B. maxValue);
Console.WriteLine("Value of x : " + classObject.x);
}
}

Output:

Conclusion

Finally, you have known about how variables allow you to store data in different ways. In this article, we learned about how to declare and initialize variables and how to make use of it. I hope this article would have helped you out with the working process of variables.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!