C# HashSet and SortedSet

The `HashSet<T>` and `SortedSet<T>` classes in C# are part of the `System.Collections.Generic` namespace and represent collections of unique elements. While both ensure that no duplicates are present, they differ in how elements are stored and accessed. Understanding these collections is essential for scenarios requiring efficient data management, uniqueness enforcement, and specific ordering of elements.

Table of Contents

1. Introduction to HashSet<T> and SortedSet<T>
- What is HashSet<T>?
- What is SortedSet<T>?
- Benefits of Using HashSet<T> and SortedSet<T>

2. Declaring and Initializing HashSet<T> and SortedSet<T>
- Declaration Syntax
- Initialization Methods
- Collection Initializers

3. Adding and Removing Elements
- Adding Elements
- Adding Range of Elements
- Removing Elements
- Clearing the Set

4. Accessing Elements
- Accessing by Enumeration
- Converting to Array

5. Iterating Through HashSet<T> and SortedSet<T>
- Using foreach Loop
- Using LINQ Queries

6. Searching Elements
- Contains Method
- Overlap and Symmetric Difference

7. Capacity and Performance
- Understanding Capacity vs. Count
- Managing Capacity
- Performance Considerations

8. Common Methods and Properties
- Key Methods
- Important Properties

9. Best Practices
- Choosing Between HashSet<T> and SortedSet<T>
- Using Appropriate Equality Comparers
- Handling Large Datasets
- Leveraging Set Operations

10. Common Mistakes with HashSet<T> and SortedSet<T>
- Ignoring Case Sensitivity
- Not Utilizing Set Operations
- Using Mutable Types as Elements

11. Advanced Topics
- Custom Comparers
- Thread Safety
- Serialization
- Immutable Sets

12. Real-World Example
13. Summary

1. Introduction to HashSet<T> and SortedSet<T>

What is HashSet<T>?

using System.Collections.Generic;

HashSet<T> hashSet = new HashSet<T>();

What is SortedSet<T>?

using System.Collections.Generic;

SortedSet<T> sortedSet = new SortedSet<T>();

Benefits of Using HashSet<T> and SortedSet<T>

2. Declaring and Initializing HashSet<T> and SortedSet<T>

2.1 Declaration Syntax

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> numbersHashSet = new HashSet<int>();
    }
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        SortedSet<string> fruitsSortedSet = new SortedSet<string>();
    }
}

2.2 Initialization Methods

HashSet<string> uniqueNames = new HashSet<string>();
SortedSet<int> sortedNumbers = new SortedSet<int>();

HashSet<string> uniqueNames = new HashSet<string>(100);

HashSet<string> caseInsensitiveSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
SortedSet<string> customSortedSet = new SortedSet<string>(new CustomComparer());

2.3 Collection Initializers

HashSet<string> uniqueFruits = new HashSet<string> { "Apple", "Banana", "Cherry" };

SortedSet<string> sortedFruits = new SortedSet<string> { "Apple", "Banana", "Cherry" };

3. Adding and Removing Elements

3.1 Adding Elements

HashSet<string> uniqueFruits = new HashSet<string>();
uniqueFruits.Add("Apple");
uniqueFruits.Add("Banana");
uniqueFruits.Add("Cherry");
uniqueFruits.Add("Apple"); // Duplicate, won't be added

SortedSet<int> sortedNumbers = new SortedSet<int>();
sortedNumbers.Add(5);
sortedNumbers.Add(3);
sortedNumbers.Add(8);
sortedNumbers.Add(3); // Duplicate, won't be added

3.2 Adding Range of Elements

HashSet<string> uniqueFruits = new HashSet<string>();
uniqueFruits.Add("Apple");
uniqueFruits.Add("Banana");

List<string> moreFruits = new List<string> { "Cherry", "Date", "Apple" };
uniqueFruits.UnionWith(moreFruits); // Adds "Cherry" and "Date", ignores "Apple"

SortedSet<int> sortedNumbers = new SortedSet<int> { 1, 2, 3 };
int[] moreNumbers = { 3, 4, 5 };
sortedNumbers.UnionWith(moreNumbers); // Adds 4 and 5, ignores 3

