LINQ's Distinct() on a Particular Property in C#

LINQ (Language-Integrated Query) provides a powerful and concise way to query collections in C#. One common requirement is filtering unique values based on a specific property of objects. This is where the LINQ Distinct() on property comes into play. In this article, we’ll explore how to achieve unique values by property using LINQ, with practical examples and best practices.

What is LINQ Distinct()?

The Distinct() method in LINQ is used to filter unique elements from a collection. By default, it uses the default equality comparer, which means it checks for overall equality of objects. However, when working with complex objects, you often need to filter distinct items by a specific property.

📄

// Example: Basic Distinct() usage
var numbers = new List<int> { 1, 2, 2, 3, 4, 4 };
var uniqueNumbers = numbers.Distinct();
Console.WriteLine(string.Join(", ", uniqueNumbers)); // Output: 1, 2, 3, 4

Using LINQ Distinct() on a Particular Property

Why Use Distinct on Property?

When working with collections of objects, such as a list of employees or products, you might want to filter unique values based on a specific property, such as a name, category, or ID. The default Distinct() method won’t work directly in such cases, as it compares entire objects, not individual properties.

Approach to Use Distinct on Property

To achieve distinct filtering by property, you can use a combination of GroupBy() or implement a custom IEqualityComparer. Below are two common approaches:

1. Using GroupBy()

The GroupBy() method groups elements by a specified key (property) and allows you to pick the first element from each group.

📄

// Example: Using GroupBy for distinct filtering
var employees = new List<Employee>
{
    new Employee { Id = 1, Name = "John" },
    new Employee { Id = 2, Name = "Jane" },
    new Employee { Id = 3, Name = "John" }
};

var distinctByName = employees.GroupBy(e => e.Name)
                              .Select(g => g.First())
                              .ToList();

foreach (var emp in distinctByName)
{
    Console.WriteLine(emp.Name); // Output: John, Jane
}

2. Using Custom IEqualityComparer

Another way to achieve distinct filtering is by implementing a custom equality comparer for the property.

📄

// Custom Equality Comparer
public class EmployeeNameComparer : IEqualityComparer<Employee>
{
    public bool Equals(Employee x, Employee y)
    {
        return x.Name == y.Name;
    }

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

// Using Distinct with custom comparer
var distinctEmployees = employees.Distinct(new EmployeeNameComparer()).ToList();

Benefits of LINQ Distinct() on Property

Using LINQ unique values by property offers several advantages:

• Eliminates redundant data from collections.
• Improves data consistency in operations such as reports or analysis.
• Enables concise and readable code compared to manual filtering logic.

Common Use Cases

Here are some common scenarios where Distinct() on property is useful:

• Filtering unique product categories from a list of products.
• Getting distinct customer names from transaction records.
• Eliminating duplicate email addresses in a contact list.

FAQs

1. Can I use Distinct() directly for a specific property?

No, the Distinct() method works on entire objects by default. For properties, use GroupBy() or a custom IEqualityComparer.

2. Which method is better: GroupBy() or Custom Comparer?

The choice depends on your requirements:

• GroupBy: Simple and concise for quick filtering.
• Custom Comparer: Ideal for reusable logic across multiple queries.

3. How does Distinct() impact performance?

While Distinct() is efficient for small collections, it may cause performance issues with large datasets due to comparisons. Optimize by using indexed properties or caching results.

Conclusion

LINQ's Distinct() method is a powerful tool for filtering unique elements in a collection. When working with objects, leveraging Distinct on property through GroupBy() or a custom comparer ensures you achieve desired results efficiently. Mastering this technique will enhance your ability to work with C# filter distinct items and create clean, maintainable code.

Start exploring LINQ's capabilities today to streamline your data operations!