为什么ReSharper要使用'var'为了一切？

Question

我刚刚开始将 ReSharper 与 Visual Studio 结合使用（在收到许多关于 SO 的建议之后）。为了尝试一下，我打开了一个最近的 ASP.NET MVC 项目。我注意到它建议的第一个也是最常见的事情之一是将我的大部分/所有显式声明更改为 var 。例如：

//From This:
MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);
//To This:
var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

等等，甚至是简单的类型，如 int、bool 等。

为什么推荐这样做？我没有计算机科学或 .NET 背景，最近“陷入”.NET 开发中，所以我真的很想了解正在发生的事情以及它是否有益。

Answer 1

ReSharper 的建议显然是过度使用 var 关键字。您可以在类型明显的地方使用它：

var obj = new SomeObject();

如果类型不明显，您应该将其写出来：

SomeObject obj = DB.SomeClass.GetObject(42);

Answer 2

原因之一是提高了可读性。哪个更好？

Dictionary<int, MyLongNamedObject> dictionary = new Dictionary<int, MyLongNamedObject>();

或者

var dictionary = new Dictionary<int, MyLongNamedObject>();

Answer 3

我个人更喜欢关闭这个建议。使用 var 通常可以提高可读性；但正如您所提到的，它有时会减少它（使用简单类型，或者当结果类型晦涩时）。

我更喜欢选择何时使用 var 和何时不使用。但再说一遍，那只是我。

Answer 4

var 可以提高代码的可读性，同时降低代码的即时理解性。同样，它会降低其他情况下代码的可读性。有时它的使用是中性的。可读性与理解性的衡量并不成正比，而是取决于具体情况。有时两者同时增加或减少。

因素在于 var 的应用范围，以及目标对读者立即混淆其数据类型的支持程度，或者是否需要其类型信息来理解手头的程序部分。

例如，错误的命名可能会导致 var 导致代码理解力下降。但这不是 var 的错：

var value1 = GetNotObviousValue(); //What's the data type? 
//vs. 
var value2 = Math.Abs(-3); // Obviously a numeric data type. 

有时，当代码在缺少它的情况下更具可读性时，将 var 用于简单数据类型是没有意义的：

var num = GetNumber(); // But what type of number?
// vs. 
double num = GetNumber(); // I see, it's a double type. 

有时 var 可用于隐藏您不一定关心其复杂性的数据类型信息：

    IEnumerable<KeyValuePair<string,List<Dictionary<int,bool>>>> q = from t in d where t.Key == null select t; // OMG! 
    //vs. 
    var q = from t in d where t.Key == null select t;

    // I simply want the first string, so the last version seems fine.  
    q.First().Key; 

当存在匿名类型时，您必须使用var因为没有类型名称来调用它：

var o = new { Num=3, Name="" };

当您让 Visual Studio Intellisense 提供类型信息而不管 var 时，您就不需要通过严格的代码阅读而无需依赖于您的理解。明智的做法是假设并非每个人都拥有或使用 Intellisense。

总之，根据上面的例子，我建议全权委托使用 var 并不是一个好主意，因为大多数事情最好根据具体情况适度完成。手如图所示。

为什么Resharper默认全部使用它？我建议轻松一点，因为它无法解析情况的细微差别来决定何时最好不使用它。

Answer 5

在 ReSharper（8.02，但也可能是其他版本）中，“使用隐式类型局部变量声明”建议的选项可以根据您的偏好进行调整，无论是什么，首先打开选项菜单ReSharper：

然后，在“代码检查”下，调整所选语言的“检查严重性”，在我的case c#:

如您所见，有一些选项可以调整 ReSharper 提出的所有建议。希望这可以帮助像我这样已经有了“var”使用策略并且只是希望 ReSharper 尊重它的人:)

Answer 6

'var' 是为了清晰

关于是否使用 var 关键字的主要争论在于代码对您和其他开发人员的可读性如何。

就像你在写一个故事一样，没有明确的正确答案。但让我们用简单的英语来看一些例子。

杰克向比尔打招呼。他不喜欢他，所以转身走了另一条路。

谁走了另一条路？杰克还是比尔？在这种情况下，使用名称“Jake”和“Bill”就像使用类型名称一样。而“He”和“him”就像使用var关键字。在这种情况下，说得更具体可能会有所帮助。下面的例子就更清楚了。

杰克向比尔打招呼。杰克不喜欢比尔，所以他转身走了另一条路。

在这种情况下，更具体可以使句子更清晰。但情况并非总是如此。在某些情况下，具体化会使阅读变得更加困难。

比尔喜欢读书，所以比尔去了图书馆，比尔拿出了一本比尔一直喜欢的书。

在这种情况下，如果我们使用“he”，并且在某些情况下将他的名字全部省略，那么阅读句子会更容易，这相当于使用 var 关键字。

比尔喜欢读书，所以他去图书馆拿出了一本他一直喜欢的书。

这些例子涵盖了要点，但并没有讲述整个故事。在这些例子中，只有一种方式来指代这个人。要么使用他们的名字，要么使用更通用的术语，如“他”和“他”。