3.3 Removing Elements

uniqueFruits.Remove("Banana"); // Removes "Banana"
uniqueFruits.RemoveWhere(f => f.StartsWith("C")); // Removes "Cherry"

sortedNumbers.Remove(2); // Removes 2
sortedNumbers.RemoveWhere(n => n > 4); // Removes 5 and 8

3.4 Clearing the Set

uniqueFruits.Clear(); // Removes all elements
sortedNumbers.Clear(); // Removes all elements

4. Accessing Elements

4.1 Accessing by Enumeration

foreach(var fruit in uniqueFruits)
{
    Console.WriteLine(fruit);
}

foreach(var number in sortedNumbers)
{
    Console.WriteLine(number);
}

4.2 Converting to Array

string[] fruitsArray = uniqueFruits.ToArray();
int[] numbersArray = sortedNumbers.ToArray();

Console.WriteLine("Fruits Array:");
foreach(var fruit in fruitsArray)
{
    Console.WriteLine(fruit);
}

Console.WriteLine("Numbers Array:");
foreach(var number in numbersArray)
{
    Console.WriteLine(number);
}

Sample Output:
Fruits Array:
Apple
Cherry
Numbers Array:
1
2
3
4

5. Iterating Through HashSet<T> and SortedSet<T>

5.1 Using foreach Loop

HashSet<string> uniqueFruits = new HashSet<string> { "Apple", "Banana", "Cherry" };
SortedSet<int> sortedNumbers = new SortedSet<int> { 1, 2, 3 };

Console.WriteLine("Iterating through HashSet:");
foreach(var fruit in uniqueFruits)
{
    Console.WriteLine(fruit);
}

Console.WriteLine("Iterating through SortedSet:");
foreach(var number in sortedNumbers)
{
    Console.WriteLine(number);
}

Sample Output:
Iterating through HashSet:
Apple
Banana
Cherry
Iterating through SortedSet:
1
2
3

5.2 Using LINQ Queries

using System.Linq;

var fruitsWithA = uniqueFruits.Where(f => f.Contains("a") || f.Contains("A"));
var evenNumbers = sortedNumbers.Where(n => n % 2 == 0);

Console.WriteLine("Fruits containing 'a' or 'A':");
foreach(var fruit in fruitsWithA)
{
    Console.WriteLine(fruit);
}

Console.WriteLine("Even Numbers:");
foreach(var number in evenNumbers)
{
    Console.WriteLine(number);
}

Sample Output:
Fruits containing 'a' or 'A':
Apple
Banana
Even Numbers:
2
4

6. Searching Elements

6.1 Contains Method

bool hasApple = uniqueFruits.Contains("Apple");
Console.WriteLine($"Contains Apple: {hasApple}"); // Output: True

bool hasTwo = sortedNumbers.Contains(2);
Console.WriteLine($"Contains 2: {hasTwo}"); // Output: True

6.2 Overlap and Symmetric Difference

HashSet<string> setA = new HashSet<string> { "Apple", "Banana", "Cherry" };
HashSet<string> setB = new HashSet<string> { "Banana", "Date", "Elderberry" };

setA.IntersectWith(setB); // setA now contains "Banana"

Console.WriteLine("Intersection of setA and setB:");
foreach(var fruit in setA)
{
    Console.WriteLine(fruit);
}

Sample Output:
Intersection of setA and setB:
Banana

HashSet<int> setC = new HashSet<int> { 1, 2, 3, 4 };
HashSet<int> setD = new HashSet<int> { 3, 4, 5, 6 };

setC.SymmetricExceptWith(setD); // setC now contains 1, 2, 5, 6

Console.WriteLine("Symmetric Difference of setC and setD:");
foreach(var number in setC)
{
    Console.WriteLine(number);
}

Sample Output:
Symmetric Difference of setC and setD:
1
2
5
6

7. Capacity and Performance

7.1 Understanding Capacity vs. Count

HashSet<int> numbersHashSet = new HashSet<int>();
Console.WriteLine($"Initial Count: {numbersHashSet.Count}"); // Output: 0

numbersHashSet.Add(1);
Console.WriteLine($"Count after adding one element: {numbersHashSet.Count}"); // Output: 1

