ReSharper为什么要对所有内容都使用'var'？

我刚刚开始在Visual Studio中使用ReSharper（在关于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开发，所以我真的很想了解正在发生的事情以及它是否有益。

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

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

要么

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

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

var obj = new SomeObject();

如果类型不明显，则应将其写出：

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

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

我宁愿选择何时使用var和不使用。但是，那只是我。

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，这可能是明智的。

综上所述，基于上述示例，我建议对Carte blanche进行应用var并不是一个好主意，因为大多数事情最好适度地进行，并且要根据此处显示的情况来完成。

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

在ReSharper（8.02，但可能是其他版本）中，可以通过首先打开ReSharper的选项菜单将“使用隐式类型的局部变量声明”建议的选项调整为您的首选项，无论采用哪种方式：

然后，在“代码检查”下，通过调整所选语言的“检查严重性”，在我的情况下为c＃：

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

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

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

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

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

'var'即将变得清晰

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

就像您在写故事一样，也没有确定的正确答案。但是，让我们用通俗易懂的英语来看一些例子。

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

谁走了另一条路？杰克还是比尔？在这种情况下，使用名称“ Jake”和“ Bill”就像使用类型名称。而“他”和“他”就像使用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通常喜欢使用对我来说更全面的关键字。但是我也倾向于用类型命名变量，这样我就不会丢失任何信息。

话虽如此，有时我会视情况而定，我会例外，这就是任何复杂事物的本质，而即使不是复杂事物，软件也不是什么。

我也不喜欢这个。

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

要记住的关键是ReSharper被配置为所需的任何编码标准。

编辑：ReSharper和var

我看到了许多正确答案，但没有完整答案。

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

我曾尝试先在其他帖子上发表评论，以添加在何处设置这些帖子，但是却没有声誉。显然，我也没有声誉发布设置的屏幕截图。

我将解释如何到达那里。

在Visual Studio>主菜单> Resharper>选项>代码编辑> C＃>代码样式>声明中的Var用法

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

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

我的规则是这样的：

• 你声明一个基本类型（即byte，char，string，int[]，double?，decimal，等）？->使用类型：

  string myStr = "foo";
  int[] myIntArray = [123, 456, 789];
  double? myDouble = 123.3;

• 你声明的复杂类型（即List<T>，Dictionary<T, T>，MyObj）？- >使用var：

  var myList = List<string>();
  var myDictionary = Dictionary<string, string>();
  var myObjInstance = new MyObj();

我只想指出，在C＃编码约定中建议使用“ var”

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

因此，这可能就是为什么在ReSharper中默认打开提示的原因。他们还提供了某些情况，在某些情况下，该情况不能立即在同一文档中提高可读性。

ReSharper建议这样做，var因为它会使对象的创建变得整洁。

比较这两个示例：

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

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

我认为用“ new”显式创建新对象时很好。但是，在您的示例中，如果未正确命名类，则可能并不明显。

顺便说一句，ReSharper在“您可能希望将此建议应用于您的代码”与“您的代码已损坏，要我解决它？”之间进行区分。该var关键字是建议类，与喜欢的东西“吊装如果减少筑巢”一起; 您不必遵循它。

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

var.Net 3.0 的功能只是类型推断，它是类型安全的，通常使您的代码更易于阅读。但是您不必这样做，并且可以根据需要将其推荐关闭。

Var太神奇了！我遇到过许多开发人员，他们var对动态类型的印象是，不是。它仍然是静态类型的，它只是由编译器决定的。

这是使用var的一些令人惊奇的积极之处

较少键入 var会更短且更易于阅读，例如

Dictionary<int,IList<string>> postcodes = new Dictionary<int,IList<string>>()Yuk。

var postcodes = new Dictionary<int,IList<string>>()\ o / \ o /

更具描述性的变量名 -狭义的变量名，但我认为让变量的可var变性在此发光很重要。由于var是有点模糊，它确实鼓励更多desciptive变量名，而不是让类自己说话。

更少的代码更改 -如果方法调用的返回类型更改。您只需要更改方法调用，而不必更改使用的每个位置。

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

但是，有时明确声明类型很有用，而我发现这在基元或结构中最有用。例如，我个人并不觉得此语法非常有用：

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

}

与

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

}

完全var取决于个人喜好，但使用确实可以加快您的开发速度并释放整个匿名类型的美好世界。

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

var x = 1;

x隐含为一个int，不能为其分配其他任何值。

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

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

该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参考

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

但是，使用'var'有其局限性。它防止了以下用法多态性是纯美容：

假设一条狗延伸了动物；猫扩展了动物类的层次结构：

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”。:-)

我认为，var仅当在定义变量的值时立即清楚类型是什么时才应使用。

例：

var s = "string value";

显然，这s是一个string。

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

例：

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，但是我可以想到一些可能有害的方案：

例如，其右侧变量值未清楚显示该类型的一次性类型。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.

'var'在您的代码中添加了一种“动态”元素（尽管代码当然仍然严格输入）。我建议不要在类型不明确的情况下使用它。考虑以下示例：

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

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

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

如果将GetTheObjectFromDatabase（）的返回类型从Type A更改为B，我们将不会注意到，因为这两个类都实现了DoSomething（）。但是，该代码现在实际上可以做一些完全不同的事情。

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

以下使用var应该总是可以的：

var abc = new Something();

对于那些不喜欢不断使用“ var”的用户，您也可以在执行“引入变量”时阻止ReSharper默认使用var。很长一段时间以来，这使我感到沮丧，它始终默认为var，并且每次都在更改它。

这些设置位于“代码编辑”>“ C＃”>“代码样式”下

没有技术差异（如eWolf所指出的）。您可以使用其中一个，生成的CLR代码将看起来相同。

我认为主要的好处是，这倾向于迫使您使用更好的变量命名。在您的示例中，对于变量名，'foo'是一个非常差的选择。

据JetBrains（ReSharper的作者）称，它们默认情况下鼓励使用var。

从他们的网站：

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