0Pricing
C# Academy · Leçon

Inférence du type des variables locales avec var

Utilisez var lorsque le type est évident.

Inférence du type des variables locales avec var est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Qu’est-ce que var ?

var permet au compilateur d’inférer le type d’une variable locale à partir de son initialiseur. La variable reste fortement typée au moment de la compilation.

using System;

class Program {
    static void Main() {
        var count = 10;
        Console.WriteLine(count);
    }
}

var n’est pas dynamic

var est résolu au moment de la compilation. var x = 10 est exactement un int et ne peut pas contenir ensuite une chaîne.

using System;

class Program {
    static void Main() {
        var name = "Ada";
        Console.WriteLine(name.GetType().Name);
    }
}

Inférence à partir des littéraux

Le compilateur lit le littéral pour choisir le type : 1 est un int, 1.5 est un double et "hi" est une chaîne.

using System;

class Program {
    static void Main() {
        var a = 1;
        var b = 1.5;
        var c = "hi";
        Console.WriteLine(a.GetType().Name + " " + b.GetType().Name + " " + c.GetType().Name);
    }
}

Un initialiseur est obligatoire

Comme le type provient de l’initialiseur, les variables var doivent recevoir une valeur lors de leur déclaration.

using System;

class Program {
    static void Main() {
        var total = 0;
        for (int i = 1; i <= 4; i++) total += i;
        Console.WriteLine(total);
    }
}

var avec des types évidents

var est particulièrement utile lorsque le côté droit indique déjà le type, par exemple avec un appel de constructeur. Cela évite les répétitions.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var list = new List<int> { 1, 2, 3 };
        Console.WriteLine(list.Count);
    }
}

var avec les résultats de méthode

Vous pouvez utiliser var pour les valeurs renvoyées lorsque le nom de la méthode rend le type évident.

using System;

class Program {
    static int Square(int n) { return n * n; }
    static void Main() {
        var result = Square(6);
        Console.WriteLine(result);
    }
}

var dans foreach

var est pratique dans les boucles foreach parcourant des collections dont le type des éléments est connu.

using System;

class Program {
    static void Main() {
        var names = new[] { "Sam", "Lee" };
        foreach (var n in names)
            Console.WriteLine(n);
    }
}

Tableaux inférés

Un tableau au typage implicite new[] { ... } déduit le type de ses éléments à partir des valeurs.

using System;

class Program {
    static void Main() {
        var nums = new[] { 10, 20, 30 };
        Console.WriteLine(nums.Length);
    }
}

var reste sûr du point de vue du typage

Comme le type est fixe, affecter ensuite un type incorrect provoque une erreur de compilation, comme avec une déclaration explicite.

using System;

class Program {
    static void Main() {
        var x = 5;
        x = 10;
        Console.WriteLine(x);
    }
}

var et les types anonymes

var est obligatoire pour les types anonymes, car ils n’ont pas de nom que vous puissiez écrire.

using System;

class Program {
    static void Main() {
        var point = new { X = 3, Y = 4 };
        Console.WriteLine(point.X + ", " + point.Y);
    }
}

Avantage en matière de lisibilité

Utilisé correctement, var réduit le bruit et aligne le code, en particulier avec les noms de types génériques longs.

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var scores = new Dictionary<string, int> { ["Ann"] = 90 };
        Console.WriteLine(scores["Ann"]);
    }
}

Vérification rapide

Testez votre compréhension de var.

Récapitulatif

var indique au compilateur d’inférer le type d’une variable locale à partir de son initialiseur. La variable reste donc fortement typée et fixe au moment de la compilation, contrairement à dynamic.

Il nécessite un initialiseur, supprime les noms de types redondants et est obligatoire pour les types anonymes. Il améliore la lisibilité lorsque le type est déjà évident.

Questions Fréquemment Posées

La leçon « Inférence du type des variables locales avec var » est-elle gratuite ?

Oui — le texte complet de « Inférence du type des variables locales avec var » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Inférence du type des variables locales avec var » ?

Utilisez var lorsque le type est évident. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Inférence du type des variables locales avec var » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Inférence du type des variables locales avec var
  2. Quand éviter var
  3. Le type dynamic
  4. Expressions new dont le type est déduit du contexte
← Retour à C# Academy