Variables C# et types de données (primitifs)

Dans ce didacticiel, nous allons découvrir les variables, comment créer des variables en C# et les différents types de données pris en charge par le langage de programmation C#.

Une variable est un nom symbolique donné à un emplacement mémoire. Les variables sont utilisées pour stocker des données dans un programme informatique.

Comment déclarer des variables en C# ?

Voici un exemple pour déclarer une variable en C#.

int age;

Dans cet exemple, une variable âge de type int (entier) est déclaré et ne peut stocker que des valeurs entières.

Nous pouvons attribuer une valeur à la variable plus tard dans notre programme comme ceci :

int age;
... ... ...
age = 24;

Cependant, la variable peut également être initialisée à une valeur lors de la déclaration. Par exemple,

int age = 24;

Ici, une variable âge de type int est déclaré et initialisé à 24 en même temps.

Comme il s'agit d'une variable, nous pouvons également modifier la valeur des variables. Par exemple,

int age = 24;
age = 35;

Ici, la valeur de age passe de 24 à 35.

Les variables en C# doivent être déclarées avant de pouvoir être utilisées. Cela signifie que le nom et le type de la variable doivent être connus avant de pouvoir leur attribuer une valeur. C'est pourquoi C# est appelé un langage à typage statique.

Une fois déclaré, le type de données d'une variable ne peut pas être modifié dans une portée. Une portée peut être considérée comme un bloc de code où la variable est visible ou disponible à l'utilisation. Si vous ne comprenez pas la déclaration précédente, ne vous inquiétez pas, nous en apprendrons davantage sur les champs d'application dans les chapitres suivants.

Pour l'instant rappelez-vous, nous ne pouvons pas faire ce qui suit en C# :

int age;
age = 24;
... ... ...
float age;

Variables implicitement typées

Alternativement en C #, nous pouvons déclarer une variable sans connaître son type en utilisant var mot-clé. Ces variables sont appelées variables locales implicitement typées .

Variables déclarées avec var le mot clé doit être initialisé au moment de la déclaration.

var value = 5;

Le compilateur détermine le type de variable à partir de la valeur qui est affectée à la variable. Dans l'exemple ci-dessus, value est de type int . Cela équivaut à :

int value;
value = 5;

Vous pouvez en savoir plus sur les variables locales implicitement typées.

Règles de nommage des variables en C#

Il y a certaines règles que nous devons suivre lorsque nous nommons une variable. Les règles pour nommer une variable en C# sont :

Le nom de la variable peut contenir uniquement des lettres (majuscules et minuscules), un trait de soulignement (_) et des chiffres.

Le nom de la variable doit commencer par une lettre, un trait de soulignement ou le symbole @. Par exemple,

Règles de nommage des variables en C#
Noms des variables	Remarques
`nom`	Valide
`sujet101`	Valide
`_age`	Valide (Meilleure pratique pour nommer les variables de membre privé)
`@break`	Valide (utilisé si le nom est un mot-clé réservé)
`101sujet`	Non valide (commence par un chiffre)
`votre_nom`	Valide
`votre nom`	Non valide (Contient des espaces blancs)

C# est sensible à la casse. Cela signifie âge et Âge fait référence à 2 variables différentes.
Un nom de variable ne doit pas être un mot-clé C#. Par exemple, if , for , using ne peut pas être un nom de variable. Nous aborderons plus en détail les mots-clés C# dans le prochain didacticiel.

Meilleures pratiques pour nommer une variable

Choisissez un nom de variable qui a du sens. Par exemple, nom , âge , sujet a plus de sens que n , un et s .
Utilisez camelCase notation (commence par une lettre minuscule) pour nommer les variables locales. Par exemple, numberOfStudents , âge , etc.
Utilisez PascalCase ou CamelCase (commence par une lettre majuscule) pour nommer les variables membres publiques. Par exemple, Prénom , Prix , etc.
Utilisez un trait de soulignement (_) suivi de camelCase notation pour nommer les variables de membre privé. Par exemple, _bankBalance , _emailAddress , etc.

Vous pouvez en savoir plus sur les conventions de nommage en C# ici.

Ne vous souciez pas des variables de membre publiques et privées. Nous en apprendrons plus sur eux dans les chapitres suivants.

Types de données primitifs C#

Les variables en C# sont généralement classées en deux types :Types de valeur et Types de référence . Dans ce didacticiel, nous discuterons des types de données primitifs (simples) qui sont une sous-classe des types de valeur.

