How to Compare Two Lists in C#

C# offers several efficient methods for comparing two lists. Whether you need to find common elements, identify differences, or compare complex objects, LINQ provides versatile functionalities to achieve accurate and concise comparisons. This article explores various techniques, including Intersect, Except, custom comparers, IntersectBy, and implementing IEquatable, to empower you with the knowledge to choose the best approach for your specific needs.

Using Intersect to Find Common Elements

The Intersect method allows you to identify elements present in both the source and the comparison list. For instance, to find common strings:

var source = new List<string>() { "a", "b", "c" };
var compare = new List<string>() { "b", "c", "d" };
var result = source.Intersect(compare);

// Result will contain: "b", "c"

This code snippet demonstrates how Intersect efficiently determines the shared elements between two string lists. The result variable will hold a new list containing only the elements found in both source and compare.

Using Except to Find Unique Elements

Conversely, the Except method helps identify elements present in the source list but absent in the comparison list. Using the same example:

var source = new List<string>() { "a", "b", "c" };
var compare = new List<string>() { "b", "c", "d" };
var result = source.Except(compare);

// Result will contain: "a"

Here, result will contain only “a,” as it’s the only element unique to the source list. This method is particularly useful for highlighting differences between datasets.

Venn Diagram illustrating the Except method in C#

Comparing Complex Types

Comparing lists of complex objects requires a more nuanced approach. Directly using Intersect or Except with custom classes won’t yield the desired outcome unless the objects implement comparison logic. Consider a Person class:

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

var source = new List<Person>() { new Person("Ken", "Nakamura"), new Person("Nozomi", "Nakamura") };
var compare = new List<Person>() { new Person("Ken", "Nakamura"), new Person("Keiko", "Nakamura") };

// The following will not compare the objects as intended
var result = source.Intersect(compare);

Implementing Comparers for Custom Comparison Logic

To compare complex types, you can implement the IEqualityComparer interface:

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

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

Then use the comparer with Intersect or Except:

var result = source.Intersect(compare, new PersonComparer());

Leveraging IntersectBy for Key-Based Comparisons

For simpler key-based comparisons, use IntersectBy:

var result = source.IntersectBy(compare.Select(x => x.LastName), x => x.LastName);

Implementing IEquatable for Inherent Comparison Logic

Alternatively, implement IEquatable within the Person class:

public class Person : IEquatable<Person>
{
    // ... other properties and constructor ...

    public bool Equals(Person? other) => this.LastName == other?.LastName;
    public override int GetHashCode() => (LastName).GetHashCode();
}

This allows direct use of Intersect and Except without separate comparers.

var result = source.Intersect(compare);