"# C# HashSet: Working with Unique Elements\n\nHave you ever needed to ensure you only have unique items in a collection? Or perhaps you need to perform set operations like union, intersection, or difference with ease? If so, C#'s `HashSet` and `SortedSet` are your powerful allies. These collection types offer a highly efficient way to manage unique elements, opening doors to optimized algorithms and cleaner code. In this comprehensive guide, we'll explore the ins and outs of Sets in C#, from basic usage to advanced scenarios, ensuring you become proficient in leveraging their capabilities.\n\n**What You'll Learn:**\n\n* Understand the fundamental concept of Sets and their advantages.\n* Differentiate between `HashSet` and `SortedSet` in C#.\n* Create, populate, and manipulate Sets effectively.\n* Perform set operations like Union, Intersection, Difference, and Symmetric Difference.\n* Explore advanced scenarios like custom equality comparisons and performance considerations.\n* Troubleshoot common issues and apply best practices.\n\n## Prerequisites\n\n* Basic understanding of C# syntax and data types.\n* Familiarity with the concept of Collections in C#.\n\n## What are Sets in C#?\n\nIn C#, a Set is a collection that stores unique elements. This means that no duplicate values are allowed within a Set. C# provides two primary implementations of Sets:\n\n* **`HashSet`:** A class that provides high-performance set operations. It's based on a hash table, offering fast lookups, insertions, and deletions. The order of elements in a `HashSet` is not guaranteed.\n* **`SortedSet`:** A class that maintains elements in a sorted order. It uses a self-balancing tree structure, providing ordered iteration and efficient set operations.\n\nSets are particularly useful in scenarios where you need to:\n\n* Ensure uniqueness of data.\n* Perform mathematical set operations.\n* Optimize search and lookup operations.\n* Represent data where order is either irrelevant (`HashSet`) or important (`SortedSet`).\n\n## Diving into `HashSet`\n\n`HashSet` is an unordered collection of unique elements. Its primary advantage is its speed when adding, removing, or checking for the existence of elements. This is due to its underlying hash table implementation, which provides O(1) average time complexity for these operations.\n\n### Creating and Populating a `HashSet`\n\nLet's start by creating a `HashSet` of integers:\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\npublic class HashSetExample\n{\n public static void Main(string[] args)\n {\n // Creating a HashSet of integers\n HashSet numbers = new HashSet();\n\n // Adding elements to the HashSet\n numbers.Add(1);\n numbers.Add(2);\n numbers.Add(3);\n numbers.Add(1); // Adding a duplicate - will be ignored\n\n // Printing the HashSet\n Console.WriteLine(\"HashSet elements:\");\n foreach (int number in numbers)\n {\n Console.WriteLine(number);\n }\n\n // Output:\n // HashSet elements:\n // 1\n // 2\n // 3\n }\n}\n```\n\n**Explanation:**\n\n1. We create a `HashSet` called `numbers`.\n2. We use the `Add()` method to add elements to the `HashSet`.\n3. Notice that when we try to add the value `1` again, it's ignored because `HashSet` only allows unique elements.\n\n### Common `HashSet` Operations\n\nHere are some common operations you can perform with `HashSet`:\n\n* **`Add(T item)`:** Adds an element to the `HashSet`. Returns `true` if the element was added (it was not already present), `false` otherwise.\n* **`Remove(T item)`:** Removes an element from the `HashSet`. Returns `true` if the element was found and removed, `false` otherwise.\n* **`Contains(T item)`:** Checks if an element exists in the `HashSet`. Returns `true` if the element is present, `false` otherwise.\n* **`Clear()`:** Removes all elements from the `HashSet`.\n* **`Count`:** Gets the number of elements in the `HashSet`.\n* **`UnionWith(IEnumerable other)`:** Modifies the current `HashSet` to contain all elements that are present in itself, the specified collection, or both.\n* **`IntersectWith(IEnumerable other)`:** Modifies the current `HashSet` to contain only elements that are present both in itself and in the specified collection.\n* **`ExceptWith(IEnumerable other)`:** Removes all elements in the specified collection from the current `HashSet`.\n* **`SymmetricExceptWith(IEnumerable other)`:** Modifies the current `HashSet` to contain only elements that are present either in itself or in the specified collection, but not both.\n* **`IsSubsetOf(IEnumerable other)`:** Determines whether the current `HashSet` is a subset of a specified collection.\n* **`IsSupersetOf(IEnumerable other)`:** Determines whether the current `HashSet` is a superset of a specified collection.\n* **`IsProperSubsetOf(IEnumerable other)`:** Determines whether the current `HashSet` is a proper (strict) subset of a specified collection. Meaning it's a subset, but not equal to the other set.\n* **`IsProperSupersetOf(IEnumerable other)`:** Determines whether the current `HashSet` is a proper (strict) superset of a specified collection. Meaning it's a superset, but not equal to the other set.\n* **`Overlaps(IEnumerable other)`:** Determines whether the current `HashSet` and a specified collection share common elements.\n* **`SetEquals(IEnumerable other)`:** Determines whether the current `HashSet` and the specified collection contain the same elements.\n\n### Example: `HashSet` Operations in Action\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\npublic class HashSetOperationsExample\n{\n public static void Main(string[] args)\n {\n HashSet set1 = new HashSet { 1, 2, 3, 4, 5 };\n HashSet set2 = new HashSet { 3, 4, 5, 6, 7 };\n\n Console.WriteLine(\"Set 1: \" + string.Join(\", \", set1)); // Output: Set 1: 1, 2, 3, 4, 5\n Console.WriteLine(\"Set 2: \" + string.Join(\", \", set2)); // Output: Set 2: 3, 4, 5, 6, 7\n\n // Union\n set1.UnionWith(set2);\n Console.WriteLine(\"Union: \" + string.Join(\", \", set1)); // Output: Union: 1, 2, 3, 4, 5, 6, 7\n\n set1 = new HashSet { 1, 2, 3, 4, 5 }; // Reset set1\n set2 = new HashSet { 3, 4, 5, 6, 7 }; // Reset set2\n\n // Intersection\n set1.IntersectWith(set2);\n Console.WriteLine(\"Intersection: \" + string.Join(\", \", set1)); // Output: Intersection: 3, 4, 5\n\n set1 = new HashSet { 1, 2, 3, 4, 5 }; // Reset set1\n set2 = new HashSet { 3, 4, 5, 6, 7 }; // Reset set2\n\n // Difference\n set1.ExceptWith(set2);\n Console.WriteLine(\"Difference: \" + string.Join(\", \", set1)); // Output: Difference: 1, 2\n\n set1 = new HashSet { 1, 2, 3, 4, 5 }; // Reset set1\n set2 = new HashSet { 3, 4, 5, 6, 7 }; // Reset set2\n\n // Symmetric Difference\n set1.SymmetricExceptWith(set2);\n Console.WriteLine(\"Symmetric Difference: \" + string.Join(\", \", set1)); // Output: Symmetric Difference: 1, 2, 6, 7\n }\n}\n```\n\n### Real-World Example: Filtering Unique User IDs\n\nImagine you're processing a stream of user IDs, and you need to identify the unique users. A `HashSet` is perfect for this:\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\npublic class UniqueUserIdsExample\n{\n public static void Main(string[] args)\n {\n List userIds = new List { 101, 102, 101, 103, 102, 104, 105 };\n HashSet uniqueUserIds = new HashSet(userIds); // Initialize from the list\n\n Console.WriteLine(\"Unique User IDs:\");\n foreach (int userId in uniqueUserIds)\n {\n Console.WriteLine(userId);\n }\n\n // Output: (Order may vary)\n // Unique User IDs:\n // 101\n // 102\n // 103\n // 104\n // 105\n }\n}\n```\n\n## Exploring `SortedSet`\n\n`SortedSet` is a collection that stores unique elements in a sorted order. It uses a self-balancing tree structure, providing efficient insertion, deletion, and retrieval operations while maintaining the sorted order. This makes it suitable for scenarios where you need to iterate through the elements in a specific sequence.\n\n### Creating and Populating a `SortedSet`\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\npublic class SortedSetExample\n{\n public static void Main(string[] args)\n {\n // Creating a SortedSet of integers\n SortedSet numbers = new SortedSet();\n\n // Adding elements to the SortedSet\n numbers.Add(3);\n numbers.Add(1);\n numbers.Add(2);\n numbers.Add(1); // Adding a duplicate - will be ignored\n\n // Printing the SortedSet\n Console.WriteLine(\"SortedSet elements:\");\n foreach (int number in numbers)\n {\n Console.WriteLine(number);\n }\n\n // Output:\n // SortedSet elements:\n // 1\n // 2\n // 3\n }\n}\n```\n\n**Explanation:**\n\n1. We create a `SortedSet` called `numbers`.\n2. We add elements in a different order (3, 1, 2).\n3. The `SortedSet` automatically sorts the elements, and the duplicate `1` is ignored.\n\n### Common `SortedSet` Operations\n\n`SortedSet` supports many of the same operations as `HashSet`, including:\n\n* **`Add(T item)`**\n* **`Remove(T item)`**\n* **`Contains(T item)`**\n* **`Clear()`**\n* **`Count`**\n* **`UnionWith(IEnumerable other)`**\n* **`IntersectWith(IEnumerable other)`**\n* **`ExceptWith(IEnumerable other)`**\n* **`SymmetricExceptWith(IEnumerable other)`**\n* **`IsSubsetOf(IEnumerable other)`**\n* **`IsSupersetOf(IEnumerable other)`**\n* **`IsProperSubsetOf(IEnumerable other)`**\n* **`IsProperSupersetOf(IEnumerable other)`**\n* **`Overlaps(IEnumerable other)`**\n* **`SetEquals(IEnumerable other)`**\n\nIn addition, `SortedSet` provides methods for working with the sorted nature of the data:\n\n* **`GetViewBetween(T lowerValue, T upperValue)`:** Creates a new `SortedSet` that contains a range of elements within the specified lower and upper values.\n* **`Min`:** Gets the smallest value in the set.\n* **`Max`:** Gets the largest value in the set.\n\n### Example: `SortedSet` Operations and Range Views\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\npublic class SortedSetOperationsExample\n{\n public static void Main(string[] args)\n {\n SortedSet numbers = new SortedSet { 5, 2, 8, 1, 9, 4 };\n\n Console.WriteLine(\"Original SortedSet: \" + string.Join(\", \", numbers)); // Output: Original SortedSet: 1, 2, 4, 5, 8, 9\n\n // Get a view between 3 and 7 (inclusive)\n SortedSet rangeView = numbers.GetViewBetween(3, 7);\n Console.WriteLine(\"Range View (3-7): \" + string.Join(\", \", rangeView)); // Output: Range View (3-7): 4, 5\n\n Console.WriteLine(\"Min: \" + numbers.Min); // Output: Min: 1\n Console.WriteLine(\"Max: \" + numbers.Max); // Output: Max: 9\n }\n}\n```\n\n### Real-World Example: Maintaining a Sorted List of High Scores\n\nImagine you're building a game and need to maintain a sorted list of high scores, ensuring no duplicate scores are stored. `SortedSet` is an excellent choice:\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\npublic class HighScoresExample\n{\n public static void Main(string[] args)\n {\n SortedSet highScores = new SortedSet();\n\n highScores.Add(1000);\n highScores.Add(1200);\n highScores.Add(900);\n highScores.Add(1200); // Duplicate - ignored\n highScores.Add(1500);\n\n Console.WriteLine(\"High Scores (Sorted):\");\n foreach (int score in highScores)\n {\n Console.WriteLine(score);\n }\n\n // Output:\n // High Scores (Sorted):\n // 900\n // 1000\n // 1200\n // 1500\n }\n}\n```\n\n## Advanced Set Concepts\n\n### Custom Equality Comparisons\n\nSometimes, the default equality comparison (using the `Equals()` method) isn't sufficient. For example, you might want to compare objects based on a specific property. In such cases, you can provide a custom `IEqualityComparer` implementation to the `HashSet` constructor.\n\n```csharp\nusing System;\nusing System.Collections.Generic;\n\npublic class Person\n{\n public string Name { get; set; }\n public int Age { get; set; }\n\n public override string ToString()\n {\n return $\"{Name} ({Age})\";\n }\n}\n\npublic class PersonNameEqualityComparer : IEqualityComparer\n{\n public bool Equals(Person x, Person y)\n {\n if (x == null && y == null)\n return true;\n if (x == null || y == null)\n return false;\n return x.Name == y.Name;\n }\n\n public int GetHashCode(Person obj)\n {\n return obj.Name.GetHashCode();\n }\n}\n\npublic class CustomEqualityExample\n{\n public static void Main(string[] args)\n {\n HashSet people = new HashSet(new PersonNameEqualityComparer());\n\n Person person1 = new Person { Name = \"Alice\", Age = 30 };\n Person person2 = new Person { Name = \"Bob\", Age = 25 };\n Person person3 = new Person { Name = \"Alice\", Age = 35 }; // Same name as person1\n\n people.Add(person1);\n people.Add(person2);\n people.Add(person3); // Will be ignored because the name is the same as person1\n\n Console.WriteLine(\"People (Unique by Name):\");\n foreach (Person person in people)\n {\n Console.WriteLine(person);\n }\n\n // Output:\n // People (Unique by Name):\n // Alice (30)\n // Bob (25)\n }\n}\n```\n\n**Explanation:**\n\n1. We define a `Person` class with `Name` and `Age` properties.\n2. We create a `PersonNameEqualityComparer` that compares `Person` objects based on their `Name` property.\n3. We create a `HashSet` using the custom comparer.\n4. When we add `person3`, it's ignored because its name is the same as `person1`, even though their ages are different.\n\n### Performance Considerations\n\n* **`HashSet`:** Offers O(1) average time complexity for `Add`, `Remove`, and `Contains` operations, making it highly efficient for large datasets where order is not important.\n* **`SortedSet`:** Offers O(log n) time complexity for `Add`, `Remove`, and `Contains` operations, where n is the number of elements in the set. While slower than `HashSet` for these operations, it provides the benefit of maintaining sorted order.\n\nChoose the appropriate Set implementation based on your specific requirements. If you need speed and order doesn't matter, use `HashSet`. If you need sorted order, use `SortedSet`.\n\n### Common Pitfalls and Solutions\n\n* **Forgetting to implement `GetHashCode()` when using custom objects:** If you're using a custom class as the type parameter for `HashSet`, you *must* override both `Equals()` and `GetHashCode()` methods. A poor `GetHashCode()` implementation can lead to performance degradation and incorrect behavior. The `GetHashCode()` method should return the same value for any two objects that are considered equal by the `Equals()` method.\n\n* **Modifying objects after they've been added to a `HashSet`:** If you modify an object's properties after it has been added to a `HashSet`, and those properties are used in the `Equals()` and `GetHashCode()` methods, the `HashSet` might not function correctly. The `HashSet` relies on the hash code to locate the object, and if the hash code changes, the object may become \"lost\" within the `HashSet`. To avoid this, avoid modifying objects that are stored in a `HashSet` after they've been added, or ensure that the properties used for equality comparisons remain constant.\n\n## FAQ: Frequently Asked Questions About Sets in C#\n\n**Q: What is the difference between `HashSet` and `SortedSet` in C#?**\n\nA: The main difference is that `HashSet` does not maintain any specific order of elements, while `SortedSet` maintains elements in a sorted order. `HashSet` generally offers faster performance for adding, removing, and checking for the existence of elements (O(1) average time complexity), while `SortedSet` provides ordered iteration (O(log n) time complexity for these operations).\n\n**Q: When should I use `HashSet` vs. `SortedSet`?**\n\nA: Use `HashSet` when you need high-performance set operations and the order of elements doesn't matter. Use `SortedSet` when you need to iterate through the elements in a sorted order or need to perform range-based queries efficiently.\n\n**Q: Can I store null values in a `HashSet` or `SortedSet`?**\n\nA: Yes, both `HashSet` and `SortedSet` allow storing null values, as long as `T` is a nullable type.\n\n**Q: How do I add multiple elements to a `HashSet` or `SortedSet` at once?**\n\nA: You can initialize the `HashSet` or `SortedSet` with an `IEnumerable` during construction, or use the `UnionWith()` method to add elements from another collection.\n\n**Q: Are `HashSet` and `SortedSet` thread-safe?**\n\nA: No, neither `HashSet` nor `SortedSet` are inherently thread-safe. If you need to use them in a multithreaded environment, you'll need to implement your own synchronization mechanisms (e.g., using locks).\n\n**Q: How can I compare objects in a `HashSet` based on a custom property?**\n\nA: Implement the `IEqualityComparer` interface and provide an instance of your custom comparer to the `HashSet` constructor. This allows you to define how objects are compared for equality within the `HashSet`. Remember to override both `Equals()` and `GetHashCode()` appropriately.\n\n## Conclusion\n\nCongratulations! You've now gained a solid understanding of Sets in C#, including `HashSet` and `SortedSet`. You've learned how to create, populate, and manipulate Sets, perform set operations, and handle advanced scenarios like custom equality comparisons. By mastering these concepts, you can write more efficient and maintainable C# code.\n\n**Next Steps:**\n\n* Experiment with different Set operations and scenarios.\n* Explore other C# Collections like `Dictionary`, `List`, and `Queue`.\n* Practice using Sets in real-world projects to solidify your knowledge.\n* Dive deeper into the performance characteristics of `HashSet` and `SortedSet` for specific use cases."