在与同事讨论了c# 3中var关键字的使用后，我想知道人们对通过var适当使用类型推断的看法是什么?
例如，我很懒地在有问题的情况下使用var，例如:-
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.
var更合法的用法如下:-
var l = new List<string>(); // Obvious what l will be.
var s = new SomeClass(); // Obvious what s will be.
有趣的是，LINQ似乎是一个灰色区域，例如:-
var results = from r in dataContext.SomeTable
select r; // Not *entirely clear* what results will be here.
结果很明显，因为它将是一个实现IEnumerable的类型，但它并不完全明显，与var声明一个新对象的方式相同。
当涉及到对象的LINQ时，情况就更糟了，例如:-
var results = from item in someList
where item != 3
select item;
这并不比等价的foreach(var item in someList){//…}相当于。
这里有一个关于类型安全的真正问题——例如，如果我们将该查询的结果放在一个接受IEnumerable<int>和IEnumerable<double>的重载方法中，调用者可能会无意中传入错误的类型。
Var确实保持强类型，但问题是，在定义中不立即显示类型是否危险，当重载意味着当你无意中将错误的类型传递给方法时，编译器可能不会发出错误，这种情况会被放大。
好吧，这个问题会一直固执己见，但我会试着给出我的观点-尽管我认为我的观点是如此混乱，你可能不会从中得到什么。
首先——有匿名类型，为此你需要使用“var”关键字来分配一个匿名类型作为类的对象——这里没有太多的讨论，“var”是必要的。
然而，对于更简单的类型，如int型、长型、字符串型等等，我倾向于输入适当的类型。主要是因为它有点像“懒人的工具”，我在这里看不到太多的好处，很少的按键和它可能带来的困惑，这是不值得的。特别是浮点数的各种类型(浮点数、双精度数、十进制数)使我感到困惑，因为我对字面量中的后缀不坚定——我喜欢在源代码中看到类型。
话虽如此，如果类型更复杂和/或它显式地重复在赋值的右侧，我倾向于大量使用var。这可以是一个List<string>或etc，例如:
var list = new List<string>();
在这种情况下，我认为没有必要重复类型两次——特别是当您开始更改代码和类型更改时——泛型类型可能会变得越来越复杂，因此必须更改它们两次只是一种痛苦。当然，如果你希望针对IList<string>编码，那么你必须显式地命名类型。
简而言之，我做了以下事情:
当类型很短或不能脱离上下文读取时，显式地命名类型
在必要时使用var(废话)
当var(在我看来)不影响可读性时，使用它来偷懒
var是c# 3.0和LINQ中为匿名类型引入的占位符。
因此，它允许在一个集合中为更少的列编写LINQ查询。不需要在内存中复制信息，只加载完成你需要做的事情所必需的东西。
var的使用一点也不坏，因为它实际上不是一个类型，但正如在其他地方提到的，它是一个类型的占位符，它是并且必须定义在等式的右边。然后，编译器将用类型本身替换关键字。
即使使用智能感知，当一个类型的名称很长时，它也特别有用。只需要写var，然后实例化它。之后阅读您的代码的其他程序员将很容易理解您在做什么。
就像使用
public object SomeObject { get; set; }
而不是:
public object SomeObject {
get {
return _someObject;
}
set {
_someObject = value;
}
}
private object _someObject;
每个人都知道属性在做什么，就像每个人都知道var关键字在做什么一样，这两个例子都倾向于通过简化它来简化可读性，并使程序员更容易编写有效的代码。
在IEnumerable<int>和IEnumerable<double>之间的比较中，你不需要担心-如果你传递了错误的类型，你的代码无论如何都不会编译。
不需要考虑类型安全，因为var不是动态的。这只是编译器的魔法，任何类型不安全的调用都会被捕获。
Linq绝对需要Var:
var anonEnumeration =
from post in AllPosts()
where post.Date > oldDate
let author = GetAuthor( post.AuthorId )
select new {
PostName = post.Name,
post.Date,
AuthorName = author.Name
};
现在看看智能感知中的anonEnumeration，它会显示类似IEnumerable<'a>
foreach( var item in anonEnumeration )
{
//VS knows the type
item.PostName; //you'll get intellisense here
//you still have type safety
item.ItemId; //will throw a compiler exception
}
c#编译器非常聪明——单独生成的anon类型如果它们的属性匹配，将具有相同的生成类型。
除此之外，只要你有智能感知，在上下文清楚的地方使用var是有意义的。
//less typing, this is good
var myList = new List<UnreasonablyLongClassName>();
//also good - I can't be mistaken on type
var anotherList = GetAllOfSomeItem();
//but not here - probably best to leave single value types declared
var decimalNum = 123.456m;
