将它用于匿名类型—这就是它存在的目的。其他的都是徒劳无功。像许多使用C长大的人一样，我习惯于查看类型声明的左侧。除非迫不得已，我是不会看右边的。在任何旧的声明中使用var都让我一直这样做，我个人觉得不舒服。

Those saying 'it doesn't matter, use what you're happy with' are not seeing the whole picture. Everyone will pick up other people's code at one point or another and have to deal with whatever decisions they made at the time they wrote it. It's bad enough having to deal with radically different naming conventions, or - the classic gripe - bracing styles, without adding the whole 'var or not' thing into the mix. The worst case will be where one programmer didn't use var and then along comes a maintainer who loves it, and extends the code using it. So now you have an unholy mess.

标准是一件好事，因为它们意味着你更有可能捡起随机代码，并能够快速地理解它。不同的东西越多，就越难。而转移到“无处不在的var”风格会有很大的不同。

I don't mind dynamic typing, and I don't mind implict typing - in languages that are designed for them. I quite like Python. But C# was designed as a statically explicitly-typed language and that's how it should stay. Breaking the rules for anonymous types was bad enough; letting people take that still further and break the idioms of the language even more is something I'm not happy with. Now that the genie is out of the bottle, it'll never go back in. C# will become balkanised into camps. Not good.

Var对于匿名类型是必不可少的(正如之前对这个问题的回答之一所指出的那样)。

我会把所有其他关于宗教战争利弊的讨论归类为“宗教战争”。我的意思是对……的相对优点进行比较和讨论。

var i = 5;
int j = 5;

SomeType someType = new SomeType();
var someType = new SomeType();

.．.完全是主观的。

隐式类型意味着使用var关键字声明任何变量都不会在运行时造成损失，因此归根结底，这是一个关于如何让开发人员满意的争论。

这没有错，但可能不合适。参见所有其他回答的例子。

Var x = 5;(坏的)

var x = new SuperDooperClass();(好)

Var x = from t，单位为db。select new {Property1 = t.Field12};(更好的)

我认为var的使用应该与明智选择的变量名称相结合。

我在foreach语句中使用var没有问题，前提是它不是这样的:

foreach (var c in list) { ... }

如果是这样的话:

foreach (var customer in list) { ... }

．.． 这样，阅读代码的人就更有可能理解什么是“列表”。如果您可以控制列表变量本身的名称，那就更好了。

这同样适用于其他情况。这是非常无用的:

var x = SaveFoo(foo);

．.． 但这是有道理的:

var saveSucceeded = SaveFoo(foo);

各有各的，我想。我发现自己这样做，简直是疯了:

var f = (float)3;

我需要一个12步的var程序。我叫Matt，我(ab)使用var。

Apart from readability concerns, there is one real issue with the use of 'var'. When used to define variables that are assigned to later in the code it can lead to broken code if the type of the expression used to initialize the variable changes to a narrower type. Normally it would be safe to refactor a method to return a narrower type than it did before: e.g. to replace a return type of 'Object' with some class 'Foo'. But if there is a variable whose type is inferred based on the method, then changing the return type will mean that this variable can longer be assigned a non-Foo object:

var x = getFoo(); // Originally declared to return Object
x = getNonFoo();

所以在这个例子中，改变getFoo的返回类型会使getNonFoo的赋值变为非法。

如果getFoo和它的所有用途都在同一个项目中，这不是什么大问题，但如果getFoo在一个库中供外部项目使用，如果他们像这样使用'var'，你就不能确保缩小返回类型不会破坏某些用户的代码。

正是由于这个原因，当我们在Curl编程语言中添加类似的类型推断特性(在Curl中称为'def')时，我们阻止了对使用这种语法定义的变量的赋值。

Var，在我看来，在c#中是一个很好的东西。任何这样类型的变量仍然是强类型的，但是它从赋值函数的右边得到它的类型。因为类型信息在右侧可用，在大多数情况下，也必须在左侧输入它是不必要的和过于冗长的。我认为这在不降低类型安全性的情况下显著提高了可读性。

From my perspective, using good naming conventions for variables and methods is more important from a readability perspective than explicit type information. If I need the type information, I can always hover over the variable (in VS) and get it. Generally, though, explicit type information shouldn't be necessary to the reader. For the developer, in VS you still get Intellisense, regardless of how the variable is declared. Having said all of that, there may still be cases where it does make sense to explicitly declare the type -- perhaps you have a method that returns a List<T>, but you want to treat it as an IEnumerable<T> in your method. To ensure that you are using the interface, declaring the variable of the interface type can make this explicit. Or, perhaps, you want to declare a variable without an initial value -- because it immediately gets a value based on some condition. In that case you need the type. If the type information is useful or necessary, go ahead and use it. I feel, though, that typically it isn't necessary and the code is easier to read without it in most cases.