Lambda变量名称 - 短名称,还是不短名称？

Question

通常,当我使用lambdas时,我只使用"a,b,c,d ......"作为变量名称,因为类型很容易推断,我发现短名称更容易阅读.这是一个例子:

var someEnumerable = GetSomeEnumerable();
var somethingElseList = someEnumerable.Select(a => a.SomeProperty)
                                      .OrderBy(a => a.SomePropertyField);
var someDictionary = somethingElseList.ToDictionary(a => new SomeClass(a.Prop1),
                                                    a => a);

有些人质疑这个命名,并且更愿意看到长输入的名称,如下所示:

var someEnumerable = GetSomeEnumerable();
var somethingElseList = someEnumerable.Select(importantObj => importantObj.SomeProperty)
                                      .OrderBy(objsInfo => objsInfo.SomePropertyField);
var someDictionary = somethingElseList.ToDictionary(theInfoId => new SomeClass(theInfoId.Prop1),
                                                    theInfoId2 => theInfoId2);

由于范围很窄(在parens之间),除非你变得愚蠢并将它们嵌套,否则我会发现阅读短名称更容易.

我没有被上面使用的愚蠢的命名示例所吸引,对Lambda变量名称的一般共识是什么？要简短的名字,还是不要简短的名字？

Answer 1

我通常这样做的方式取决于你列举的集合.如果集合的名称暗示lambda参数将是什么类型,那么我只使用单个字母,但是如果集合不是描述性的,那么我将使用一个单词.

IE:

myCollection.Where(person =>....); //non descriptive collection name

myPeopleCollection.Where(p=>...); // descriptive collection name

Answer 2

我尝试使用单字但有意义的名字.所以我倾向于使用"人"而不是"p",但不会选择"newlyAddedPerson".

这也适用于查询表达式 - 我可能会在快速丢弃的示例中违反此规则,但我通常不喜欢:

from p in source
where p.Age > 10
select p.Name;

我宁愿看到

from person in source
where person.Age > 10
select person.Name;

Answer 3

我喜欢这个简称.我一直这样做.我主要在lambdas中使用i,y,x,但我在sql中使用a,b,c,d.

Answer 4

我们的团队不允许单字母变量，也不允许 lamdas 中的事件。

我们发现，就像在 TSQL 中一样，代码存在的时间越长，它就越令人困惑。至于 lambda 的

我们会做这样的事情：

people.Where(personFound => personFound.FirstName.Contains("blah!"));

这样下一个开发者就不必看

people.Where(p => p.FirstName.Contains("blah"));

它似乎可读，但它总是一开始

加入怎么样

citizenShip.Join(people, c => c.personid, p => p.persoinid, (p, c) => new { p.FirstName, c.IsCitizen})
.Where(pc => pc.FirstName.Contains("blah");

与变量名相同

citizenShip.Join(people, 
                 citizenToJoin => citizenToJoin.personid, 
                 personToJoin => personToJoin.persoinid, 
                 (joinedPerson, joinedCitiznship) => 
                     new { joinedPerson.FirstName, joinedCitiznship.IsCitizen})
.Where(personAndCitizenshipFound=> personAndCitizenshipFound.FirstName.Contains("blah");

哦，但这令人困惑和丑陋。只需使用不同的字母，这样就不会那么混乱

citizenShip.Join(people, 
                 c => c.personid, 
                 p => p.persoinid, 
                 (jp, pc) => 
                     new { jp.FirstName, jc.IsCitizen})
.Where(pc => pc.FirstName.Contains("blah");

仍然令人困惑，但现在情况更糟。所以我们将 lambda 分解，以便我们重构以提高可读性

var peopleWithCitizenship = citizenShip.Join(people, 
                                             citizenToJoin => citizenToJoin.personid, 
                                             personToJoin => personToJoin.persoinid, 
                                             (joinedPerson, joinedCitiznship) => new { joinedPerson.FirstName, joinedCitiznship.IsCitizen});

var peopleWithCitizenshipFilteredByName = peopleWithCitizenship.Where(personAndCitizenshipFound=> personAndCitizenshipFound.FirstName.Contains("blah"));

这不是一个完美的例子，但可以让代码在很少的内幕知识下可读。我们发现这暴露了需要分解成更小的块的复杂代码（lambda）。