Variables locales implicitement typées (Guide de programmation C#)

Article
06/10/2015

Les variables locales peuvent se voir attribuer un « type » déduit de var au lieu d'un type explicite. Le mot clé var demande au compilateur de déduire le type de la variable de l'expression à droite de l'instruction d'initialisation. Le type déduit peut être un type intégré, un type anonyme, un type défini par l'utilisateur ou un type défini dans la bibliothèque de classes .NET Framework. Pour plus d'informations sur l'initialisation de tableaux avec var, consultez Tableaux implicitement typés (Guide de programmation C#).

Les exemples suivants présentent différentes directions dans lesquelles les variables locales peuvent être déclarées avec var :

// i is compiled as an int 
var i = 5;

// s is compiled as a string 
var s = "Hello";

// a is compiled as int[] 
var a = new[] { 0, 1, 2 };

// expr is compiled as IEnumerable<Customer> 
// or perhaps IQueryable<Customer> 
var expr =
    from c in customers
    where c.City == "London" 
    select c;

// anon is compiled as an anonymous type 
var anon = new { Name = "Terry", Age = 34 };

// list is compiled as List<int>                              
var list = new List<int>();

Il est important de comprendre que le mot clé var ne signifie pas « Variant » et n'indique pas que la variable est peu typée ou à liaison tardive. Il signifie juste que le compilateur détermine et assigne le type le plus approprié.

Le mot clé var peut être utilisé dans les contextes suivants :

Sur les variables locales (les variables déclarées à la portée de la méthode) comme indiqué dans l'exemple précédent.
Dans une instruction d'initialisation for.
```
for(var x = 1; x < 10; x++)
```
Dans une instruction d'initialisation foreach.
```
foreach(var item in list){...}
```

Dans une instruction using

using (var file = new StreamReader("C:\\myfile.txt")) {...}

Pour plus d'informations, consultez Comment : utiliser des tableaux et des variables locales implicitement typés dans une expression de requête (Guide de programmation C#).

Types var et anonymes

Dans de nombreux cas, l'utilisation de var est facultative et simplement plus pratique en termes de syntaxe. Toutefois, lorsqu'une variable est initialisée avec un type anonyme, vous devez déclarer la variable comme var si vous devez accéder aux propriétés de l'objet à un point ultérieur. C'est un scénario courant dans les expressions de requête LINQ. Pour plus d'informations, consultez Types anonymes (Guide de programmation C#).

Du point de vue de votre code source, un type anonyme n'a aucun nom. Par conséquent, si une variable de requête a été initialisée avec var, la seule manière d'accéder aux propriétés dans la séquence d'objets retournée consiste à utiliser var comme type de la variable d'itération dans l'instruction foreach.

class ImplicitlyTypedLocals2
{
    static void Main()
    {
        string[] words = { "aPPLE", "BlUeBeRrY", "cHeRry" };

        // If a query produces a sequence of anonymous types,  
        // then use var in the foreach statement to access the properties. 
        var upperLowerWords =
             from w in words
             select new { Upper = w.ToUpper(), Lower = w.ToLower() };

        // Execute the query 
        foreach (var ul in upperLowerWords)
        {
            Console.WriteLine("Uppercase: {0}, Lowercase: {1}", ul.Upper, ul.Lower);
        }
    }
}
/* Outputs:
    Uppercase: APPLE, Lowercase: apple
    Uppercase: BLUEBERRY, Lowercase: blueberry
    Uppercase: CHERRY, Lowercase: cherry        
 */

Notes

Les restrictions suivantes s'appliquent aux déclarations de variable implicitement typées :

var peut être utilisé uniquement lorsqu'une variable locale est déclarée et initialisée dans la même instruction ; la variable ne peut pas être initialisée à la valeur Null, ni à un groupe de méthodes ou une fonction anonyme.
var ne peut pas être utilisé sur les champs à la portée de classe.
Les variables déclarées en utilisant var ne peuvent pas être utilisées dans l'expression d'initialisation. En d'autres termes, l'expression : int i = (i = 20); est autorisée, mais cette expression génère une erreur de compilation : var i = (i = 20);
Plusieurs variables implicitement typées ne peuvent pas être initialisées dans la même instruction.
Si un type nommé var est dans la portée, le mot clé var sera résolu à ce nom de type et ne sera pas traité comme faisant partie d'une déclaration de variable locale implicitement typée.

var peut également s'avérer utile avec les expressions de requête dans lesquelles le type construit exact de la variable de requête est difficile à déterminer. Cela peut se produire avec les opérations de regroupement et de classement.

Le mot clé var peut également être utile lorsque le type spécifique de la variable est fastidieux à taper au clavier, qu'il est évident ou qu'il n'augmente pas la lisibilité du code. Les types génériques imbriqués comme ceux utilisés avec les opérations de groupe sont un exemple où var est utile de cette manière. Dans la requête suivante, le type de la variable de requête est IEnumerable<IGrouping<string, Student>>. Tant que vous et ceux qui doivent conserver votre code comprenez ceci, l'utilisation des types implicites pour des raisons de commodité et de concision ne pose aucun problème.

// Same as previous example except we use the entire last name as a key. 
// Query variable is an IEnumerable<IGrouping<string, Student>> 
 var studentQuery3 =
     from student in students
     group student by student.Last;

Toutefois, l'utilisation de var présente au moins l'éventualité que votre code soit plus difficile à comprendre pour d'autres développeurs. Pour cette raison, la documentation C# utilise généralement var uniquement lorsqu'il est requis.

Voir aussi

Partager via

Variables locales implicitement typées (Guide de programmation C#)

Types var et anonymes

Notes

Voir aussi

Tâches

Référence

Concepts

Autres ressources

Ressources supplémentaires