numbersHashSet.Add(2);
numbersHashSet.Add(3);
Console.WriteLine($"Count after adding three elements: {numbersHashSet.Count}"); // Output: 3

7.2 Managing Capacity

HashSet<int> numbersHashSet = new HashSet<int>(100);
numbersHashSet.EnsureCapacity(200); // Ensures the set can hold at least 200 elements
numbersHashSet.TrimExcess(); // Reduces capacity to match count

SortedSet<int> sortedNumbers = new SortedSet<int>();
// No direct capacity management, but efficient operations are inherent

7.3 Performance Considerations

8. Common Methods and Properties

8.1 Key Methods

8.2 Important Properties

9. Best Practices

9.1 Choosing Between HashSet<T> and SortedSet<T>

9.2 Using Appropriate Equality Comparers

HashSet<string> caseInsensitiveSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
caseInsensitiveSet.Add("apple");
caseInsensitiveSet.Add("Apple"); // Duplicate, won't be added

9.3 Handling Large Datasets

HashSet<int> largeSet = new HashSet<int>(10000);

9.4 Leveraging Set Operations

HashSet<int> setA = new HashSet<int> { 1, 2, 3 };
HashSet<int> setB = new HashSet<int> { 3, 4, 5 };

setA.UnionWith(setB); // setA now contains 1, 2, 3, 4, 5
setA.IntersectWith(new HashSet<int> { 2, 3, 6 }); // setA now contains 2, 3

9.5 Avoiding Mutable Types as Elements

public class Person
{
    public string Name { get; }
    public int Age { get; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public override bool Equals(object obj)
    {
        if(obj is Person other)
        {
            return Name == other.Name && Age == other.Age;
        }
        return false;
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(Name, Age);
    }
}

HashSet<Person> peopleSet = new HashSet<Person>();
peopleSet.Add(new Person("Alice", 30));

10. Common Mistakes with HashSet<T> and SortedSet<T>

10.1 Ignoring Case Sensitivity

HashSet<string> fruitsSet = new HashSet<string>();
fruitsSet.Add("apple");
fruitsSet.Add("Apple"); // Considered different in default comparer

HashSet<string> fruitsSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
fruitsSet.Add("apple");
fruitsSet.Add("Apple"); // Duplicate, won't be added

10.2 Not Utilizing Set Operations

foreach(var item in setA)
{
    if(setB.Contains(item))
    {
        commonSet.Add(item);
    }
}

setA.IntersectWith(setB);

10.3 Using Mutable Types as Elements

public class Person
{
    public string Name { get; set; }
}

HashSet<Person> peopleSet = new HashSet<Person>();
Person p = new Person { Name = "Alice" };
peopleSet.Add(p);
p.Name = "Alicia"; // Alters hash code if Name is used in hashing

11. Advanced Topics

11.1 Custom Comparers

public class CaseInsensitiveStringComparer : IEqualityComparer<string>
{
    public bool Equals(string x, string y)
    {
        return string.Equals(x, y, StringComparison.OrdinalIgnoreCase);
    }

    public int GetHashCode(string obj)
    {
        return obj.ToLower().GetHashCode();
    }
}

// Usage
HashSet<string> ciHashSet = new HashSet<string>(new CaseInsensitiveStringComparer());
ciHashSet.Add("Apple");
ciHashSet.Add("apple"); // Duplicate, won't be added

11.2 Thread Safety

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    static HashSet<int> numbersHashSet = new HashSet<int>();
    static object lockObj = new object();

    static void Main()
    {
        Parallel.For(0, 1000, i =>
        {
            lock(lockObj)
            {
                numbersHashSet.Add(i);
            }
        });

        Console.WriteLine($"Total Numbers Added: {numbersHashSet.Count}"); // Output: 1000
    }
}

11.3 Serialization

using System;
using System.Collections.Generic;
using System.Text.Json;

