C#集合根据对象的某个属性进行去重

当根据对象的Name属性进行去重时，你可以使用以下三种方法：使用Distinct方法和自定义比较器、使用LINQ的GroupBy方法，以及使用HashSet。下面是每种方法的详细代码示例和解释：

1. 使用Distinct方法和自定义比较器：

using System;
using System.Collections.Generic;
using System.Linq;

// 自定义对象类
public class Person
{
    public string Name { get; set; }
}

// 自定义比较器类
public class NameEqualityComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.Name == y.Name;
    }

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

public class Program
{
    public static void Main()
    {
        // 创建包含重复对象的集合
        List<Person> people = new List<Person>()
        {
            new Person { Name = "John" },
            new Person { Name = "Jane" },
            new Person { Name = "John" },
            new Person { Name = "Alice" },
            new Person { Name = "Jane" }
        };

        // 使用Distinct方法和自定义比较器进行去重
        List<Person> distinctPeople = people.Distinct(new NameEqualityComparer()).ToList();

        // 输出去重后的结果
        foreach (Person person in distinctPeople)
        {
            Console.WriteLine(person.Name);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

解释：

• 在上述代码中，我们首先定义了一个Person类，具有Name属性作为去重的依据。
• 然后，我们创建了一个包含重复对象的List<Person>集合。
• 接下来，我们定义了一个名为NameEqualityComparer的自定义比较器类，实现了IEqualityComparer<Person>接口。
• 在自定义比较器类中，我们重写了Equals方法和GetHashCode方法，分别根据Person对象的Name属性进行比较和哈希计算。
• 在主程序中，我们使用Distinct方法，并将自定义比较器作为参数传递给该方法，以实现根据Name属性进行去重的功能。
• 最后，我们将去重后的结果转换为List<Person>类型，并逐个输出去重后的Person对象的Name属性。

2. 使用LINQ的GroupBy方法：

using System;
using System.Collections.Generic;
using System.Linq;

// 自定义对象类
public class Person
{
    public string Name { get; set; }
}

public class Program
{
    public static void Main()
    {
        // 创建包含重复对象的集合
        List<Person> people = new List<Person>()
        {
            new Person { Name = "John" },
            new Person { Name = "Jane" },
            new Person { Name = "John" },
            new Person { Name = "Alice" },
            new Person { Name = "Jane" }
        };

        // 使用GroupBy方法根据Name属性进行分组，并选择每个分组的第一个对象
        List<Person> distinctPeople = people.GroupBy(p => p.Name).Select(g => g.First()).ToList();

        // 输出去重后的结果
        foreach (Person person in distinctPeople)
        {
            Console.WriteLine(person.Name);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

解释：

• 在上述代码中，我们定义了一个Person类，具有Name属性作为去重的依据。
• 然后，我们创建了一个包含重复对象的List<Person>集合。
• 接下来，我们使用GroupBy方法根据Name属性进行分组。这将返回一个IEnumerable<IGrouping<string, Person>>，其中每个分组具有一个键（Name属性的值）和相应的对象集合。
• 然后，我们使用Select方法选择每个分组的第一个对象，以实现去重的效果。
• 最后，我们将去重后的结果转换为List<Person>类型，并逐个输出去重后的Person对象的Name属性。

3. 使用HashSet：

using System;
using System.Collections.Generic;

// 自定义对象类
public class Person
{
    public string Name { get; set; }
}

public class Program
{
    public static void Main()
    {
        // 创建包含重在C#中，你可以使用以下几种方法根据对象的Name属性对集合进行去重：

1. 使用Distinct方法和自定义比较器：
```csharp
using System;
using System.Collections.Generic;
using System.Linq;

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

public class NameEqualityComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.Name == y.Name;
    }

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

public class Program
{
    public static void Main()
    {
        List<Person> people = new List<Person>()
        {
            new Person { Name = "John" },
            new Person { Name = "Jane" },
            new Person { Name = "John" },
            new Person { Name = "Alice" },
            new Person { Name = "Jane" }
        };

        List<Person> distinctPeople = people.Distinct(new NameEqualityComparer()).ToList();

        foreach (Person person in distinctPeople)
        {
            Console.WriteLine(person.Name);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

在上面的代码中，我们定义了一个Person类，其中包含一个Name属性用于去重。然后，我们创建了一个包含重复对象的List集合。接下来，我们定义了一个NameEqualityComparer类，实现了IEqualityComparer接口，其中Equals方法用于比较Name属性是否相等，GetHashCode方法用于获取Name属性的哈希码。在主程序中，我们使用Distinct方法，并将自定义的比较器作为参数传递给Distinct方法，以实现根据Name属性进行去重的功能。最后，我们将去重后的结果转换为List类型，并遍历输出每个人物的Name属性。

2. 使用LINQ的GroupBy方法：

using System;
using System.Collections.Generic;
using System.Linq;

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

public class Program
{
    public static void Main()
    {
        List<Person> people = new List<Person>()
        {
            new Person { Name = "John" },
            new Person { Name = "Jane" },
            new Person { Name = "John" },
            new Person { Name = "Alice" },
            new Person { Name = "Jane" }
        };

        List<Person> distinctPeople = people.GroupBy(p => p.Name).Select(g => g.First()).ToList();

        foreach (Person person in distinctPeople)
        {
            Console.WriteLine(person.Name);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在上面的代码中，我们同样定义了一个Person类，并创建了一个包含重复对象的List集合。然后，我们使用GroupBy方法根据Name属性进行分组，将相同Name属性的对象放入同一个组中。接着，我们使用Select方法选择每个组中的第一个对象，以实现去重的效果。最后，我们将去重后的结果转换为List类型，并遍历输出每个人物的Name属性。

3. 使用HashSet：

using System;
using System.Collections.Generic;

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

public class Program
{
    public static void Main()
    {
        List<Person> people = new List<Person>()
        {
            new Person { Name = "John" },
            new Person { Name = "Jane" },
            new Person { Name = "John" },
            new Person { Name = "Alice" },
            new Person { Name = "Jane" }
        };

        HashSet<Person> distinctPeople = new HashSet<Person>(people, new NameEqualityComparer());

        foreach (Person person in distinctPeople)
        {
            Console.WriteLine(person.Name);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在上面的代码中，我们同样定义了一个Person类，并创建了一个包含重复对象的List集合。然后，我们使用HashSet类，并将List集合和自定义的比较器传递给HashSet的构造函数，以实现根据Name属性进行去重的功能。最后，我们遍历输出去重后的结果。