为什么ReSharper希望对所有内容都使用“var”?

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

或

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

var obj = new SomeObject();

如果类型不明显,则应写出:

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

我个人更倾向于关闭这个建议。使用 var 经常可以提高可读性;但是正如您所提到的,它有时会减少它(使用简单类型,或者当生成的类型是 ).

变量 当我没有的时候。但同样,那只是我。

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

变量

例如,不好的命名可能会导致 导致代码理解能力下降。这不是 变量 不过,这是他的错:

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

有时使用它是没有意义的 对于简单的数据类型,如果代码在没有代码的情况下可读性更强:

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

变量 隐藏数据类型信息时非常有用,您不必关心这些信息的复杂性:

    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 o = new { Num=3, Name="" };

变量 ,然后您需要在没有帮助的情况下通过严格的代码阅读来减少对理解的依赖。假设不是每个人都拥有或使用智能感知可能是明智的。

我建议全权申请 变量 这不是一个好主意,因为大多数事情都是在适度的情况下完成的,并且是基于眼前的情况,如图所示。

为什么Resharper在默认情况下会使用它?为了方便起见,我建议您使用它,因为它无法解析各种情况的细微差别,从而决定何时最好不使用它。

偏爱

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

“var”是关于清晰的

关于是否使用 var 关键字与否关系到代码对您和其他开发人员的可读性。

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

谁走了另一条路?杰克还是比尔?在本例中,使用名称“Jake”和“Bill”就像使用类型名称一样。“他”和“他”就像使用 变量 关键词。在这种情况下,更具体一些可能会有所帮助。下面的例子更清楚。

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

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

在这种情况下,如果我们使用“他”,并且在某些情况下将他的名字全部省略,这相当于使用 变量 关键词。

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

这些例子涵盖了要点,但并不能说明全部情况。在这些例子中,只有一种方式可以指代此人。要么用他们的名字,要么用“他”和“他”这样更一般的词。

对于代码,我们有3种方法来帮助增加清晰度。类型、变量名和赋值。以这行代码为例:

Person p = GetPerson();

现在的问题是,这行代码中是否有足够的信息来帮助您了解发生了什么?

p 在这种情况下是指:

var p = GetPerson();

现在呢:

var p = Get();

var person = Get();

或者这个:

var t = GetPerson();

var u = Person.Get();

关键词是否正确 变量 在给定场景中的工作在很大程度上取决于代码的上下文,例如变量、类和方法的命名方式。它还取决于代码的复杂性以及围绕它的其他代码。

就我个人而言,我喜欢使用 更全面 大多数时候。但是我也倾向于以类型命名变量,这样我就不会丢失任何信息。

也就是说,有时根据上下文,我会做出例外,这是任何复杂事物的本质,而软件如果不复杂就什么都不是。

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

AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments );

是一个 重复形式 AVeryLongTypeName 对于它的一个派生类,在使用 var 并且仍然可以访问子类的方法。

除此之外,可读性的提高是一个重要的方面,但是正如其他人所说的,var不应该被过度使用,所以我认为在Resharper中关闭提示是完全可以的。

我也不喜欢这个。

我不想让这变成一场关于使用 var

需要记住的关键是,ReSharper配置为您想要的任何编码标准。

编辑: ReSharper and var

的确,ReSharper过度使用了 var 默认情况下。我想大多数人都会同意这一点。它也更容易阅读时 变量 并且类型很明显,例如当您使用 new 变量

我曾试图先对其他帖子发表评论,以添加这些帖子的设置位置,但没有这样的名声。显然,我也没有名声发布我的设置截图。

我将解释如何到达那里。

在Visual Studio中>主菜单>再竖琴>选项>代码编辑>C#>代码样式>声明中的Var用法

• 对于简单类型,在明显时使用“var”
• 其他地方使用“var”

ReSharper帮助文档: Code Syntax Style: Implicit/Explicit Typing ('var' Keyword) — Configure preferences of using 'var' keyword

我的规则是:

• 您是否声明了一个基元类型(即。 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# Coding Conventions

ReSharper建议 var

StringBuilder bld = new StringBuilder();

var bld = new StringBuilder();

这只是一个速记,应该更容易阅读。

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

var 关键字在建议类别中,以及“反转以减少嵌套”之类的内容;你不必遵循它。

您可以通过“选项”对话框或直接通过该警报的弹出菜单配置每个警报的恼人程度。你可以降级,比如 变量 建议,使其不那么突出,或者您可以升级“使用扩展方法”警报,使其显示为实际错误。

var NET3.0的功能只是 type inference

Var太棒了!我遇到过很多开发者,他们的印象是 var 绑定到动态类型,而不是。它仍然是静态类型,只是由编译器决定。

下面是使用var的一些令人惊讶的优点

少打字

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

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

-纤细的一个,但我认为重要的是让它的流动性 变量 在这里发光。作为 变量 有点模糊,它确实鼓励使用更具描述性的变量名,而不是让类型自己说话。

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

匿名类型 partial resources . 如果没有var,就不能使用它们。

然而,有时明确地声明类型很有用,我发现这在原语或结构中最有用。例如,我个人并不认为这种语法非常有用:

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

}

vs

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

}

这完全取决于个人喜好,但使用 变量

在我看来,, 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>>>();

变量 ,但我可以想到一些可能有害的情况:

例子:

// 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 x = 1;

x暗示为int,不能为其指定其他值。

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 reference

指定显式对象类型在某种程度上是多余的。即使翻译成英语,它听起来也是多余的:“将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 bar = GetTheObjectFromDatabase();
bar.DoSomething();

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

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

如果GetTheObjectFromDatabase()的返回类型从类型A更改为B,我们将不会注意到,因为这两个类都实现DoSomething()。然而,代码现在实际上可能会做一些完全不同的事情。

这可能和在日志中写入不同的内容一样微妙,所以你可能不会注意到unitl,现在已经太晚了。

以下var的使用应始终正确:

var abc = new Something();

这些设置正在进行代码编辑>C#>代码样式

没有技术上的区别(正如伊渥尔人所指出的)。您可以使用其中一个,生成的CLR代码看起来是一样的。

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

根据JetBrains(ReSharper的作者)的说法,他们鼓励默认情况下使用var。

their website :

使用隐式类型的局部变量(也称为 var 在C#3.0中引入的关键字)已经变得非常流行,因为它在许多场景中提高了可读性。默认情况下,ReSharper还鼓励使用 变量