就代码而言，我们有 3 种方法来帮助提高清晰度。类型、变量名和赋值。以这行代码为例：

Person p = GetPerson();

现在的问题是，这行代码中是否有足够的信息来帮助您弄清楚发生了什么？

下面这行代码怎么样？您是否仍然知道 p 在这种情况下意味着什么：

var p = GetPerson();

现在怎么样：

var p = Get();

或者现在：

var person = Get();

或者这个：

var t = GetPerson();

或者这个：

var u = Person.Get();

关键字 var 在给定场景中是否有效取决于很多关于代码上下文的内容，例如变量、类和方法的命名方式。它还取决于代码及其周围代码的其余部分的复杂性。

就我个人而言，我喜欢使用 var 关键字，它在大多数时候对我来说更全面。但我也倾向于根据类型命名我的变量，这样我就不会真正丢失任何信息。

也就是说，有时根据具体情况，我会做出例外，这就是任何复杂事物的本质，而软件如果不复杂就什么都不是。

Answer 7

令我惊讶的是，没有人提到更改实例化对象的类型也更容易，因为它

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

是一种重复形式。如果我想将 AVeryLongTypeName 更改为其派生类之一，则在使用 var 时只需更改一次，并且仍然可以访问子类的方法。

除此之外，提高可读性是很重要的一点，但正如其他人所说，var 不应该被过度使用，所以我认为在 Resharper 中关闭提示是绝对可以的。

Answer 8

我也不喜欢这个。

我不希望这变成关于 var 的使用的争论，它有它的用途，但不应该在任何地方使用。

要记住的关键一点是 ReSharper 可以根据您想要的任何编码标准进行配置。

编辑：ReSharper 和 var

Answer 9

我看到了很多正确答案，但缺少完整的答案。

确实，ReSharper 默认情况下过度使用 var。我想大多数人都会同意这一点。当使用 var 并且类型很明显时（例如当您使用 new 语句时），它也更容易阅读。我看到一篇文章展示了如何更新检查严重性以仅显示使用 var 的提示。

我曾尝试先对其他帖子发表评论，以添加设置这些帖子的位置，但没有声誉。显然，我也没有资格发布我的设置屏幕截图。

我将解释如何到达那里。

在 Visual Studio 中>主菜单>重磨器>选项>代码编辑> C#>代码风格>声明中的 Var 使用

• 对于内置类型 使用显式类型
• 对于简单类型 在明显时使用 'var'
• 在其他地方使用 'var'

ReSharper 帮助文档：代码语法风格：隐式/显式键入（'var' 关键字）
— 配置使用“var”关键字的首选项

Answer 10

我的规则是这样的：

• 你是否声明一个基本类型（即byte、char、string、int[]< /code>、双精度？、十进制等）？ ->使用类型：

  string myStr = "foo";
  int[] myIntArray = [123, 456, 789];
  双倍的？ myDouble = 123.3;
  

• 您是否声明了复杂类型（即 List、Dictionary、MyObj） ？ ->使用var：

  var myList = List();
  var myDictionary = Dictionary<字符串, 字符串>();
  var myObjInstance = new MyObj();
  

Answer 11

我只想指出 C# 编码约定

当变量的类型从赋值的右侧很明显时，或者当精确类型不重要时

这可能就是 ReSharper 中默认打开提示的原因。他们还在同一文档的下面提供了一些不会提高可读性的情况。

Answer 12

ReSharper 建议使用 var，因为它可以使对象创建更加整洁。

比较这两个例子：

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

这只是一个简写，应该更容易阅读。

我认为当你用“new”显式创建新对象时就很好了。然而，在您的示例中，如果类命名不正确，可能并不明显。

Answer 13

瓦尔太棒了！我遇到过许多开发人员，他们的印象是 var 绑定到动态类型，但事实并非如此。它仍然是静态类型，只是由编译器决定。

以下是使用 var 的一些令人惊奇的优点

减少输入 var 更短且更易于阅读，例如

Dictionary> postcodes = new Dictionary>() Yuk.

var postcodes = new Dictionary>() \o/\o/

更具描述性的变量名称 - 很脆弱，但我认为让 var 的流动性在这里发挥作用很重要。由于 var 有点模糊，它确实鼓励使用更具描述性的变量名称，而不是让类型自己说话。

更少的代码更改 - 如果方法调用的返回类型发生更改。您只需更改方法调用，而不是使用它的每个地方。

匿名类型 - 匿名类型是一个非常强大的概念，特别是在 WebApi 等领域 部分资源。没有 var，它们就无法使用。

然而，有时显式声明类型很有用，我发现这在基元或结构中最有用。例如，我个人认为这种语法不是很有用：

for(var i = 0; i < 10; i++) 
{

}

vs

for(int i = 0; i < 10; i++) 
{

}

这完全取决于个人喜好，但使用 var 确实会加快您的开发速度并解锁匿名类型的整个世界。

Answer 14

顺便说一句，ReSharper 区分了“您可能希望将此建议应用于您的代码”和“您的代码已损坏，需要我修复它吗？”。 var 关键字位于建议类别中，以及“反转 if 以减少嵌套”等内容；你不必遵循它。

