How do you remove duplicates from collections with Distinct and Except operators?

2 How to use Distinct operator?

The Distinct operator returns a new collection that contains only the unique elements from the original collection, based on the default equality comparer or a custom one. The Distinct operator is an extension method that can be applied to any type that implements IEnumerable<T>, such as arrays, lists, dictionaries, etc. For example, if you have an array of integers with some duplicates, you can use the Distinct operator to get a new array with only the distinct values:

int[] numbers = { 1, 2, 3, 4, 4, 5, 6, 6, 7 };
int[] distinctNumbers = numbers.Distinct().ToArray();
// distinctNumbers = { 1, 2, 3, 4, 5, 6, 7 }        

You can also use a custom equality comparer to define how the elements are compared for equality. For example, if you have a list of strings with some duplicates that differ only by case, you can use the Distinct operator with a custom comparer that ignores the case:

List<string> names = new List<string> { "Alice", "Bob", "bob", "Charlie", "alice" };
List<string> distinctNames = names.Distinct(StringComparer.OrdinalIgnoreCase).ToList();
// distinctNames = { "Alice", "Bob", "Charlie" }        

3 How to use Except operator?

The Except operator returns a new collection that contains only the elements from the first collection that are not present in the second collection, based on the default equality comparer or a custom one. The Except operator is an extension method that can be applied to any type that implements IEnumerable<T>, such as arrays, lists, dictionaries, etc. For example, if you have two arrays of integers and you want to get the elements that are in the first array but not in the second array, you can use the Except operator to get a new array with the difference:

int[] numbers1 = { 1, 2, 3, 4, 5 };
int[] numbers2 = { 3, 4, 5, 6, 7 };
int[] difference = numbers1.Except(numbers2).ToArray();
// difference = { 1, 2 }        

You can also use a custom equality comparer to define how the elements are compared for equality. For example, if you have two lists of strings and you want to get the elements that are in the first list but not in the second list, ignoring the case, you can use the Except operator with a custom comparer that ignores the case:

List<string> names1 = new List<string> { "Alice", "Bob", "Charlie", "David" };
List<string> names2 = new List<string> { "bob", "Charlie", "Eve", "david" };
List<string> difference = names1.Except(names2, StringComparer.OrdinalIgnoreCase).ToList();
// difference = { "Alice" }        

4 Tips and tricks

Using the Distinct and Except operators can be a great way to improve the accuracy and performance of your queries. For example, you can use the Distinct operator to remove duplicates from a collection before applying other operators, such as Count, Sum, or Average. Additionally, you can use the Except operator to perform set operations, such as union, intersection, and symmetric difference. You can also use lambda expressions or anonymous methods to create custom equality comparers for Distinct and Except. For instance, you could compare two strings by their length using a lambda expression: List<string> distinctWords = words.Distinct((x, y) => x.Length == y.Length).ToList();

5 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?