Comment déclarez-vous des variables et utilisez-vous var ?

Question

Accepted Answer

C# est fortement typé — les variables ont un type connu au moment de la compilation. Vous pouvez déclarer une variable avec un type explicite ou utiliser **`var`** pour l'inférence de type (le compilateur déduit le type de la valeur), mais dans les deux cas le type est fixe. ## Déclarer des variables ```csharp int count = 42; // explicit type string name = "Ann"; double price = 9.99; bool active = true; var age = 30; // inferred as int (var = let the compiler figure it out) var message = "Hello"; // inferred as string var items = new List(); // inferred as List ``` `var` déduit le type de l'initialiseur — `var age = 30` est exactement équivalent à `int age = 30`. Surtout, **`var` est toujours fortement typé** : le type est fixe au moment de la compilation (vous ne pouvez pas assigner une chaîne à `age` plus tard) ; il est simplement déduit, pas dynamique. ## var nécessite un initialiseur et garde le type fixe ```csharp var x = 5; x = "hi"; // ❌ compile error — x is an int, can't become a string var y; // ❌ error — var needs an initializer to infer from ``` ## Quand utiliser var (style) ```csharp var user = new UserService(); // ✅ type is obvious from the right side — var is clean var count = users.Count; int total = CalculateComplexValue(); // explicit when the type isn't obvious aids readability ``` Utilisez `var` quand le type est évident du côté droit (réduit la redondance, surtout avec les types génériques longs) ; utilisez les types explicites quand c'est plus clair. ## Constantes et autres déclarations ```csharp const double Pi = 3.14159; // compile-time constant (can't change) readonly int id; // set once (in constructor), then immutable int a = 1, b = 2; // multiple of the same type nint nativeInt; // platform-sized integer ``` ## Types intégrés courants ```text int, long, short, byte integers float, double, decimal floating point (decimal for money — exact) bool, char, string boolean, character, text object the base of all types ``` ## Pourquoi c'est important Comprendre la déclaration de variables et `var` est une connaissance C# fondamentale au quotidien. Le point conceptuel clé est que **`var` est l'inférence de type, pas le typage dynamique** — une idée fausse courante. Avec `var`, le compilateur déduit le type de l'initialiseur, mais le type est toujours fixe au moment de la compilation (vous obtenez tous les avantages du typage statique — vérification de type, IntelliSense, performance), juste sans écrire le nom du type explicitement. Cela rend `var` une commodité pour la lisibilité (surtout avec les types génériques verbeux comme `Dictionary>`) plutôt qu'un assouplissement du système de types. Savoir quand utiliser `var` (quand le type est évident du côté droit, réduisant la redondance) par rapport aux types explicites (quand c'est plus clair), ainsi que les types intégrés (notamment **`decimal` pour l'argent** — arithmétique décimale exacte, contrairement à `double`), les constantes (`const`, `readonly`), est une connaissance quotidienne pour écrire du C#. Comprendre que C# est fortement typé partout (que vous écriviez le type ou utilisiez `var`), et les idiomes autour de la déclaration de variables, est fondamental pour lire et écrire du code C# propre et correct, et le point que `var` n'est pas dynamique est une clarification fréquente qui reflète une bonne compréhension du langage.