在C＃中使用var关键字的

提供有关在C＃中使用'变种'关键字的同事讨论后3我想知道是什么人的意见通过VAR是类型推断的适当使用？

After discussion with colleagues regarding the use of the 'var' keyword in C# 3 I wondered what people's opinions were on the appropriate uses of type inference via var?

例如我可疑的情况下，而懒洋洋地使用VAR，例如： -

For example I rather lazily used var in questionable circumstances, e.g.:-

foreach(var item in someList) { // ... } // Type of 'item' not clear.
var something = someObject.SomeProperty; // Type of 'something' not clear.
var something = someMethod(); // Type of 'something' not clear.

是变种的

更多合法的用途如下： -

More legitimate uses of var are as follows:-

var l = new List<string>(); // Obvious what l will be.
var s = new SomeClass(); // Obvious what s will be.

有趣的LINQ似乎有点灰色地带，例如组成： -

Interestingly LINQ seems to be a bit of a grey area, e.g.:-

var results = from r in dataContext.SomeTable
              select r; // Not *entirely clear* what results will be here.

很清楚什么结果将在这将是其实现IEnumerable一种类型，但它是不以同样的方式一个变种声明一个新的对象完全是显而易见的。

It's clear what results will be in that it will be a type which implements IEnumerable, however it isn't entirely obvious in the same way a var declaring a new object is.

这是当它涉及到LINQ的对象，例如更糟糕： -

It's even worse when it comes to LINQ to objects, e.g.:-

var results = from item in someList
              where item != 3
              select item;

这是不超过equivilent的foreach（在someList VAR项）{// ...} equivilent。

This is no better than the equivilent foreach(var item in someList) { // ... } equivilent.

有大约类型安全一个真正的问题在这里 - 例如，如果我们到查询的结果放到一个重载的方法接受IEnumerable的＆LT; INT＆GT;和IEnumerable＆LT;双＆GT;主叫方可能会在无意中传递了错误的类型。

There is a real concern about type safety here - for example if we were to place the results of that query into an overloaded method that accepted IEnumerable<int> and IEnumerable<double> the caller might inadvertently pass in the wrong type.

VAR 的确实的保持强类型，但真正的问题是它是否是危险的类型不会对定义立即显现出来，一些东西，当过载的意思是当你无意中传递了错误类型的方法编译器错误可能不会发出放大。

var does maintain strong typing but the question is really whether it's dangerous for the type to not be immediately apparent on definition, something which is magnified when overloads mean compiler errors might not be issued when you unintentionally pass the wrong type to a method.