您可以通过“选项”对话框或直接通过该警报的弹出菜单来配置每个警报的烦人程度。您可以降级诸如 var 建议之类的内容，使其不那么突出，或者您可以升级诸如“使用扩展方法”警报之类的内容，使其显示为实际错误。

Answer 15

.NET 3.0 的 var 功能只是 类型推断，它是类型安全的，通常使您的代码更易于阅读。但您不必这样做，并且如果您愿意，可以在 ReSharper 中关闭该建议。

Answer 16

在我看来，只有在定义变量的值时立即清楚类型是什么时才应使用var。

示例：

var s = "string value";

很明显s 是一个字符串。

我相信当变量类型名称非常复杂时它也是合适的。

示例：

Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>> dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

// This is a little easier to read than the above statement
var dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

除了这些场景之外，我没有看到使用 var 能带来任何增益 code>，但我可以想到一些可能有害的场景：

例如，一次性类型的右侧变量值没有清楚地显示类型。 IDisposable 的处置很容易被忘记

示例：

// returns some file writer
var wr = GetWriter();

wr.add("stuff");
wr.add("more stuff");

//...
//...

// Now `wr` needs to be disposed, 
// but there is no clear indication of the type of `wr`,
// so it will be easily overlooked by code writer and code reviewer.

Answer 17

没有技术上的区别，如果您使用 var，则类型由编译器隐含。如果您有这样的代码：

var x = 1;

x 隐含为 int 并且不能为其分配其他值。

如果您更改变量的类型，则 var 关键字很有用；然后您只需进行一项更改，而不是两项：

var x = 1; --> var x = "hello";
int x = 1; --> string x = "hello";

Answer 18

var 关键字是在 C# 3.0 中引入的 - 它允许我们忘记显式指定类型。

没有真正的区别

使用MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

或

var foo = DB.MyObjects.SingleOrDefault( w => w.Id == 1);

除了纯粹的可读性和更少的错误机会。

这看起来像是一个陈词滥调的例子，但是说下面的内容可能会帮助你理解：

var myInt = 23;

返回一个 int 类型，而

var myInt = "23";

返回一个 string 类型。

MSDN 参考

Answer 19

指定显式对象类型在某种程度上是多余的。即使翻译成英语，它听起来也是多余的：“将 X 类型的对象放入 X 类型的变量中”与“将 X 类型的对象放入变量中”。

但是，使用“var”有其局限性。它阻止了多态性的以下使用，这是纯粹的美：

假设一只狗继承了动物； Cat 扩展了 Animal 类层次结构：

Animal x = new Dog();
DoStuffWithDog(x as Dog);

x = new Cat();
DoStuffWithCat(x as Cat);

void DoStuffWithDog(Dog d){}
void DoStuffWithCat(Cat c){}

相同的代码，其中 x 用“var”声明将无法编译。

var x = new Dog(); // from this point, x is a Dog
DoStuffWithDog(x as Dog);

x = new Cat(); // cannot assign a Cat instance to a Dog
DoStuffWithCat(x as Cat);

void DoStuffWithDog(Dog d){}
void DoStuffWithCat(Cat c){}

无论如何，回到最初的问题，我不使用 Resharper，但我认为它足够聪明，可以检测何时不使用“var”。 :-)

Answer 20

没有技术差异（正如 eWolf 指出的）。您可以使用其中之一，生成的 CLR 代码看起来是一样的。

在我看来，主要的好处是这往往会迫使您使用更好的变量命名。在您的示例中，“foo”对于变量名来说是一个非常糟糕的选择。

Answer 21

'var' 向您的代码添加了一种“动态”元素（尽管代码当然仍然是严格类型化的）。我建议不要在类型不清楚的情况下使用它。考虑这个例子：

var bar = GetTheObjectFromDatabase();
bar.DoSomething();

ClassA {
  void DoSomething() {
  //does something
  }
}

ClassB {
  void DoSomething() {
  //does something entirely different
  }
}

如果 GetTheObjectFromDatabase() 的返回类型从类型 A 更改为类型 B，我们不会注意到，因为这两个类都实现了 DoSomething()。然而，现在的代码实际上可能会执行完全不同的操作。

这可能与将不同的内容写入日志一样微妙，因此您可能不会注意到，直到为时已晚。

var 的以下使用应该总是没问题的：

var abc = new Something();

Answer 22

对于那些不喜欢不断使用“var”的人，您还可以阻止 ReSharper 在执行“引入变量”时默认为 var。这是让我沮丧了很长一段时间的事情，它总是默认为var，而我每次都在改变它。

这些设置位于“代码编辑”>“代码编辑”下。 C#>代码风格

Answer 23

根据 JetBrains（ReSharper 的作者）的说法，他们鼓励默认使用 var。

来自他们的网站：

使用 C# 3.0 中引入的隐式类型局部变量（也称为 var 关键字）已变得非常流行，因为它提高了许多场景中的可读性。默认情况下，ReSharper 还鼓励使用 var 关键字，但其使用偏好是可以灵活配置的 - 例如，您可以选择在特定情况或任何地方使用显式类型，ReSharper 将帮助您强制执行您的偏好.