SchimmelDevNest

C#

Distinct by property of class with LINQ duplicate

27 September 2026 · 5 min read

Distinct by property of class with LINQ duplicate

When working with collections of objects in C, a common task is to retrieve a list of unique items. However, the default behavior of LINQ’s Distinct() method often doesn’t meet expectations when dealing with complex objects. By default, Distinct() compares object references or relies on the object’s overridden Equals and GetHashCode methods for value types. This means that if you have a list of custom objects and you want to get distinct items based on just one specific property, you need a more tailored approach. This article will explore various powerful and efficient ways to achieve “Distinct by property of class with LINQ”, enabling you to precisely control how uniqueness is defined within your data sets. Understanding these techniques is crucial for effective data manipulation and avoiding common pitfalls in .NET development.

Understanding the Challenge of Object Uniqueness in LINQ

The standard Distinct() method in LINQ is highly effective for primitive types like integers or strings, where equality is straightforward. For instance, a list of {1, 2, 2, 3} will correctly yield {1, 2, 3}. However, when applied to a collection of custom objects, its behavior can be misleading. Without explicit instructions, Distinct() treats two instances of a class as distinct even if all their properties hold the same values, simply because they are different references in memory.

Consider a scenario where you have a list of Product objects, each with properties like Id, Name, and Price. If your goal is to find all unique products based solely on their Id, a direct call to myProducts.Distinct() won’t work as expected. It would return every single Product object, even if multiple objects share the same Id, because each object is a unique instance in memory. This is a fundamental concept in object uniqueness that developers frequently encounter.

To overcome this, we need to instruct LINQ on how to determine uniqueness, specifically by focusing on a chosen property or a combination of properties. This is where the power and flexibility of LINQ truly shine, offering several elegant solutions. The techniques discussed below provide robust ways to filter C collections and extract precisely the unique data you require.

Method 1: Leveraging GroupBy() and Select() for Distinctness

One of the most versatile and widely used approaches to achieve “Distinct by property of class with LINQ” is to combine the GroupBy() and Select() methods. This method works by first grouping all elements that share the same value for a specified key property. Once grouped, you can then select any single element from each group, effectively yielding a distinct set based on that property.

For example, if you have a list of Employee objects and want a distinct list based on their DepartmentId, you would group the employees by this ID. Each group would then contain all employees belonging to a specific department. By taking the first element of each group, you ensure that you get one representative employee for each unique DepartmentId. This method is highly readable and intuitive, making it a popular choice for data filtering C applications.

This pattern is particularly useful when you don’t necessarily need a specific instance from the duplicates, just any instance that represents the unique key. It’s an excellent way to handle object uniqueness without needing to implement custom interfaces. The flexibility of lambda expressions within GroupBy() allows for complex grouping criteria, not just single properties.

  1. Define the Grouping Key: Use GroupBy() on your collection, specifying the property you want to be distinct as the key. For instance, myCollection.GroupBy(item => item.PropertyName).
  2. Select a Representative: After grouping, use Select() to iterate through each group. From each group, pick the first element using group.First() or group.FirstOrDefault().
  3. Combine for Result: The full query would look like myCollection.GroupBy(item => item.PropertyName).Select(group => group.First()).

Method 2: Implementing a Custom IEqualityComparer

For more complex scenarios, especially when performance is a critical concern or when you need to reuse the distinctness logic across multiple queries, implementing a custom IEqualityComparer<t></t> is an exceptionally powerful solution. This approach provides fine-grained control over how two objects are compared for equality, allowing you to define uniqueness based on one or more specific properties of your custom class.

An IEqualityComparer<t></t> requires you to implement two methods: Equals(T x, T y) and GetHashCode(T obj). The Equals method is where you define the logic for comparing two objects (e.g., comparing their Id properties). The GetHashCode method is crucial for performance, as LINQ’s Distinct() (and other set operations) uses hash codes to quickly narrow down potential matches before performing a full equality check. A well-implemented comparer can significantly boost the performance of LINQ queries dealing with large datasets and object uniqueness.

Once you have a custom comparer, you can pass an instance Question & Answer :

I have a collection: 
List<Car> cars = new List<Car>();

Cars are uniquely identified by their property CarCode.

I have three cars in the collection, and two with identical CarCodes.

How can I use LINQ to convert this collection to Cars with unique CarCodes?

You can use grouping, and get the first car from each group:

List<Car> distinct = cars .GroupBy(car => car.CarCode) .Select(g => g.First()) .ToList();