Les types de référence seront traités dans des didacticiels ultérieurs. Toutefois, si vous souhaitez en savoir plus sur les types de variables, consultez Types et variables C# (documents C# officiels).

Booléen (bool)

Le type de données booléen a deux valeurs possibles :true ou false
Valeur par défaut :false
Les variables booléennes sont généralement utilisées pour vérifier des conditions telles que les instructions if , boucles , etc.

Par exemple :

using System;
namespace DataType
{
    class BooleanExample
    {
        public static void Main(string[] args)
        {
            bool isValid = true;
            Console.WriteLine(isValid);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

True

Intégral signé

Ces types de données contiennent des valeurs entières (positives et négatives). Sur le nombre total de bits disponibles, un bit est utilisé pour le signe.

1. sbyte

Taille :8 bits
Plage :-128 à 127.
Valeur par défaut :0

Par exemple :

using System;
namespace DataType
{
    class SByteExample
    {
        public static void Main(string[] args)
        {
            sbyte level = 23;
            Console.WriteLine(level);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

Essayez d'attribuer des valeurs hors plage, c'est-à-dire inférieures à -128 ou supérieures à 127, et voyez ce qui se passe.

2. court

Taille :16 bits
Plage :-32 768 à 32 767
Valeur par défaut :0

Par exemple :

using System;
namespace DataType
{
    class ShortExample
    {
        public static void Main(string[] args)
        {
            short value = -1109;
            Console.WriteLine(value);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

-1109

3. entier

Taille :32 bits
Plage :-231 à 231-1
Valeur par défaut :0

Par exemple :

using System;
namespace DataType
{
    class IntExample
    {
        public static void Main(string[] args)
        {
            int score = 51092;
            Console.WriteLine(score);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

4. longue

Taille :64 bits
Plage :-263 à 263-1
Valeur par défaut :0L [L à la fin représente la valeur est de type long]

Par exemple :

using System;
namespace DataType
{
    class LongExample
    {
        public static void Main(string[] args)
        {
            long range = -7091821871L;
            Console.WriteLine(range);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

-7091821871

Intégrale non signée

Ces types de données ne contiennent que des valeurs égales ou supérieures à 0. Nous utilisons généralement ces types de données pour stocker des valeurs lorsque nous sommes sûrs que nous n'aurons pas de valeurs négatives.

1. octet

Taille :8 bits
Plage :0 à 255.
Valeur par défaut :0

Par exemple :

using System;
namespace DataType
{
    class ByteExample
    {
        public static void Main(string[] args)
        {
            byte age = 62;
            Console.WriteLine(level);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

2. bref

Taille :16 bits
Plage :0 à 65 535
Valeur par défaut :0

Par exemple :

using System;
namespace DataType
{
    class UShortExample
    {
        public static void Main(string[] args)
        {
            ushort value = 42019;
            Console.WriteLine(value);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

3. uint

Taille :32 bits
Plage :0 à 232-1
Valeur par défaut :0

Par exemple :

using System;
namespace DataType
{
    class UIntExample
    {
        public static void Main(string[] args)
        {
            uint totalScore = 1151092;
            Console.WriteLine(totalScore);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

4. longtemps

Taille :64 bits
Plage :0 à 264-1
Valeur par défaut :0

Par exemple :

using System;
namespace DataType
{
    class ULongExample
    {
        public static void Main(string[] args)
        {
            ulong range = 17091821871L;
            Console.WriteLine(range);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

17091821871

Point flottant

Ces types de données contiennent des valeurs à virgule flottante, c'est-à-dire des nombres contenant des valeurs décimales. Par exemple, 12.36, -92.17, etc.

1. flotter

Type à virgule flottante simple précision
Taille :32 bits
Plage :1,5 × 10−45 à 3,4 × 1038
Valeur par défaut :0.0F [F à la fin représente que la valeur est de type float]

Par exemple :

using System;
namespace DataType
{
    class FloatExample
    {
        public static void Main(string[] args)
        {
            float number = 43.27F;
            Console.WriteLine(number);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

43.27

2. double

Type à virgule flottante double précision. Quelle est la différence entre virgule flottante simple et double précision ?
Taille :64 bits
Plage :5,0 × 10−324 à 1,7 × 10308
Valeur par défaut :0.0D [D à la fin représente la valeur est de type double]

Par exemple :

using System;
namespace DataType
{
    class DoubleExample
    {
        public static void Main(string[] args)
        {
            double value = -11092.53D;
            Console.WriteLine(value);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

-11092.53

Caractère (char)

Il représente un caractère Unicode 16 bits.
Taille :16 bits
Valeur par défaut :'\0'
Plage :U+0000 ('\u0000') à U+FFFF ('\uffff')

Par exemple :

using System;
namespace DataType
{
    class CharExample
    {
        public static void Main(string[] args)
        {
            char ch1 ='\u0042';
            char ch2 = 'x';
            Console.WriteLine(ch1);
            Console.WriteLine(ch2);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

B
x

La valeur unicode de 'B' est '\u0042' , d'où l'impression de ch1 imprimera 'B' .

Décimal

Le type décimal a plus de précision et une plage plus petite par rapport aux types à virgule flottante (double et float). Il convient donc aux calculs monétaires.
Taille :128 bits
Valeur par défaut :0.0M [M à la fin représente que la valeur est de type décimal]
Plage :(-7,9 x 1028 à 7,9 x 1028) / (100 à 28)

Par exemple :

using System;
namespace DataType
{
    class DecimalExample
    {
        public static void Main(string[] args)
        {
         decimal bankBalance = 53005.25M;
            Console.WriteLine(bankBalance);
        }
    }
}

Lorsque nous exécutons le programme, la sortie sera :

53005.25

Le suffixe M ou m doit être ajouté à la fin sinon la valeur sera traitée comme un double et une erreur sera générée.

C# Littéraux

Regardons la déclaration suivante :

int number = 41;

Ici,

int est un type de données
numéro est une variable et
41 est un littéral

Les littéraux sont des valeurs fixes qui apparaissent dans le programme. Ils ne nécessitent aucun calcul. Par exemple, 5 , false , 'w' sont des littéraux qui apparaissent directement dans un programme sans aucun calcul.

Littéraux booléens

true et false sont les littéraux booléens disponibles.
Ils sont utilisés pour initialiser les variables booléennes.

Par exemple :

bool isValid = true;
bool isPresent = false;

Littéraux entiers

Les littéraux entiers sont utilisés pour initialiser les variables de types de données entiers, c'est-à-dire sbyte , short , int , long , byte , ushort , uint et ulong .
Si un entier littéral se termine par L ou l , il est de type long. Pour les meilleures pratiques, utilisez L (pas l ).
```
long value1 = 4200910L;
long value2 = -10928190L;
```
Si un entier littéral commence par un 0x , il représente une valeur hexadécimale. Les nombres sans préfixes sont traités comme des valeurs décimales. Les représentations octales et binaires ne sont pas autorisées en C#.
```
int decimalValue = 25;
int hexValue = 0x11c;// decimal value 284
```

Littéraux à virgule flottante

Les littéraux à virgule flottante sont utilisés pour initialiser les variables de types de données float et double.
Si un littéral à virgule flottante se termine par un suffixe f ou F , il est de type float. De même, s'il se termine par d ou D , il est de type double. Si aucun des suffixes n'est présent, il est de type double par par défaut .

Ces littéraux contiennent e ou E lorsqu'ils sont exprimés en notation scientifique.

double number = 24.67;// double by default
float value = -12.29F;
double scientificNotation = 6.21e2;// equivalent to 6.21 x 102 i.e. 621

Littéraux de caractères et de chaînes

Les littéraux de caractères sont utilisés pour initialiser les variables des types de données char.
Les caractères littéraux sont placés entre guillemets simples. Par exemple, 'x' , 'p' , etc.
Ils peuvent être représentés sous forme de caractère, de séquence d'échappement hexadécimale, de représentation unicode ou de valeurs intégrales converties en char.
```
char ch1 = 'R';// character
char ch2 = '\x0072';// hexadecimal
char ch3 = '\u0059';// unicode
char ch4 = (char)107;// casted from integer
```
Les littéraux de chaîne sont la collection de littéraux de caractères.
Ils sont entourés de guillemets doubles. Par exemple, "Bonjour" , « Programmation facile » , etc.
```
string firstName = "Richard";
string lastName = " Feynman";
```
C# prend également en charge les caractères de séquence d'échappement tels que :

Personnage Signification

\' Avis simples

\" Avis double

\\ Barre oblique inverse

\n Nouvelle ligne

\r Retour chariot

\t Onglet horizontal

\a Alerte

\b Retour arrière

Personnage	Signification
`\'`	Avis simples
`\"`	Avis double
`\\`	Barre oblique inverse
`\n`	Nouvelle ligne
`\r`	Retour chariot
`\t`	Onglet horizontal
`\a`	Alerte
`\b`	Retour arrière

Mots-clés et identifiants C# Opérateurs C#

Langue C