在与同事讨论了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确实保持强类型,但问题是,在定义中不立即显示类型是否危险,当重载意味着当你无意中将错误的类型传递给方法时,编译器可能不会发出错误,这种情况会被放大。


当前回答

在做了十年的Java专业人员之后,我在c#世界里还是个新手。我最初的想法是“哦,不!这就把类型安全丢进了下水道”。然而,我对var了解得越多,我就越喜欢它。

1) Var与显式声明的类型一样是类型安全的。这都是关于编译时语法糖。

2)遵循DRY原则(不要重复)。DRY是关于避免冗余的,在两边都命名类型肯定是冗余的。避免冗余就是要让你的代码更容易修改。

3)至于确切的型号……嗯. .我认为你应该有一个大致的概念你有一个整数,一个套接字,一些UI控件,等等。智能感知将从这里引导你。知道确切的类型通常并不重要。例:我认为99%的情况下你并不关心给定的变量是long还是int, float还是double。对于最后1%的情况,在真正重要的地方,只需将鼠标指针悬停在var关键字上方。

4)我曾看到过这样一种荒谬的观点:现在我们需要回到1980年风格的匈牙利疣,才能区分变量类型。毕竟,在蒂莫西·道尔顿(Timothy Dalton)扮演詹姆斯·邦德(James Bond)的时代,这是判断变量类型的唯一方法。但现在是2010年。我们已经学会了根据变量的用法和内容来命名变量,并让IDE指导我们确定它们的类型。只要继续这样做,var就不会伤害你。

总而言之,var不是什么大东西,但它确实是一个很好的东西,而且它是Java最好很快复制的东西。所有反对的观点似乎都是基于ide之前的谬误。我会毫不犹豫地使用它,我很高兴R#帮助我做到这一点。

其他回答

@erlando,出于好奇,为什么你需要知道变量的类型看源代码?

在我的实践中,我发现变量类型只在我在代码中使用它的时候对我来说是重要的。

如果我试图做一些不适当的操作在某些evar编译器欣然给我一个错误\警告。

我真的不关心someVar有什么类型,如果我明白为什么它被使用在给定的上下文中。

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')时,我们阻止了对使用这种语法定义的变量的赋值。

当然,int很简单,但当变量的类型是IEnumerable<MyStupidLongNamedGenericClass<int, string>>时,var会让事情变得更简单。

好吧,这个问题会一直固执己见,但我会试着给出我的观点-尽管我认为我的观点是如此混乱,你可能不会从中得到什么。

首先——有匿名类型,为此你需要使用“var”关键字来分配一个匿名类型作为类的对象——这里没有太多的讨论,“var”是必要的。

然而,对于更简单的类型,如int型、长型、字符串型等等,我倾向于输入适当的类型。主要是因为它有点像“懒人的工具”,我在这里看不到太多的好处,很少的按键和它可能带来的困惑,这是不值得的。特别是浮点数的各种类型(浮点数、双精度数、十进制数)使我感到困惑,因为我对字面量中的后缀不坚定——我喜欢在源代码中看到类型。

话虽如此,如果类型更复杂和/或它显式地重复在赋值的右侧,我倾向于大量使用var。这可以是一个List<string>或etc,例如:

var list = new List<string>();

在这种情况下,我认为没有必要重复类型两次——特别是当您开始更改代码和类型更改时——泛型类型可能会变得越来越复杂,因此必须更改它们两次只是一种痛苦。当然,如果你希望针对IList<string>编码,那么你必须显式地命名类型。

简而言之,我做了以下事情:

当类型很短或不能脱离上下文读取时,显式地命名类型 在必要时使用var(废话) 当var(在我看来)不影响可读性时,使用它来偷懒

我广泛使用var。有人批评这降低了代码的可读性,但没有证据支持这种说法。

Admittedly, it may mean that it's not clear what type we are dealing with. So what? This is actually the point of a decoupled design. When dealing with interfaces, you are emphatically not interested in the type a variable has. var takes this much further, true, but I think that the argument remains the same from a readability point of view: The programmer shouldn't actually be interested in the type of the variable but rather in what a variable does. This is why Microsoft also calls type inference “duck typing.”

当我用var声明变量时,它会做什么呢?简单,智能感知让它做什么它就做什么。任何关于c#的推理都忽略了IDE,这是不现实的。实际上,每个c#代码都是在支持智能感知的IDE中编写的。

如果我使用了一个var声明的变量,并对变量的用途感到困惑,那么我的代码就有根本性的问题。Var不是原因,它只是使症状可见。不要责怪送信的人。

现在,c#团队发布了一个编码指南,声明var应该只用于捕获创建匿名类型的LINQ语句的结果(因为在这里,我们没有真正的替代var的方法)。去他的。只要c#团队没有给我一个合理的论证,我就会忽略它,因为在我的专业和个人观点中,这纯粹是胡扯。(抱歉;我找不到相关指南的链接。)

Actually, there are some (superficially) good explanations on why you shouldn't use var but I still believe they are largely wrong. Take the example of “searchabililty”: the author claims that var makes it hard to search for places where MyType is used. Right. So do interfaces. Actually, why would I want to know where the class is used? I might be more interested in where it is instantiated and this will still be searchable because somewhere its constructor has to be invoked (even if this is done indirectly, the type name has to be mentioned somewhere).