Variables locales implicitement typées (Guide de programmation C#)Implicitly typed local variables (C# Programming Guide)

Les variables locales peuvent être déclarées sans donner de type explicite.Local variables can be declared without giving an explicit type. Le mot clé var indique au compilateur de déduire le type de la variable à partir de l’expression située à droite de l’instruction d’initialisation.The var keyword instructs the compiler to infer the type of the variable from the expression on the right side of the initialization statement. 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.The inferred type may be a built-in type, an anonymous type, a user-defined type, or a type defined in the .NET Framework class library. Pour plus d’informations sur l’initialisation des tableaux avec var, consultez Tableaux implicitement typés.For more information about how to initialize arrays with var, see Implicitly Typed Arrays.

Les exemples suivants montrent différentes manières de déclarer des variables locales avec var :The following examples show various ways in which local variables can be declared with 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 n’est pas « variant » et qu’il n’indique pas que la variable est peu typée ou à liaison tardive.It is important to understand that the var keyword does not mean "variant" and does not indicate that the variable is loosely typed, or late-bound. Cela signifie simplement que le compilateur détermine et assigne le type qui convient le mieux.It just means that the compiler determines and assigns the most appropriate type.

Le mot clé var peut être utilisé dans les contextes suivants :The var keyword may be used in the following contexts:

  • Dans des variables locales (variables déclarées dans la portée de la méthode), comme indiqué dans l’exemple précédent.On local variables (variables declared at method scope) as shown in the previous example.

  • Dans une instruction d’initialisation forIn a for initialization statement.

    for(var x = 1; x < 10; x++)
    
  • Dans une instruction d’initialisation foreachIn a foreach initialization statement.

    foreach(var item in list){...}
    
  • Dans une instruction usingIn a using statement.

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

Pour plus d'informations, voir Procédure : Utiliser des tableaux et des variables locales implicitement typés dans une expression de requête.For more information, see How to: Use Implicitly Typed Local Variables and Arrays in a Query Expression.

Types var et anonymesvar and anonymous types

Dans de nombreux cas, l’utilisation de var est facultative et sert uniquement à simplifier la syntaxe.In many cases the use of var is optional and is just a syntactic convenience. Toutefois, lorsqu’une variable est initialisée avec un type anonyme, vous devez déclarer la variable en tant que var si vous savez déjà que vous aurez besoin d’accéder aux propriétés de l’objet.However, when a variable is initialized with an anonymous type you must declare the variable as var if you need to access the properties of the object at a later point. Il s’agit d’un scénario courant avec les expressions de requête LINQLINQ.This is a common scenario in LINQLINQ query expressions. Pour plus d’informations, consultez Types anonymes.For more information, see Anonymous Types.

Du point de vue de votre code source, un type anonyme n’a pas de nom.From the perspective of your source code, an anonymous type has no name. Par conséquent, si une variable de requête a été initialisée avec var, la seule façon d’accéder aux propriétés de la séquence d’objets retournée consiste à utiliser var comme type pour la variable d’itération de l’instruction foreach.Therefore, if a query variable has been initialized with var, then the only way to access the properties in the returned sequence of objects is to use var as the type of the iteration variable in the foreach statement.

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        
 */

RemarquesRemarks

Les restrictions suivantes s’appliquent aux déclarations de variables implicitement typées :The following restrictions apply to implicitly-typed variable declarations:

  • 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 vers la valeur Null, vers un groupe de méthodes ou vers une fonction anonyme.var can only be used when a local variable is declared and initialized in the same statement; the variable cannot be initialized to null, or to a method group or an anonymous function.

  • var ne peut pas être utilisé dans les champs situés dans la portée de la classe.var cannot be used on fields at class scope.

  • Les variables déclarées à l’aide de var ne peuvent pas être utilisées dans l’expression d’initialisation.Variables declared by using var cannot be used in the initialization expression. En d’autres termes, l’expression : int i = (i = 20); est légale, mais l’expression var i = (i = 20); génère une erreur de compilation.In other words, this expression is legal: int i = (i = 20); but this expression produces a compile-time error: var i = (i = 20);

  • Il n’est pas possible d’initialiser plusieurs variables implicitement typées dans la même instruction.Multiple implicitly-typed variables cannot be initialized in the same statement.

  • Si un type nommé var se trouve dans la portée, le mot clé var est résolu en ce nom de type et n’est pas considéré comme faisant partie d’une déclaration de variable locale implicitement typée.If a type named var is in scope, then the var keyword will resolve to that type name and will not be treated as part of an implicitly typed local variable declaration.

Le typage implicite avec le mot clé var ne peut être appliqué qu’aux variables comprises dans la portée de la méthode locale.Implicit typing with the var keyword can only be applied to variables at local method scope. Le typage implicite n’est pas disponible pour les champs de classe, car le compilateur C# rencontrerait un paradoxe logique pendant le traitement du code : le compilateur a besoin de connaître le type du champ, mais il ne peut pas déterminer le type tant que l’expression d’assignation n’est pas analysée, et l’expression ne peut pas être évaluée sans connaître le type.Implicit typing is not available for class fields as the C# compiler would encounter a logical paradox as it processed the code: the compiler needs to know the type of the field, but it cannot determine the type until the assignment expression is analyzed, and the expression cannot be evaluated without knowing the type. Examinons le code ci-dessous.Consider the following code:

private var bookTitles;

bookTitles est un champ de classe de type var.bookTitles is a class field given the type var. Le champ n’ayant aucune expression à évaluer, le compilateur ne peut pas déduire le type que bookTitles est censé avoir.As the field has no expression to evaluate, it is impossible for the compiler to infer what type bookTitles is supposed to be. De plus, l’ajout d’une expression au champ (comme vous le feriez pour une variable locale) est également insuffisant :In addition, adding an expression to the field (like you would for a local variable) is also insufficient:

private var bookTitles = new List<string>();

Quand le compilateur rencontre des champs pendant la compilation du code, il enregistre le type de chaque champ avant de traiter toutes les expressions associées.When the compiler encounters fields during code compilation, it records each field's type before processing any expressions associated with it. Le compilateur rencontre le même paradoxe en essayant d’analyser bookTitles : il doit connaître le type du champ, mais il détermine normalement le type de var en analysant l’expression, ce qui est impossible sans connaître le type au préalable.The compiler encounters the same paradox trying to parse bookTitles: it needs to know the type of the field, but the compiler would normally determine var's type by analyzing the expression, which isn't possible without knowing the type beforehand.

var peut également être utile avec les expressions de requête dans lesquelles il est difficile de déterminer le type construit exact de la variable de requête.You may find that var can also be useful with query expressions in which the exact constructed type of the query variable is difficult to determine. Cela peut se produire avec les opérations de regroupement et de classement.This can occur with grouping and ordering operations.

Le mot clé var peut également être utile lorsque le type de la variable est fastidieux à taper, ou bien lorsqu’il est évident ou lorsqu’il n’aide pas à la lisibilité du code.The var keyword can also be useful when the specific type of the variable is tedious to type on the keyboard, or is obvious, or does not add to the readability of the code. Par exemple, var est utile avec les types génériques imbriqués tels que ceux utilisés avec les opérations de groupe.One example where var is helpful in this manner is with nested generic types such as those used with group operations. Dans la requête suivante, le type de la variable de requête est IEnumerable<IGrouping<string, Student>>.In the following query, the type of the query variable is IEnumerable<IGrouping<string, Student>>. Tant que les personnes qui doivent gérer votre code comprennent ceci, le typage implicite peut tout à fait être utilisé pour rendre votre code plus concis et simplifier sa gestion.As long as you and others who must maintain your code understand this, there is no problem with using implicit typing for convenience and brevity.

// 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 risque de rendre votre code plus difficile à comprendre pour les autres développeurs.However, the use of var does have at least the potential to make your code more difficult to understand for other developers. C’est pourquoi, en général, la documentation C# utilise var uniquement lorsque cela est nécessaire.For that reason, the C# documentation generally uses var only when it is required.

Voir aussiSee also