class Program
{
    static void Main()
    {
        HashSet<string> fruitsSet = new HashSet<string> { "Apple", "Banana", "Cherry" };
        SortedSet<int> sortedNumbers = new SortedSet<int> { 1, 2, 3 };

        string jsonFruits = JsonSerializer.Serialize(fruitsSet);
        string jsonNumbers = JsonSerializer.Serialize(sortedNumbers);

        Console.WriteLine(jsonFruits); // Output: ["Apple","Banana","Cherry"]
        Console.WriteLine(jsonNumbers); // Output: [1,2,3]

        // Deserialization
        HashSet<string> deserializedFruits = JsonSerializer.Deserialize<HashSet<string>>(jsonFruits);
        SortedSet<int> deserializedNumbers = JsonSerializer.Deserialize<SortedSet<int>>(jsonNumbers);

        Console.WriteLine("Deserialized Fruits:");
        foreach(var fruit in deserializedFruits)
        {
            Console.WriteLine(fruit);
        }

        Console.WriteLine("Deserialized Numbers:");
        foreach(var number in deserializedNumbers)
        {
            Console.WriteLine(number);
        }
    }
}

Sample Output:
["Apple","Banana","Cherry"]
[1,2,3]
Deserialized Fruits:
Apple
Banana
Cherry
Deserialized Numbers:
1
2
3

11.4 Immutable Sets

using System;
using System.Collections.Immutable;

class Program
{
    static void Main()
    {
        ImmutableHashSet<string> immutableFruits = ImmutableHashSet.Create("Apple", "Banana", "Cherry");
        // immutableFruits.Add("Date"); // Returns a new set, original remains unchanged

        Console.WriteLine("Immutable Fruits:");
        foreach(var fruit in immutableFruits)
        {
            Console.WriteLine(fruit);
        }
    }
}

Sample Output:
Immutable Fruits:
Apple
Banana
Cherry

12. Real-World Example

Example: Student Enrollment System Using HashSet<T>

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        EnrollmentSystem enrollment = new EnrollmentSystem();

        // Enroll students
        enrollment.EnrollStudent("Alice");
        enrollment.EnrollStudent("Bob");
        enrollment.EnrollStudent("Charlie");
        enrollment.EnrollStudent("Alice"); // Duplicate, won't be enrolled again

        // Display all enrolled students
        Console.WriteLine("Enrolled Students:");
        enrollment.DisplayEnrolledStudents();

        // Check enrollment
        Console.WriteLine($"\nIs Bob enrolled? {enrollment.IsEnrolled("Bob")}");
        Console.WriteLine($"Is David enrolled? {enrollment.IsEnrolled("David")}");

        // Unenroll a student
        enrollment.UnenrollStudent("Charlie");
        Console.WriteLine("\nEnrolled Students after unenrolling Charlie:");
        enrollment.DisplayEnrolledStudents();

        // Attempt to unenroll a non-existent student
        enrollment.UnenrollStudent("Eve");
    }
}

public class EnrollmentSystem
{
    private HashSet<string> enrolledStudents;

    public EnrollmentSystem()
    {
        enrolledStudents = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
    }

    public bool EnrollStudent(string studentName)
    {
        if(enrolledStudents.Add(studentName))
        {
            Console.WriteLine($"Enrolled: {studentName}");
            return true;
        }
        else
        {
            Console.WriteLine($"Student {studentName} is already enrolled.");
            return false;
        }
    }

    public bool UnenrollStudent(string studentName)
    {
        if(enrolledStudents.Remove(studentName))
        {
            Console.WriteLine($"Unenrolled: {studentName}");
            return true;
        }
        else
        {
            Console.WriteLine($"Student {studentName} is not enrolled.");
            return false;
        }
    }

    public bool IsEnrolled(string studentName)
    {
        return enrolledStudents.Contains(studentName);
    }

    public void DisplayEnrolledStudents()
    {
        foreach(var student in enrolledStudents)
        {
            Console.WriteLine(student);
        }
    }
}

Sample Output:
Enrolled: Alice
Enrolled: Bob
Enrolled: Charlie
Student Alice is already enrolled.
Enrolled Students:
Alice
Bob
Charlie
Is Bob enrolled? True
Is David enrolled? False
Unenrolled: Charlie
Enrolled Students after unenrolling Charlie:
Alice
Bob
Student Eve is not enrolled.

13. Summary