Constantes et mot-clé var

1. Constantes

Une constante — c'est une variable "magique" dont la valeur ne peut pas (et ne doit pas !) changer après sa déclaration. Imagine un autocollant super-collant sur ta tasse avec écrit "Uniquement du thé". Une fois que tu as collé cet autocollant, tu ne peux plus remplacer le thé par du café (en tout cas, dans le cadre de C#).

const int DaysInWeek = 7;
const string HelloMessage = "Bienvenue !";

Dans ces exemples, DaysInWeek sera toujours 7, et HelloMessage — restera toujours un message de bienvenue. Une fois la valeur d'une constante définie, tu ne peux plus la changer.

Pourquoi utiliser des constantes ?

• Clarté du code : quand tu vois const double Pi = 3.14159;, aucun doute, c'est une constante, pas une variable qui pourrait changer au milieu du programme.
• Sécurité : personne (même toi dans quelques mois) ne pourra écraser la valeur de la constante par accident.
• Performance : le compilateur C# insère la valeur de la constante directement là où elle est utilisée, donc le programme tourne un peu plus vite.

Syntaxe de déclaration

const type nom = valeur;

• Type — n'importe quel type primitif (int, double, string, char, ainsi que les enums et les littéraux).
• Nom — on utilise généralement le style CamelCase ou PascalCase. Pour les "constantes magiques", parfois on met tout en majuscules avec des underscores (DAYS_IN_WEEK), mais en C# ce n'est pas obligatoire.

Exemples :

const double GRAVITY = 9.81; // accélération de la gravité, m/s^2
const char DELIMITER = ',';
const string DEVELOPER_NAME = "Ivan Petrov";

Particularités et limites des constantes

• La valeur doit être connue à la compilation. Ça veut dire que tu ne peux pas déclarer une constante dont la valeur est calculée à l'exécution.

const int NowYear = DateTime.Now.Year; // ERREUR DE COMPILATION !

• Tu peux utiliser seulement des types simples, string ou des enums.
• Impossible de faire une constante avec un tableau, un objet, le résultat d'une méthode, etc.
• Même les expressions qui semblent "simples" mathématiquement doivent être calculées par le compilateur, pas à l'exécution.

Par exemple, ça c'est interdit :

const string FullGreeting = "Salut, " + userName; // userName est une variable, interdit !

Mais ça, c'est bon :

const string DefaultGreeting = "Salut, utilisateur !";

Où déclare-t-on généralement les constantes ?

• Au début de la classe (ou du fichier), au-dessus des méthodes.
• Dans des classes spéciales pour les constantes (par exemple, public static class Constants).
• Au niveau de la classe, si la constante ne concerne que cette classe.

Exemple pour notre appli console :

class Program
{
    const string Welcome = "Bienvenue dans notre application !";
    static void Main(string[] args)
    {
        Console.WriteLine(Welcome);
    }
}

Constantes et portée

Les constantes suivent les mêmes règles de portée que les variables normales : elles ne sont visibles que là où elles sont déclarées.

2. Mot-clé var

Le mot-clé var — ce n'est pas un nouveau type de variable, mais juste un moyen pratique de laisser le compilateur deviner tout seul le type de la variable à partir du contexte.

C'est juste du sucre syntaxique — aucune magie ici, et après compilation la variable devient d'un type classique.

var age = 23;      // le compilateur comprend : age est un int
var name = "Anna"; // le compilateur comprend : string
var price = 99.99; // le compilateur comprend : double

Pourquoi var est apparu ?

• Lisibilité : pas besoin d'écrire des types à rallonge (genre Dictionary<string, List<int>>) à la main.
• Flexibilité : ça permet de changer plus facilement les types plus tard : tu modifies à droite — à gauche var s'adapte tout seul.
• Style moderne : quasiment tous les projets C# modernes utilisent var là où le type est évident à l'initialisation.

Quand utiliser (et il FAUT utiliser) var

• Quand à droite on voit clairement le type de la variable.
• Quand le type est évident (var price = 100; — c'est clairement un int).
• Quand le type est trop long ou compliqué (genre le résultat d'une requête LINQ).

var numbers = new int[] { 1, 2, 3, 4 };
var input = Console.ReadLine(); // input est un string (la méthode retourne un string)

Quand il vaut mieux NE PAS utiliser var

Si le type n'est pas évident à droite, le code peut devenir moins clair. Et si dans un mois, même avec l'aide des collègues, tu ne comprends plus quel type c'était, mieux vaut l'écrire explicitement.

var mystery = DoSomethingVeryComplicated(); // QUI ES-TU, mystery ???

Dans ce cas, mieux vaut écrire le type :

string result = DoSomethingVeryComplicated();

Règle d'or : utilise var seulement là où ça ne nuit pas à la lisibilité !

var — uniquement pour les variables locales

Le mot-clé var ne marche que pour les variables locales — à l'intérieur des méthodes. Tu ne peux pas utiliser var pour :

• les paramètres de méthode ;
• les propriétés de classe ;
• les constantes.

Comment var fonctionne "sous le capot"

• Le compilateur C# remplace var par le bon type à la compilation.
• Après compilation, il n'y a plus de var.
• Aucune perte de performance : c'est juste pour le confort du développeur.

var year = 2025; // à la compilation devient : int year = 2025;

Erreurs classiques avec var

• Variable non initialisée :

var a; // ERREUR : Le compilateur ne peut pas deviner le type !

• Initialisation ambiguë :

var list = null; // ERREUR : Le type null n'est pas défini !

• Réutilisation de la variable avec des types différents :

var value = 5; // value est un int
value = "Cinq"; // ERREUR : value est déjà un int !

Comparaison : types explicites et var

int age = 42;

var age = 42;

Dictionary<int, string> dict = SomeFunc();

var dict = SomeFunc();

string[] names = ...

var names = ...

3. Pièges et astuces

En C#, on écrit souvent des nombres magiques directement dans le code ("7", "3.14159", "0.15" et d'autres chiffres mystérieux). C'est pas top : si jamais la valeur change, il faudra chercher toutes les occurrences dans tout le projet. Utilise des constantes ! Ce sera plus simple pour toi, et tes collègues ne te maudiront pas...

Avec var, c'est l'excès inverse : si tout ton code n'est que du var et qu'on ne voit jamais les types — le code devient vite incompréhensible. Donc, utilise var là où c'est logique et clair dans le contexte, et sinon, n'hésite pas à écrire le type explicitement.