HashSet in C#

Last Updated : 11 Sep, 2025

A HashSet<T> is a collection of unique elements. It does not allow duplicates and does not maintain any particular order.

  • Implemented using hash table internally.
  • Provides fast lookup, addition and deletion (average O(1) time complexity).
  • Implements ISet<T>, so you can perform set operations like union, intersection, etc.

Example: Creating a HashSet

C# 
using System;
using System.Collections.Generic;

class Geeks
{
    public static void Main()
    {
        // Create a HashSet 
        HashSet<int> hs = new HashSet<int>();

        // Add elements to the HashSet
        hs.Add(10);
        hs.Add(20);
        hs.Add(30);
        hs.Add(10); 

        // Display elements in the HashSet
        Console.WriteLine("Elements in the HashSet: ");
        foreach (int number in hs)
            Console.WriteLine(number);
    }
}

Output
Elements in the HashSet: 
10
20
30

Steps to Create a HashSet

The HashSet class provides different ways to create a HashSet. Here we will use the HashSet() constructor to create an instance of the HashSet class that is empty and uses the default equality comparer for the set type.

Step 1: Include System.Collections.Generic namespace

using System.Collections.Generic;

Step 2: Create a HashSet using the HashSet class

HashSet<Type_of_hashset> Hashset_name = new HashSet<Type_of_hashset>();

Performing Different Operations on HashSet

1. Adding Elements

We can add an element HashSet, then use the Add() method to add or we can also store elements in your HashSet using a collection initializer.

// Using Add method
set.Add(1);
set.Add(2);

// Using Collection Initializer

HashSet<T> s = new HashSet<int>{1,2,3};

2. Accessing Elements

We generally use a foreach loop to iterate through the elements of a HashSet.

Example:

C# 
using System;
using System.Collections.Generic;

class Geeks {

    static public void Main()
    {
        // Creating HashSet Using HashSet class
        HashSet<string> set1 = new HashSet<string>();

        // Add the elements in HashSet Using Add method
        set1.Add("C");
        set1.Add("C++");
        set1.Add("C#");
        set1.Add("Java");
        set1.Add("Ruby");
        Console.WriteLine("Elements of set1:");

        // Accessing elements of HashSet Using foreach loop
        foreach(var val in set1){
            Console.WriteLine(val);
        }

        // Creating another HashSet using collection initializer to initialize HashSet
        HashSet<int> set2 = new HashSet<int>() {1, 2, 3};
        
        // Display elements of set2
        Console.WriteLine("Elements of set2:");
        foreach(var value in set2){
            Console.WriteLine(value);
        }
    }
}

Output
Elements of set1:
C
C++
C#
Java
Ruby
Elements of set2:
1
2
3

3. Removing Elements

We can remove elements from a HashSet using three methods:

  • Remove(T): This method is used to remove the specified element from a HashSet object.
  • RemoveWhere(Predicate): This method is used to remove all elements that match the conditions defined by the specified predicate from a HashSet collection.
  • Clear: This method is used to remove all elements from a HashSet object.

Example:

C# 
using System;
using System.Collections.Generic;

class Geeks
{
    static public void Main()
    {
        // Create a HashSet
        HashSet<string> set = new HashSet<string>();

        // Add elements to HashSet
        set.Add("C");
        set.Add("C++");
        set.Add("C#");
        set.Add("Java");
        set.Add("Ruby");

        // Before removing elements
        Console.WriteLine("Elements (Before Removal): " + set.Count);

        // Remove an element
        set.Remove("C++");

        // After removal
        Console.WriteLine("Elements (After Removal): " + set.Count);
    }
}

Output
Elements (Before Removal): 5
Elements (After Removal): 4

4. Set Operations

The HashSet class also provides some methods that are used to perform different operations on sets and the methods are:

  • UnionWith(IEnumerable): This method is used to modify the current HashSet object to contain all elements that are present in itself, the specified collection or both.
  • IntersectWith(IEnumerable): This method is used to modify the current HashSet object to contain only elements that are present in that object and the specified collection.
  • ExceptWith(IEnumerable): This method is used to remove all elements in the specified collection from the current HashSet object.

Example:

C# 
using System;
using System.Collections.Generic;

class Geeks
{
    public static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3, 5 };
        HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

        // Union of two sets
        set1.UnionWith(set2);
        Console.WriteLine("After Union: "  + string.Join(", ", set1));

        // Intersection of two sets
        set1.IntersectWith(new HashSet<int> { 3, 5 });
        Console.WriteLine("After Intersection: "  + string.Join(", ", set1));

        // Difference of sets
        set1.ExceptWith(new HashSet<int> { 5 });
        Console.WriteLine("After Difference: "  + string.Join(", ", set1));
    }
}

Output
After Union: 1, 2, 3, 5, 4
After Intersection: 3, 5
After Difference: 3
Comment

Explore