C# 按属性对列表的对象进行分组

Question

我对 C# 很陌生，不善于解释，希望给定的输入和输出数据会有所帮助。

我有一个 JSON 文件，其中包含成对的字符串，这些字符串是用于识别某些内容的键。 每个密钥可以是多对的一部分。 我将 JSON 数据读入对象列表（称为TopComparison ）。 对于任何特定的键，我需要扫描列表并找到所有匹配项。 它可以匹配一对中的两个键中的任何一个。

我开始创建一个对象来存储一对：

class TopComparison
        {
            public string first_submission { get; set; }
            public string second_submission { get; set; }
        }

我有一个 JSON 文件中所有元素的List<TopComparison> topComparisons = new List<TopComparison>();

一个示例数据集可能是：

[
                {
                    "first_submission ": "Tom",
                    "second_submission ": "EJ",
                },
                {
                    "first_submission ": "Ben",
                    "second_submission ": "Tom"
                },
                {
                    "first_submission ": "Manny",
                    "second_submission ": "harry"
                },
                {
                    "first_submission ": "Manz",
                    "second_submission ": "John"
                },
                {
                    "first_submission ": "Rocky",
                    "second_submission ": "Manz"
                }
            ]

并且我想根据 id 的出现对对象进行分组，无论它是在first_submission还是second_submission中，这意味着如果出现在first_submission或second_submission中的任何键都必须在整个列表中检查是否重复出现，如果它们出现在first_submission或second_submission中，它们必须是添加到列表中。

所以在原始数据集中“Tom”与“EJ”和“Ben”配对，“Manz”与“Rocky”和“John”配对，但“Manny”只与“Harry”配对。 任何键都可以有无限数量的匹配（不仅仅是两个）！ 我想生成这些配对的列表，如下所示：

List<List<TopComparison>> topComparison_list = new List<List<TopComparison>>();

[
        [
            {
                "first_submission ": "Tom",
                "second_submission ": "EJ"
            },
            {
                "first_submission ": "Ben",
                "second_submission ": "Tom"
            }
        ],
        [
            {
                "first_submission ": "Manny",
                "second_submission ": "Harry"
            }
        ],
        [
            {
                "first_submission ": "Manz",
                "second_submission ": "John"
            },
            {
                "first_submission ": "Rocky",
                "second_submission ": "Manz"
            }
        ]
    ]

Answer 1

我为您提出了一个等于您的目标输出的解决方案。 我还没有编写尽可能短的代码，所以更容易理解。 我也没有重构代码以使用来自其他函数调用的函数调用。 这是一个有趣的脑筋急转弯，但它旨在成为您通往更好框架用例场景的学习垫脚石。 根据您的输出，我还假设没有任何重复值（即，同一项目不能在两个不同的列表中，这适合您的场景）

我喜欢使用测试项目，而不是制作控制台应用程序。 这些很棒，因为您可以创建许多“测试”函数，然后只需在要运行的方法的第一行代码上设置一个断点 > 右键单击​​方法签名 > 选择调试测试。 然后它将执行该测试，您可以遍历它并观察变量（F10 Hotkey to step）。 Visual Studio 2020 社区版现在免费提供，如果你还没有的话。

实施我的解决方案：（.NET 6.0，Nullable=enabled）

1. 创建一个新的解决方案 > 添加一个 NUnit 测试项目 > 将项目命名为“分组”> 目标 .NET 6.0（长期支持）> 选择创建（如果需要，请安装 .NET 6.0，或者如果您愿意，请尝试早期版本）
2. 删除生成的类文件。 创建一个名为“GroupingTests.cs”的新类文件
3. 将所有这些代码复制粘贴到命名空间内。

