Tout avantage à utiliser implicitement type var

Question

Je n'ai pas l'habitude d'utiliser Var variable implicitement typée. Tout le monde peut me faire savoir l'avantage d'utiliser une telle variable?

Answer 1

Une chose est qu'il est un raccourci pour les types longs ... Tels que:

List<Dictionary<string, object>> myList = getList(); 

peut être simplifié à:

var myList = getList(); 

Answer 2

types Annonymous:

var person = new { Name = "John", Surname = "Doe" }; 

Answer 3

En utilisation normale, 'var' est entièrement optionnel et équivaut à spécifier manuellement le type. Voir here.

Cependant, le mot-clé 'var' est nécessaire pour anonymous types, que j'ai normalement utilisé conjointement avec LINQ.

Answer 4

Je trouve précisément beaucoup plus facile à lire ceci:

foreach(var dbitem in context.usp_GetUserAndAccountData()) 
{ 
    txtUserName.Text = dbitem.UserName; 
    // ... 
} 

que ceci:

foreach(ISingleResult<usp_GetUserAndAccountDataResult> dbitem in context.usp_GetUserAndAccountData()) 
{ 
    txtUserName.Text = dbitem.UserName; 
    // ... 
} 

Pour moi, peu importe ce que je définis explicitement dbitem, je vais faire encore les mêmes actions ; donc var ici est inestimable!
Et la beauté de tout cela est qu'IntelliSense vous énumérera toujours tous les membres du type attendu à l'autre extrémité (tel que UserName dans mon exemple).

Answer 5

Meilleure lisibilité du code. Surtout utilisé avec les constructeurs et à long nom du type:

var anArray = new String[3]; 
var iStream = new InputStream(...); 
var dict = new Dictionary<string, int>(); 

Answer 6

Je crois qu'il a été créé dans le but de types anonymes (ala exemple kugels):

var person = new { Name = "John", Surname = "Doe" }; 

Cependant, depuis je l'ai découvert je dois admettre Je l'ai trouvé très utile en cours d'utilisation au jour le jour où traiter les noms de type plus, par exemple:

var aaa = new Dictionary<string, List<ReallyLongTypeName>>(); 
// vs 
Dictionary<string, List<ReallyLongTypeName>> aaa = new Dictionary<string, List<ReallyLongTypeName>>(); 

Un autre effet secondaire est que les noms de type peuvent changer (ou être remplacés par d'autres t ypes), mais le code qui utilise var ne cassera pas », par exemple:

var item = this.GetItem(); 
this.Name = item.Name; 
this.Age = item.Age; 

Tant que la valeur de retour de GetItem a toujours une propriété Name et une propriété Age (qui sont compatibles avec les propriétés sur this) puis GetItems peut retourner un objet entièrement différent et le code ci-dessus sera toujours compiler. (Mais attention, les assemblages compilés existants ne peuvent pas utiliser la même astuce!)

Answer 7

Sachez que l'utilisation de var n'est pas toujours ce qu'elle semble être (mais c'est surtout le cas).Un exemple est le suivant:

datalist est un contrôle DataList sur un formulaire en ligne

foreach (var item in dataList.Items) 
{ 
    // item is of type System.Object 
} 

foreach (DataListItem item in dataList.Items) 
{ 
    // item is of type DataListItem 
} 

Answer 8

Outre les autres réponses, à moi un réel avantage est en matière de code externe, pour découpler le type de variable la signature de la méthode réelle.

Tenir compte de cette interface:

public interface IFoo 
{ 
    List<Foo> GetSomething(); 
} 

Et que vous avez deux lignes de code:

List<Foo> foos = fooRepo.GetSomething(); 
var foos2 = fooRepo.GetSomething(); 

Même résultat pour au-dessus de deux lignes. (List<Foo> retourné).

Maintenant, si changé l'interface:

public interface IFoo 
{ 
    Dictionary<bool,Foo> GetSomething(); 
} 

La première ligne serait maintenant lancer une erreur de compilation, le second ne serait pas:

List<Foo> foos = fooRepo.GetSomething(); // error - can't convert from Dictionary<bool,Foo> to List<Foo> 
var foos2 = fooRepo.GetSomething(); // works! 

Ceci est très pratique lorsque vous travaillez avec les dépôts/autres projets où les contrats d'interface/les signatures de méthodes peuvent changer.

Oui, vous devez encore recompiler les classes, mais vous ne devez pas revenir en arrière et modifier tout le code qui référencé l'ancien type de retour.