Foreach 扩展的更优雅的 LINQ 替代方法

Question

这纯粹是为了提高我的技能。我的解决方案适用于主要任务，但它并不"整洁"。我目前正在开发带有实体框架项目的 .NET MVC。我只知道多年来已经足够的基本单数 LINQ 函数。现在我想学习如何花哨。

所以我有两个模型

public class Server
{
[Key]
public int Id { get; set; }
public string InstanceCode { get; set; }
public string ServerName { get; set; }
}
public class Users
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public int ServerId { get; set; } //foreign key relationship
}

在我的一个视图模型中，我被要求提供一个下拉列表，用于在创建新用户时选择服务器。用文本和值 Id 填充的下拉列表作为 IEnumerable 这是我的服务器下拉列表的原始属性

public IEnumerable<SelectListItem> ServerItems
{
get { Servers.ToList().Select(s => new selectListItem { Value = x.Id.ToString(), Text = $"{s.InstanceCode}@{s.ServerName}" }); }
}

更新需求，现在我需要显示与每个服务器选择相关的用户数量。好的，没问题。这是我在头顶上写下的内容。

public IEnumerable<SelectListItem> ServerItems
{
get 
{
var items = new List<SelectListItem>();
Servers.ToList().ForEach(x => {
var count = Users.ToList().Where(t => t.ServerId == x.Id).Count();
items.Add(new SelectListItem { Value = x.Id.ToString(), Text = $"{x.InstanceCode}@{x.ServerName} ({count} users on)" });
});
return items;
}
}

这得到了我的结果，让我们说"localhost@rvrmt1u(8 个用户)"，但仅此而已。 如果我想按用户计数对此下拉列表进行排序怎么办。我所做的只是字符串中的另一个变量。

TLDR ...我敢肯定，某个地方的某个人可以教我一两件事，如何将其转换为 LINQ 查询并使其看起来更好。还有加分项，因为我知道如何对列表进行排序以首先显示用户最多的服务器。

Answer 1

好吧，我们有这个混乱：

var items = new List<SelectListItem>();
Servers.ToList().ForEach(x => {
var count = Users.ToList().Where(t => t.ServerId == x.Id).Count();
items.Add(new SelectListItem { Value = x.Id.ToString(), Text = $"{x.InstanceCode}@{x.ServerName} ({count} users on)" });
});
return items;

进行一系列小的、仔细的、明显正确的重构，逐步改进代码。

首先：让我们将这些复杂的操作抽象为它们自己的方法。

请注意，我已将无用的x替换为有用的server。

int UserCount(Server server) => 
Users.ToList().Where(t => t.ServerId == server.Id).Count();

到底为什么Users上有ToList？这看起来不对劲。

int UserCount(Server server) => 
Users.Where(t => t.ServerId == server.Id).Count();

我们注意到有一个内置方法可以同时执行这两个操作：

int UserCount(Server server) => 
Users.Count(t => t.ServerId == server.Id);

同样，对于创建项目：

SelectListItem CreateItem(Server server, int count) => 
new SelectListItem 
{ 
Value = server.Id.ToString(), 
Text = $"{server.InstanceCode}@{server.ServerName} ({count} users on)" 
};

现在我们的财产主体是：

var items = new List<SelectListItem>();
Servers.ToList().ForEach(server => 
{
var count = UserCount(server);
items.Add(CreateItem(server, count);
});
return items;

已经好多了。

永远不要使用ForEach作为方法，如果你只是要传递一个 lambda 体！语言中已经有一个内置的机制可以做得更好！ 当您可以简单地写items.Foreach(item => {...});foreach(var item in items) { ... }时，没有理由写. 它更简单、更易于理解和调试，编译器可以更好地优化它。

var items = new List<SelectListItem>();
foreach (var server in Servers.ToList())
{
var count = UserCount(server);
items.Add(CreateItem(server, count);
}
return items;

好多了。

为什么Servers上有ToList？完全没有必要！

var items = new List<SelectListItem>();
foreach(var server in Servers)
{
var count = UserCount(server);
items.Add(CreateItem(server, count);
}
return items;

越来越好。我们可以消除不必要的变量。

var items = new List<SelectListItem>();
foreach(var server in Servers)
items.Add(CreateItem(server, UserCount(server));
return items;

嗯。 这让我们了解CreateItem可以自己进行计数。让我们重写它。

SelectListItem CreateItem(Server server) => 
new SelectListItem 
{ 
Value = server.Id.ToString(), 
Text = $"{server.InstanceCode}@{server.ServerName} ({UserCount(server)} users on)" 
};

现在我们的道具体是

var items = new List<SelectListItem>();
foreach(var server in Servers)
items.Add(CreateItem(server);
return items;

这应该看起来很熟悉。我们重新发明了Select，ToList：

var items = Servers.Select(server => CreateItem(server)).ToList();

现在我们注意到 lambda 可以替换为方法组：

var items = Servers.Select(CreateItem).ToList();

我们已经把整个混乱减少到一行，清晰而明确地看起来像它所做的。它有什么作用？它为每个服务器创建一个项目，并将它们放在一个列表中。代码应该读起来像它做什么，而不是它是如何做的。

仔细研究我在这里使用的技术。

• 将复杂代码提取到帮助程序方法
• 将ForEach替换为实际循环
• 消除不必要的ToList
• 当您意识到需要改进时，请重新审视以前的决定
• 在重新实现简单帮助程序方法时识别
• 不要止步于一项改进！ 每一项改进都可以做另一项改进。

---

如果我想按用户计数对此下拉列表进行排序，该怎么办？

然后按用户计数排序！我们将其抽象为一个帮助程序方法，因此我们可以使用它：

var items = Servers
.OrderBy(UserCount)
.Select(CreateItem)
.ToList();

我们现在注意到我们给UserCount打电话两次。 我们在乎吗？或。称它两次可能是性能问题，或者，可怕的是，它可能不是幂等的！如果任何一个是问题，那么我们需要撤消我们之前做出的决定。 在理解模式下处理这种情况比在流畅模式下更容易，所以让我们重写为理解：

var query = from server in Servers
orderby UserCount(server)
select CreateItem(server);
var items = query.ToList();

现在我们回到前面：

SelectListItem CreateItem(Server server, int count) => ...

现在我们可以说

var query = from server in Servers
let count = UserCount(server)
orderby count
select CreateItem(server, count);
var items = query.ToList();

我们只为每个服务器调用UserCount一次。

为什么要回到理解模式？因为在流畅模式下执行此操作会弄得一团糟：

var query = Servers
.Select(server => new { server, count = UserCount(server) })
.OrderBy(pair => pair.count)
.Select(pair => CreateItem(pair.server, pair.count))
.ToList();

而且看起来有点丑。 (在 C# 7 中，您可以使用元组而不是匿名类型，但思路是相同的。

Answer 2

LINQ 的诀窍只是键入return并从那里开始。不要创建列表并向其中添加项目;通常有一种方法可以一次性选择所有内容。

public IEnumerable<SelectListItem> ServerItems
{
get 
{
return Servers.Select
(
server => 
new 
{
Server = server,
UserCount = Users.Count( u => u.ServerId = server.Id )
}
)
.Select
(
item =>
new SelectListItem
{
Value = item.Server.Id.ToString(),
Text = string.Format
(
@"{0}{1} ({2} users on)" ,
item.Server.InstanceCode,
item.Server.ServerName, 
item.UserCount
)
}
);
}
}

在此示例中，实际上有两个Select语句 - 一个用于提取数据，另一个用于执行格式设置。在理想情况下，这两个任务的逻辑将分成不同的层，但这是一个可以的折衷方案。