using Newtonsoft.Json;
using NUnit.Framework;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace Grouping
{
    public class TopComparison
    {
        public string? FirstSubmission { get; set; }
        public string? SecondSubmission { get; set; }
    }

    public class GroupingTests
    {
        [Test]
        public void GroupEqualProperties()
        {
            List<TopComparison> topComparisons = new List<TopComparison>();
            var comparisonOne = new TopComparison()
            {
                FirstSubmission = "Tom",
                SecondSubmission = "EJ"
            };
            var comparisonTwo = new TopComparison() { FirstSubmission = "Ben", SecondSubmission = "Tom" };
            var comparisonThree = new TopComparison() { FirstSubmission = "Manny", SecondSubmission = "harry" };
            var comparisonFour = new TopComparison() { FirstSubmission = "Manz", SecondSubmission = "John" };
            var comparisonFive = new TopComparison() { FirstSubmission = "Rocky", SecondSubmission = "Manz" };
            topComparisons.Add(comparisonOne);
            topComparisons.Add(comparisonTwo);
            topComparisons.Add(comparisonThree);
            topComparisons.Add(comparisonFour);
            topComparisons.Add(comparisonFive);

            var topComparisonList = new List<List<TopComparison>>();

            for (int i = 0; i < topComparisons.Count - 1; i++)
            {
                TopComparison comparison = topComparisons[i];

                bool continueOuterFor = false;
                foreach (var resultList in topComparisonList)
                {
                    foreach (var result in resultList)
                    {
                        if (comparison.Equals(result))
                        {
                            continueOuterFor = true;
                            continue;
                        }
                    }

                    if (continueOuterFor) { continue; }
                }

                if (continueOuterFor) { continue; }

                bool foundMatch = false;

                for (int j = i + 1; j < topComparisons.Count; j++)
                {
                    TopComparison innerComparison = topComparisons[j];


                    if (comparison.FirstSubmission == innerComparison.FirstSubmission
                        || comparison.FirstSubmission == innerComparison.SecondSubmission
                        || comparison.SecondSubmission == innerComparison.FirstSubmission
                        || comparison.SecondSubmission == innerComparison.SecondSubmission)
                    {
                        foundMatch = true;
                        var topComparisonGroup = new List<TopComparison>() { comparison, innerComparison };

                        if (!topComparisonList.Contains(topComparisonGroup))
                        {
                            topComparisonList.Add(topComparisonGroup);
                        }
                        break;
                    }
                }

                if (!foundMatch)
                {
                    topComparisonList.Add(new List<TopComparison>() { comparison });
                }
            }

            var asJson = JsonConvert.SerializeObject(topComparisonList, Formatting.Indented);
        }
    }
}

4. 点击 CTRL K + D 自动格式化页面。
5. 如果任何红色波浪线向您尖叫 > 选择一个，请点击“CTRL+”。 > 通常采用最佳建议修复，例如它会为您拉入 nuget 包或参考。
6. 如上所述在方法上运行调试器。
7. 脚本底部的局部变量“asJson”将保存您的输出

您可以从调试 Autos 窗口或 Locals 窗口中获取它的值，或者双击它并 > 快速观看（以获得全面的窗口视图）

如果您遇到任何后续问题，请告诉我，祝您编码愉快！

PS有吗？ 在 TopComparison 类的字符串属性之后，因为在我的解决方案中启用了 Nullable，这对 C# 来说是新的。 PSS 我更改了大小写以匹配 C# 标准。 如果你想要你的 lower_snake_case 只需将属性更改回匹配。

我的调试器输出是：

[
  [
    {
      "FirstSubmission": "Tom",
      "SecondSubmission": "EJ"
    },
    {
      "FirstSubmission": "Ben",
      "SecondSubmission": "Tom"
    }
  ],
  [
    {
      "FirstSubmission": "Manny",
      "SecondSubmission": "harry"
    }
  ],
  [
    {
      "FirstSubmission": "Manz",
      "SecondSubmission": "John"
    },
    {
      "FirstSubmission": "Rocky",
      "SecondSubmission": "Manz"
    }
  ]
]