如何对具有相同子对象列表的对象进行分组？

Question

我正在尝试对对象列表进行分组，这些对象具有一个列表属性。使用以下表达式时，它不会将具有列表的对象分组在一起，大概是因为当它检查每个列表的相等性时，它不匹配 - 即使内容相同。

我知道这是问题所在，就好像我停止对列表进行分组一样，代码输出两项而不是三项。

如何调整我的表达方式，以便正确地将前两项（相同的）归为一组？

public class Item {
  public string Id { get; set; }
  public string Name { get; set; }
  public IEnumerable<ChildItem> Children { get; set; }
}

public class ChildItem {
  public string ChildItemName { get; set; }
}

var items = new List<Item> {
  new Item {
    Id = "00001",
    Name = "My Item",
    Children = new List<ChildItem> {
      new ChildItem { ChildItemName = "string 1" },
      new ChildItem { ChildItemName = "string 2" },
    }
  },
  new Item {
    Id = "00001",
    Name = "My Item",
    Children = new List<ChildItem> {
      new ChildItem { ChildItemName = "string 1" },
      new ChildItem { ChildItemName = "string 2" },
    }
  },
  new Item {
    Id = "00002",
    Name = "My Second Item",
    Children = new List<ChildItem> {
      new ChildItem { ChildItemName = "string 3" },
    }
  }
};

var result =
  from c in items
  group c by new
  {
    c.Id,
    c.Name,
    c.Children,
  }
  into gcs
  select new Item()
  {
    Id = gcs.Key.Id,
    Name = gcs.Key.Name,
    Children = gcs.Key.Children
  };

Answer 1

如果具有相同Id的项目具有相同的名称和集合，您可以按Id分组，然后取出组的第一项

IEnumerable<Item> uniqueItems = items
    .GroupBy(x => x.Id)
    .Select(g => g.First());

您不需要将所有内容都放入组密钥中。

---

由于根据您的评论，Id 不保证唯一性，因此您必须提供自己对“相等”含义的定义。您可以通过实现自己的相等比较器来做到这一点。

ChildItem 作为单例的实现，因为它将在 ItemEqualityComparer.Equals 中重复使用。

class ChildItemEqualityComparer : IEqualityComparer<ChildItem>
{
    public static readonly ChildItemEqualityComparer Instance =
        new ChildItemEqualityComparer(); // Create singleton.
    private ChildItemEqualityComparer() { } // Hide constructor.

    public bool Equals(ChildItem x, ChildItem y) =>
        String.Equals(x.ChildItemName, y.ChildItemName);
    public int GetHashCode(ChildItem childItem) =>
        childItem.ChildItemName?.GetHashCode() ?? 0;
}

Item 的实现：

class ItemEqualityComparer : IEqualityComparer<Item>
{
    public bool Equals(Item x, Item y)
    {
        return x.Id == y.Id && x.Name == y.Name &&
            Enumerable.SequenceEqual(x.Children, y.Children,
                ChildItemEqualityComparer.Instance);
    }

    public int GetHashCode(Item item)
    {
        int hash = 43;
        unchecked {
            hash = 17 * hash + (item.Id?.GetHashCode() ?? 0);
            hash = 17 * hash + (item.Name?.GetHashCode() ?? 0);
            foreach (ChildItem childItem in item.Children) {
                hash = 17 * hash + ChildItemEqualityComparer.Instance.GetHashCode(childItem);
            }
        }
        return hash;
    }
}

还有查询：

var result = items.Distinct(new ItemEqualityComparer());

这会产生 2 个项目。

Answer 2

1. 如果您必须使用 ChildItem 类（而不是简单的字符串），您 可以考虑为 ChildItem 实现 IEqualityComparer。这使得使用 (System.Linq) SequenceEqual 方法。

ProductA[] storeA = { new ProductA { Name = "apple", Code = 9 }, 
                       new ProductA { Name = "orange", Code = 4 } };

ProductA[] storeB = { new ProductA { Name = "apple", Code = 9 }, 
                       new ProductA { Name = "orange", Code = 4 } };

bool equalAB = storeA.SequenceEqual(storeB);

1. 那你可以考虑在Item类中实现IEquatable接口。

IEquatable 接口定义了 Equals 方法，该方法 确定实现类型实例的相等性

在 Equals 方法中，您可以使用 SequenceEqual 来检查上面描述的子项是否相等。

3.最后，您可以使用 (System.Linq) Distinct() 方法获取项目的唯一对象。

IEnumerable<Item> noduplicates = items.Distinct();

请查看：

• https://docs.microsoft.com/en-gb/dotnet/api/system.collections.generic.iequalitycomparer-1?view=netframework-4.8

  https://docs.microsoft.com/en-us/dotnet/api/system.linq.enumerable.sequenceequal?view=netframework-4.8

  https://docs.microsoft.com/en-gb/dotnet/api/system.iequatable-1?view=netframework-4.8

  https://docs.microsoft.com/en-gb/dotnet/api/system.linq.enumerable.distinct?view=netframework-4.8

Answer 3

如果您只是想消除重复项，您可以将集合转换为 HashSet 并返回。

items.ToHashSet().ToList();

不过，您需要覆盖GetHashCode 的默认实现，以确保它是使用Item 的字段计算的。

Answer 4

你可以这样写GroupBy表达式

items.GroupBy(x => x.Id);