c# - Foreach 扩展的更优雅的 LINQ 替代方案

Question

这纯粹是为了提高我的技能。我的解决方案适用于主要任务，但并不“整洁”。我目前正在使用 Entity 框架项目开发 .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
}

在我的一个 View 模型中，我被要求提供一个下拉列表，用于在创建新用户时选择服务器。下拉列表填充有文本和值 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)" 
  };

现在我们的属性(property)主体是:

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

已经好多了。

如果您只是要传递 lambda 主体，请不要使用 ForEach 作为方法!语言中已经有一个内置机制可以做得更好!没有理由写 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)" 
  };

现在我们的 Prop 主体是

    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
• 当您意识到需要改进时，重新审视之前的决定
• 识别何时重新实现简单的辅助方法
• 不要停留在一个改进上!每项改进都可以使另一项改进成为可能。

---

What if I want to sort this dropdown list by user count?

然后按用户数排序!我们将其抽象为辅助方法，因此我们可以使用它:

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 中，您可以使用元组代替匿名类型，但想法是一样的。)