How to Use LINQ Distinct by Property in C#

By the end of this page, you will understand why Distinct() does not automatically compare object properties, how equality works for custom classes in C#, and the common ways to get unique objects by one or more properties. You will also see practical approaches using GroupBy, custom equality comparers, and DistinctBy in modern C#.

Distinct() in LINQ removes duplicate items based on equality. For simple types like int, string, or DateTime, this works as you expect because those types already define value-based equality.

For custom classes like Person, the default behavior is different. Unless you define equality yourself, C# compares object references, not property values. That means two different Person instances with the same Id and Name are still considered different objects.

var p1 = new Person { Id = 1, Name = "Test1" };
var p2 = new Person { Id = 1, Name = "Test1" };

Console.WriteLine(p1 == p2); // False

Even though the property values match, these are two separate objects in memory.

So when you call:

people.Distinct()

LINQ only removes duplicates if the objects are considered equal by:

• Equals()

Think of Distinct() as a bouncer checking names on a guest list.

• For simple values like numbers, the bouncer can easily tell whether 1 is the same as another 1.
• For objects like Person, the bouncer does not automatically inspect the Id or Name badge.
• Instead, by default, the bouncer only checks whether it is literally the same person instance entering again.

If you want the bouncer to treat two Person objects with the same Id as duplicates, you must give the bouncer a rule such as:

• “Compare only Id”
• “Compare Id and Name”

That rule can be provided by:

• grouping by a property
• selecting a distinct key
• or writing a custom comparer

1. Using GroupBy()

This is one of the easiest and most readable ways.

var distinctPeople = people
    .GroupBy(p => p.Id)
    .Select(group => group.First())
    .ToList();

How it works

• GroupBy(p => p.Id) creates one group for each unique Id
• Select(group => group.First()) picks one Person from each group
• ToList() turns the result back into a list

For the sample data, the result contains:

Id = 1, Name = "Test1"
Id = 2, Name = "Test2"

2. Using DistinctBy() in modern .NET

If you are using .NET 6 or later, LINQ includes DistinctBy().

var distinctPeople = people
    .DistinctBy(p => p.Id)
    .ToList();

Consider this example:

var people = new List<Person>
{
    new Person { Id = 1, Name = "Test1" },
    new Person { Id = 1, Name = "Test1" },
    new Person { Id = 2, Name = "Test2" }
};

var distinctPeople = people
    .GroupBy(p => p.Id)
    .Select(group => group.First())
    .ToList();

Step-by-step

Step 1: Start with the original list

[
    { Id = 1, Name = "Test1" },
    { Id = 1, Name = "Test1" },
    { Id = 2, Name = "Test2" }
]

Step 2: GroupBy(p => p.Id)

LINQ groups items by Id.

Group 1:

Key = 1
Items = [
    { Id = 1, Name = "Test1" },
    { Id = 1, Name = "Test1" }
]

Common situations where distinct-by-property is useful

Removing duplicate database results

A query or join may return repeated entities with the same ID.

var uniqueUsers = users.DistinctBy(u => u.Id).ToList();

Importing CSV or API data

A file may contain duplicate rows for the same product.

var uniqueProducts = products.GroupBy(p => p.Sku).Select(g => g.First()).ToList();

Keeping one log entry per request

You may want only one record per request ID.

var uniqueRequests = logs.DistinctBy(log => log.RequestId).ToList();

Merging data from multiple sources

When combining lists, duplicates are common.

var merged = listA.Concat(listB)
    .DistinctBy(x => x.Id)
    .ToList();

De-duplicating form submissions

If users accidentally submit the same entry twice, you may want to keep just one.

var uniqueEmails = submissions.DistinctBy(s => s.Email).ToList();

In real projects, developers usually choose one of these patterns depending on where the equality rule belongs.

Query-level uniqueness

If the rule is specific to one query, developers often use GroupBy() or DistinctBy() directly in that query.

var activeUsers = users
    .Where(u => u.IsActive)
    .DistinctBy(u => u.Id)
    .ToList();

This is useful when the uniqueness rule is local and should not affect the entire class.

Reusable comparer objects

If the same distinct logic appears in several places, a custom comparer is common.

var comparer = new PersonIdComparer();

var result = people.Distinct(comparer).ToList();

This avoids repeating the same grouping logic everywhere.

Guarding against null values

In real code, developers often validate input before running LINQ.

if (people == null)
{
    return new List<Person>();
}

return people.DistinctBy(p => p.Id).ToList();

Choosing which duplicate to keep

Sometimes duplicates are not identical. Developers then define a rule for which record wins.

Examples:

1. Expecting Distinct() to compare properties automatically

Broken example:

var distinctPeople = people.Distinct().ToList();

Why it fails:

• For custom classes, default equality is usually reference-based
• Two separate Person objects with the same data are still different

Use one of these instead:

var distinctPeople = people.GroupBy(p => p.Id).Select(g => g.First()).ToList();

or

var distinctPeople = people.DistinctBy(p => p.Id).ToList();

2. Writing Equals() without GetHashCode()

Broken example:

public override bool Equals(object obj)
{
    return obj is Person other && Id == other.Id;
}

Why it is a problem:

// Distinct objects by one property (.NET 6+)
var result = people.DistinctBy(p => p.Id).ToList();

// Distinct objects by multiple properties (.NET 6+)
var result2 = people.DistinctBy(p => new { p.Id, p.Name }).ToList();

// Distinct objects by property (works in older versions)
var result3 = people.GroupBy(p => p.Id)
                    .Select(g => g.First())
                    .ToList();

// Distinct property values only
var ids = people.Select(p => p.Id).Distinct().ToList();

// Distinct with custom comparer
var result4 = people.Distinct(new PersonIdComparer()).ToList();

Rules to remember

• Distinct() uses equality, not arbitrary property comparison
• Custom classes usually need a comparer or overridden equality methods
• GroupBy(...).Select(g => g.First()) is a common fallback
• DistinctBy() is the cleanest option in modern .NET
• Use anonymous objects or tuples for multiple properties

Good key choices

• stable IDs
• unique business keys
• normalized text values when needed

Be careful with

• mutable equality fields
• missing GetHashCode()
• null handling in comparers
• assuming inspects object properties automatically

Can I use Distinct() directly on a property in C#?

Not directly on the object unless equality is defined for that object. For property-based uniqueness, use DistinctBy(), GroupBy(), or a custom comparer.

What is the easiest way to get distinct objects by one property?

If you are using .NET 6 or later, use:

people.DistinctBy(p => p.Id)

Otherwise, use:

people.GroupBy(p => p.Id).Select(g => g.First())

How do I get distinct objects by multiple properties?

Use a composite key:

people.DistinctBy(p => new { p.Id, p.Name })

or:

people.GroupBy(p => new { p.Id, p.Name }).Select(g => g.First())

Why does Distinct() not remove duplicate objects with the same values?

Because custom class instances are usually compared by reference unless you define value-based equality.

Should I override Equals() and GetHashCode() in my model class?

• Equals() and GetHashCode() - These define how objects are considered equal in C#.
• IEqualityComparer<T> - This lets you provide custom equality rules to LINQ methods like Distinct().
• GroupBy() - A common way to collect items by key and then choose one item from each group.
• Select() - Useful when projecting keys such as Id before calling Distinct().
• Anonymous types - Handy for combining multiple properties into one comparison key.
• Tuples - Another clean way to create multi-property keys.
• HashSet<T> - Also uses equality rules and is often used for efficient duplicate removal.
• OrderBy() - Often combined with grouping when you need to choose the best item from each duplicate set.