How to Make the Most of HashSet and SortedSet in .NET
If you’ve been looking into data structures in .NET, you’ve probably already encountered HashSet<T>, SortedSet<T>, ImmutableHashSet<T>, and ImmutableSortedSet<T>. These four collections might seem similar at first glance because they all store unique elements, but trust me, they each have their own personality and specific use cases.
In this post, we’ll break down the differences between these four collections, show some full code examples, and give you the lowdown on when to use each one.
HashSet<T>: Unique and Fast Access
What is it?
HashSet<T> is your go-to collection when you need a set of unique elements. Think of it as a set you might use in mathematics—it's all about ensuring no duplicates and providing fast lookups. The cool part? It doesn’t care about the order of the elements.
Why use it?
It’s best for scenarios where you need to quickly check if an item is already in the collection or when you’re working with a lot of data and want fast insertions and deletions.
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// Create a HashSet with initial elements
HashSet<int> numbers = new HashSet<int> { 10, 20, 30, 40, 50 };
// Add elements
numbers.Add(60);
numbers.Add(10); // Duplicate value, will not be added
Console.WriteLine("HashSet after adding elements:");
Console.WriteLine(string.Join(", ", numbers));
// Remove an element
numbers.Remove(30);
Console.WriteLine("\nHashSet after removing 30:");
Console.WriteLine(string.Join(", ", numbers));
// Contains method to check existence
bool contains50 = numbers.Contains(50);
Console.WriteLine($"\nDoes the HashSet contain 50? {contains50}");
// UnionWith (add elements from another collection)
HashSet<int> otherNumbers = new HashSet<int> { 60, 70, 80 };
numbers.UnionWith(otherNumbers);
Console.WriteLine("\nHashSet after UnionWith another set:");
Console.WriteLine(string.Join(", ", numbers));
// IntersectWith (find common elements)
HashSet<int> anotherSet = new HashSet<int> { 20, 40, 60 };
numbers.IntersectWith(anotherSet);
Console.WriteLine("\nHashSet after IntersectWith another set:");
Console.WriteLine(string.Join(", ", numbers));
// SymmetricExceptWith (find elements that are in one set or the other, but not both)
HashSet<int> yetAnotherSet = new HashSet<int> { 50, 60, 90 };
numbers.SymmetricExceptWith(yetAnotherSet);
Console.WriteLine("\nHashSet after SymmetricExceptWith another set:");
Console.WriteLine(string.Join(", ", numbers));
// Clear the set
numbers.Clear();
Console.WriteLine("\nHashSet after clearing:");
Console.WriteLine(string.Join(", ", numbers));
}
}This example shows how to create and manipulate a HashSet<int>. It covers adding and removing elements, checking for existence with Contains, and performing various set operations like UnionWith, IntersectWith, and SymmetricExceptWith. Since HashSet<T> does not allow duplicates, it automatically ignores attempts to add duplicate values. The code also demonstrates how to clear the set, which removes all elements.
SortedSet<T>: Sorted and Unique
What is it?
SortedSet<T> is like HashSet<T>, but with an important twist: it automatically keeps your elements in sorted order. So, if you're working with a set of unique items but want them in order, this is your collection.
Why use it?
Use this when you want unique items, and order matters. It’s super handy when you need the benefits of a set but also need your data to be sorted without manually sorting it every time.
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
// Create a SortedSet with initial elements
SortedSet<int> sortedNumbers = new SortedSet<int> { 50, 20, 30, 10, 40 };
// Add elements
sortedNumbers.Add(60);
sortedNumbers.Add(25); // Adds 25 in sorted order
Console.WriteLine("SortedSet after adding elements:");
Console.WriteLine(string.Join(", ", sortedNumbers));
// Remove an element
sortedNumbers.Remove(30);
Console.WriteLine("\nSortedSet after removing 30:");
Console.WriteLine(string.Join(", ", sortedNumbers));
// Contains method to check existence
bool contains40 = sortedNumbers.Contains(40);
Console.WriteLine($"\nDoes the SortedSet contain 40? {contains40}");
// UnionWith (add elements from another collection)
SortedSet<int> moreNumbers = new SortedSet<int> { 70, 80, 90 };
sortedNumbers.UnionWith(moreNumbers);
Console.WriteLine("\nSortedSet after UnionWith another set:");
Console.WriteLine(string.Join(", ", sortedNumbers));
// IntersectWith (find common elements)
SortedSet<int> anotherSortedSet = new SortedSet<int> { 20, 40, 60 };
sortedNumbers.IntersectWith(anotherSortedSet);
Console.WriteLine("\nSortedSet after IntersectWith another set:");
Console.WriteLine(string.Join(", ", sortedNumbers));
// Clear the set
sortedNumbers.Clear();
Console.WriteLine("\nSortedSet after clearing:");
Console.WriteLine(string.Join(", ", sortedNumbers));
}
}In this example, we create a SortedSet<int> that automatically sorts the elements as they are added. The code shows how to add elements, remove them, and check if an element exists. It also demonstrates the use of set operations like UnionWith, IntersectWith, and DifferenceWith. Since the elements are sorted, the SortedSet keeps the elements in ascending order. It’s a great choice when you need both uniqueness and automatic sorting.
ImmutableHashSet<T>: Thread-Safe and Unchangeable
What is it?
If you’re looking for a collection that you don’t want to change after it’s created, ImmutableHashSet<T> is what you need. As the name implies, it’s immutable. Once you create it, it’s frozen. Need to add an item? It creates a brand new set.
Why use it?
Great for multi-threaded environments where you don’t want anyone to modify the collection. It’s thread-safe because you can’t alter it once it’s created, and everyone can access it without fear of changes happening while they’re reading it.
using System;
using System.Collections.Immutable;
class Program
{
static void Main()
{
// Create an ImmutableHashSet with initial elements
ImmutableHashSet<int> immutableSet = ImmutableHashSet<int>.Empty.Add(10).Add(20).Add(30);
Console.WriteLine("Original ImmutableHashSet:");
Console.WriteLine(string.Join(", ", immutableSet));
// Add elements (returns a new instance)
var newSet = immutableSet.Add(40);
Console.WriteLine("\nImmutableHashSet after adding 40:");
Console.WriteLine(string.Join(", ", newSet));
// Remove an element (returns a new instance)
var afterRemoveSet = newSet.Remove(20);
Console.WriteLine("\nImmutableHashSet after removing 20:");
Console.WriteLine(string.Join(", ", afterRemoveSet));
// Check if an element exists
bool contains30 = afterRemoveSet.Contains(30);
Console.WriteLine($"\nDoes the ImmutableHashSet contain 30? {contains30}");
// UnionWith (returns a new set)
var anotherImmutableSet = ImmutableHashSet<int>.Empty.Add(50).Add(60);
var unionSet = afterRemoveSet.Union(anotherImmutableSet);
Console.WriteLine("\nImmutableHashSet after UnionWith another set:");
Console.WriteLine(string.Join(", ", unionSet));
// IntersectWith (returns a new set)
var intersectionSet = unionSet.Intersect(ImmutableHashSet<int>.Empty.Add(30).Add(50));
Console.WriteLine("\nImmutableHashSet after IntersectWith another set:");
Console.WriteLine(string.Join(", ", intersectionSet));
}
}Here, we work with an ImmutableHashSet<int>, which, unlike a regular HashSet<T>, doesn’t allow modification of its existing elements. Instead, each operation like adding or removing elements returns a new set. The code shows how to add and remove elements, check if an element exists, and perform set operations like Union and Intersect. Since the set is immutable, any modification results in a new instance of the set, ensuring the original set remains unchanged.
ImmutableSortedSet<T>: Immutable and Sorted
What is it?
ImmutableSortedSet<T> combines the immutability of ImmutableHashSet<T> with the sorted nature of SortedSet<T>. Once it's created, you can't change it, and it keeps the elements sorted automatically.
Why use it?
Use this when you need a collection that’s immutable, sorted, and thread-safe. It’s great for scenarios where you have data that shouldn’t change and needs to stay in order.
using System;
using System.Collections.Immutable;
class Program
{
static void Main()
{
// Create an ImmutableSortedSet with initial elements
ImmutableSortedSet<int> immutableSortedSet = ImmutableSortedSet<int>.Empty.Add(50).Add(10).Add(40).Add(30);
Console.WriteLine("Original ImmutableSortedSet:");
Console.WriteLine(string.Join(", ", immutableSortedSet));
// Add elements (returns a new instance)
var updatedSet = immutableSortedSet.Add(60);
Console.WriteLine("\nImmutableSortedSet after adding 60:");
Console.WriteLine(string.Join(", ", updatedSet));
// Remove an element (returns a new instance)
var removedSet = updatedSet.Remove(10);
Console.WriteLine("\nImmutableSortedSet after removing 10:");
Console.WriteLine(string.Join(", ", removedSet));
// Check if an element exists
bool contains40 = removedSet.Contains(40);
Console.WriteLine($"\nDoes the ImmutableSortedSet contain 40? {contains40}");
// UnionWith (returns a new set)
var anotherSortedSet = ImmutableSortedSet<int>.Empty.Add(80).Add(90);
var unionSet = removedSet.Union(anotherSortedSet);
Console.WriteLine("\nImmutableSortedSet after UnionWith another set:");
Console.WriteLine(string.Join(", ", unionSet));
// IntersectWith (returns a new set)
var intersectionSet = unionSet.Intersect(ImmutableSortedSet<int>.Empty.Add(40).Add(90));
Console.WriteLine("\nImmutableSortedSet after IntersectWith another set:");
Console.WriteLine(string.Join(", ", intersectionSet));
// DifferenceWith (returns a new set)
var differenceSet = unionSet.Except(ImmutableSortedSet<int>.Empty.Add(90));
Console.WriteLine("\nImmutableSortedSet after Except another set:");
Console.WriteLine(string.Join(", ", differenceSet));
}
}This example demonstrates how to use an ImmutableSortedSet<int>, which behaves similarly to ImmutableHashSet<T>, but it also keeps the elements sorted in ascending order. The operations in the code include adding and removing elements (which return new sets), checking for the existence of an element, and performing operations like Union, Intersect, and Except. Just like with other immutable collections, modifications create new instances, ensuring the original set stays intact. It’s perfect for situations where you need both immutability and sorted elements.
When to Use Each Collection
- HashSet<T>: When you need unique elements but don’t care about order. Fast lookups are a priority.
- SortedSet<T>: When you need unique elements and care about their order.
- ImmutableHashSet<T>: When you need an immutable, thread-safe set that can’t be changed.
- ImmutableSortedSet<T>: When you need an immutable, thread-safe set with elements kept in sorted order.
Wrapping Up ✨
These four collections — HashSet<T>, SortedSet<T>, ImmutableHashSet<T>, and ImmutableSortedSet<T>—are all powerful tools to have in your .NET toolkit. The main difference lies in mutability, ordering, and thread safety. So, depending on whether you need fast, unordered access, sorted data, or an immutable collection, you can choose the one that best suits your needs.
If you have any questions, suggestions, or topics you’d like to see featured, feel free to reach out! Your feedback is invaluable in making my content even more helpful and engaging. A big shoutout to AI tools for playing a role in enhancing the creation of this post. Until next time, Happy Coding! 🤖
