在c#中根据子数组过滤数组中的重复项

Question

我有一个包含基本代码和位置数组的人员列表。我需要消除列表中具有相同位置的不同基码的人员，并保留具有不同位置的人员。

我尝试使用 IEqualityComparer，并在 linq 中分组，但我没有成功。 你们能告诉我怎么做吗？ 这是我的班级结构

public class Person
{
    public string Name { get; set; }

    public List<Location> Locations { get; set; }
}
public class Location
{
    public string Name { get; set; }
    public string BaseCode { get; set; }
}

数据示例

Person 1
Name : John

Locations :
      [0]  Name : India , BaseCode : "AA12"
      [1] Name : USA ,BaseCode : "AA14"
Person 2
Name : John

Locations :
      [0]  Name : India, BaseCode : "AA13"
      [1] Name : USA ,BaseCode : "AA14"
Person 3
Name : John

Locations :
      [0]  Name : India, BaseCode : "AA16"
      [1] Name : UK , BaseCode : "AA17"

我想从我的列表中过滤掉第 2 个人，保留第 1 个人和第 3 个人。请指教

Answer 1

_{免责声明：此解决方案不专门处理具有不同/相同位置的相同BaseCode；你没有在你的要求中提到这个。}

---

IEqualityComparer<T>路线

这里重要的部分是Person 和Location 的IEqualityComparer<T> 实现：

class Program
{
    static void Main(string[] args)
    {
        var p1 = new Person {Name ="John", BaseCode="AA12", Locations = new List<Location>
        {
            new Location { Name = "India" },
            new Location { Name = "USA" }
        }};

        var p2 = new Person {Name ="John", BaseCode="AA13", Locations = new List<Location>
        {
            new Location { Name = "India" },
            new Location { Name = "USA" }
        }};

        var p3 = new Person {Name ="John", BaseCode="AA14", Locations = new List<Location>
        {
            new Location { Name = "India" },
            new Location { Name = "UK" }
        }};

        var persons = new List<Person> { p1, p2, p3 };

        // Will not return p2.
        var distinctPersons = persons.Distinct(new PersonComparer()).ToList();

        Console.ReadLine();
    }
}

public class PersonComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        if (x == null || y == null)
            return false;

        bool samePerson = x.Name == y.Name;

        bool sameLocations = !x.Locations
            .Except(y.Locations, new LocationComparer())
            .Any();

        return samePerson && sameLocations;
    }

    public int GetHashCode(Person obj)
    {
        return obj.Name.GetHashCode();
    }
}

public class LocationComparer : IEqualityComparer<Location>
{
    public bool Equals(Location x, Location y)
    {
        if (x == null || y == null)
            return false;

        return x.Name == y.Name;
    }

    public int GetHashCode(Location obj)
    {
        return obj.Name.GetHashCode();
    }
}

PersonComparer 使用提供 LocationComparer 的 linq Except 扩展来生成两个位置列表之间的差异列表。

PersonComparer 然后输入 linq Distinct 方法。

---

IEquatable<T>路线

_{如果您需要与 BaseCode 一起工作，不同算作“匹配”，我认为这条路线行不通，因为 GetHashCode 没有给你一个区分价值的机会。}

另一种解决方案是在类本身上实现 IEquatable<T> 并覆盖 GetHashCode、Distinct 和 Except 将遵循此实现：

public class Person : IEquatable<Person>
{
    public string Name { get; set; }
    public string BaseCode { get; set; }
    public List<Location> Locations { get; set; }

    public bool Equals(Person other)
    {
        if (other == null)
            return false;

        bool samePerson = Name == other.Name;

        // This is simpler because of IEquatable<Location>
        bool sameLocations = !Locations.Except(other.Locations).Any();

        return samePerson && sameLocations;
    }

    public override int GetHashCode()
    {
        return Name.GetHashCode();
    }
}

public class Location : IEquatable<Location>
{
    public string Name { get; set; }

    public bool Equals(Location other)
    {
        if (other == null)
            return false;

        return Name == other.Name;
    }

    public override int GetHashCode()
    {
        return Name.GetHashCode();
    }
}

这导致更简单的调用：

var distinctPersons = persons.Distinct().ToList();

Answer 2

我很想写如下内容。我没有检查过y.Locations.Equals() 是否有效，但应该很容易将其替换为具有相同功能的东西。

    List<Person> personList = new List<Person>();
    List<Person> deduplicatedPersonList = new List<Person>();
    personList.ForEach(x =>
    {
        Person existingPerson = personList.Find(y =>
        {
            if (y.Locations.Equals(x.Locations))
                return false;
            return true;
        });
        if (existingPerson == null)
            deduplicatedPersonList.Add(x);
    });

Answer 3

您可以使用 IEquatable 接口，并像这样覆盖 Equal 和 GetHashCode 方法：

问题更改后编辑：

public class Location : IEquatable<Location>
{    
       public string Name { get; set; }     
       public string BaseCode { get; set; 

        public bool Equals(Location other)
        {
            if (Object.ReferenceEquals(other, null)) return false;

            if (Object.ReferenceEquals(this, other)) return true;
            return BaseCode.Equals(other.BaseCode);
        }

        public override int GetHashCode()
        {
            return BaseCode.GetHashCode();
        }


} 

所以，现在你可以在 Person 列表中使用 Distinct，它只会返回 distinct name 和 BaseCode。

 var distinctListPerson = PersonList.Distinct().ToList();

您可以从MSDN阅读有关此接口的信息

Answer 4

Adam 的解决方案是更“正确”的处理方式。但是如果你想用 LINQ 来做，那么像这样的东西也应该做（请注意，代码需要对位置进行排序并将字符串作为标识符）：

persons
    .GroupBy(x => x.Name)
    .SelectMany(x => x)
        .GroupBy(y => string.Concat(y.Locations.Select(z => z.Name)))
    .SelectMany(x => x
        .GroupBy(y => string.Concat(y.Locations.Select(z => z.BaseCode)))
    .Select(x => x.First());