Maîtriser les variables C# et types de données primitifs : guide complet

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

Dans ce tutoriel, nous apprendrons les variables, comment créer des variables en C# et les différents types de données que le langage C# supporte.

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 age de type int (entier) est déclarée et elle ne peut stocker que des valeurs entières.

Nous pouvons assigner une valeur à la variable plus loin dans notre programme comme tel :

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

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

int age = 24;

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

Puisque c'est une variable, nous pouvons changer la valeur des variables également. Par exemple,

int age = 24;
age = 35;

Ici, la valeur de age est changée à 35 depuis 24.

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

Une fois déclarée, le type de données d'une variable ne peut pas être changé 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'usage. Si vous ne comprenez pas l'affirmation précédente, ne vous inquiétez pas, nous apprendrons les portées 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 à typage implicite

Alternativement en C#, nous pouvons déclarer une variable sans connaître son type en utilisant le mot-clé var. De telles variables sont appelées variables locales à typage implicite.

Les variables déclarées avec le mot-clé var doivent être initialisées au moment de la déclaration.

var value = 5;

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

int value;
value = 5;

Vous pouvez en apprendre plus sur les variables locales à typage implicite.

Règles pour nommer les variables en C#

Il y a certaines règles à suivre lors du nommage d'une variable. Les règles pour nommer une variable en C# sont :

Le nom de variable peut contenir des lettres (majuscules et minuscules), underscore (_) et chiffres seulement.

Le nom de variable doit commencer par une lettre, underscore ou symbole @. Par exemple,

Règles pour nommer les variables en C#
Noms de variables	Remarques
`name`	Valide
`subject101`	Valide
`_age`	Valide (Bonne pratique pour variables membres privées)
`@break`	Valide (Utilisé si le nom est un mot-clé réservé)
`101subject`	Invalide (Commence par un chiffre)
`your_name`	Valide
`your name`	Invalide (Contient un espace)

C# est sensible à la casse. Cela signifie que age et Age font 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 peuvent pas être un nom de variable. Nous en discuterons plus sur les mots-clés C# dans le prochain tutoriel.

Bonnes pratiques pour nommer une variable

Choisissez un nom de variable qui a du sens. Par exemple, name, age, subject ont plus de sens que n, a et s.
Utilisez la notation camelCase (commence par minuscule) pour nommer les variables locales. Par exemple, numberOfStudents, age, etc.
Utilisez PascalCase ou CamelCase (commence par majuscule) pour nommer les variables membres publiques. Par exemple, FirstName, Price, etc.
Utilisez un underscore initial (_) suivi de la notation camelCase pour nommer les variables membres privées. Par exemple, _bankBalance, _emailAddress, etc.

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

Ne vous inquiétez pas des variables membres publiques et privées. Nous les apprendrons dans les chapitres suivants.

Types de données primitifs C#

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

Les types référence seront couverts dans les tutoriels suivants. Cependant, si vous voulez en savoir plus sur les types de variables, visitez Types et variables C# (docs officiels C#).

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

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

True

Entiers signés

Ces types de données contiennent des valeurs entières (positives et négatives). Sur le 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);
        }
    }
}

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

Essayez d'assigner des valeurs hors plage c.-à-d. moins que -128 ou plus que 127 et voyez ce qui se passe.

2. short

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

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

-1109

3. int

Taille : 32 bits
Plage : -2 147 483 648 à 2 147 483 647
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);
        }
    }
}

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

4. long

Taille : 64 bits
Plage : -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807
Valeur par défaut : 0L [L à la fin représente que 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);
        }
    }
}

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

-7091821871

Entiers non signés

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

1. byte

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

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

2. ushort

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

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

3. uint

Taille : 32 bits
Plage : 0 à 4 294 967 295
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);
        }
    }
}

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

4. ulong

Taille : 64 bits
Plage : 0 à 18 446 744 073 709 551 615
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);
        }
    }
}

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

17091821871

Virgule flottante

Ces types de données contiennent des valeurs à virgule flottante c.-à-d. nombres contenant des valeurs décimales. Par exemple, 12,36, -92,17, etc.

1. float

Type virgule flottante simple précision
Taille : 32 bits
Plage : 1,5 × 10⁻⁴⁵ à 3,4 × 10³⁸
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);
        }
    }
}

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

43.27

2. double

Type virgule flottante double précision. Quelle est la différence entre simple et double précision ?
Taille : 64 bits
Plage : 5,0 × 10⁻³²⁴ à 1,7 × 10³⁰⁸
Valeur par défaut : 0,0D [D à la fin représente que 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);
        }
    }
}

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

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

B x

La valeur unicode de 'B' est '\u0042', donc l'affichage de ch1 affichera 'B'.

Décimal

Le type decimal a plus de précision et une plage plus petite comparé aux types virgule flottante (double et float). Il est donc approprié pour les calculs monétaires.
Taille : 128 bits
Valeur par défaut : 0,0M [M à la fin représente que la valeur est de type decimal]
Plage : (-7,9 × 10²⁸ à 7,9 × 10²⁸) / (10⁰ à 10²⁸)

Par exemple :

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

Quand 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.

Littéraux C#

Regardons l'instruction suivante :

int number = 41;

Ici,

int est un type de données
number 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 dans un programme directement 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.-à-d. sbyte, short, int, long, byte, ushort, uint et ulong.
Si un littéral entier se termine par L ou l, il est de type long. Pour la bonne pratique utilisez L (pas l).
```
long value1 = 4200910L; long value2 = -10928190L;
```
Si un littéral entier commence par 0x, il représente une valeur hexadécimale. Les nombres sans préfixes sont traités comme valeur décimale. La représentation octale et binaire ne sont pas autorisées en C#.
```
int decimalValue = 25; int hexValue = 0x11c; // valeur décimale 284
```

Littéraux à virgule flottante

Les littéraux à virgule flottante sont utilisés pour initialiser les variables de types 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 défaut.

Ces littéraux contiennent e ou E quand exprimés en notation scientifique.

double number = 24.67; // double par défaut float value = -12.29F; double scientificNotation = 6.21e2; // équivalent à 6.21 × 10² c.-à-d. 621

Littéraux caractère et chaîne

Les littéraux caractère sont utilisés pour initialiser les variables de type char.
Les littéraux caractère sont entre guillemets simples. Par exemple, 'x', 'p', etc.
Ils peuvent être représentés comme caractère, séquence d'échappement hexadécimale, représentation unicode ou valeurs entières castées en char.
```
char ch1 = 'R'; // caractère char ch2 = '\x0072'; // hexadécimal char ch3 = '\u0059'; // unicode char ch4 = (char)107; // casté depuis entier
```
Les littéraux chaîne sont la collection de littéraux caractère.
Ils sont entre guillemets doubles. Par exemple, "Hello", "Easy Programming", etc.
```
string firstName = "Richard"; string lastName = " Feynman";
```
C# supporte aussi les caractères de séquence d'échappement tels que :

Caractère Signification

\' Guillemet simple

\" Guillemet double

\\ Antislash

\n Nouvelle ligne

\r Retour chariot

\t Tabulation horizontale

\a Alerte

\b Retour arrière

Caractère	Signification
`\'`	Guillemet simple
`\"`	Guillemet double
`\\`	Antislash
`\n`	Nouvelle ligne
`\r`	Retour chariot
`\t`	Tabulation horizontale
`\a`	Alerte
`\b`	Retour arrière

Comprendre les mots-clés et identificateurs C# : règles, listes et bonnes pratiques Opérateurs C# — Guide complet des opérateurs en C#

Langue C