In this article, we are going to take a look at the HashSet class in C#. We will discuss how to use it and its key features. Also, we are going to see some examples of how to use it in practice. Finally, we’ll compare it to other data structures available in C#.<\/p>\n
Without further ado, let’s start!<\/p>\n
A HashSet is a collection of unique elements that uses a<\/strong> hash table<\/a> for storage, allowing faster retrieval of elements than other collection types<\/strong>. Adding and removing elements to the HashSet also has constant time complexity. However, it does not maintain insertion order and cannot access elements by index.<\/p>\n The HashSet<T><\/a> class has been available since .NET 3.5 as part of the For most of our examples, we intend to use a HashSet that contains strings of some of the popular programming languages used today.<\/p>\n Let’s start by creating an empty HashSet:<\/p>\n Let’s begin by adding a set of programming languages into our Here, we insert elements into the In some cases, we may want to initialize HashSets directly with values:<\/p>\n For all our tests, we are going to reuse the same class object instance to make our examples as easy to follow as possible:<\/p>\n Let’s also initialize our HashSet in the test constructor to avoid repetitive code:<\/p>\n Next, we can verify that our HashSet has nine elements<\/strong> and check whether it contains one of the elements (“C#” )<\/strong>:<\/p>\n We can successfully prove that Also, we use the inbuilt This technique can be useful for quickly checking if an element exists in the set without having to iterate through all of the elements.<\/p>\n HashSets do not allow for duplicate elements. It will not affect the set if we try to add a duplicate element. It uses a hashing structure that ensures that each element can only appear once in the set.<\/p>\n Let’s attempt to add duplicate elements to the When we try to add duplicate values to our Besides using the inbuilt Let’s put this theory into practice:<\/p>\n Here, To remove an item from the HashSet, we can use the Here, the Next, we can verify that the We invoke the Besides using the inbuilt Our Next, let’s implement a method that returns true when an integer is odd. We are going to use this method as our predicate when we eventually implement the Finally, let’s implement our We can verify that the Here, we create a HashSet to store odd numbers from the random numbers we generate. Next, we invoke the What if we want to remove all the elements in a HashSet? We can make use of the Let’s verify that the After invoking the To iterate through a HashSet, we can use the statements available in C# such as Here, the Alternatively, we can simply call the inbuilt Let’s verify that We must remember that a HashSet does not store elements in a specific order<\/strong>, so the order in which we iterate through the elements varies.<\/p>\n Let’s understand some methods we can use for set operations as we work with HashSets.<\/p>\n When we want to check whether a HashSet instance is a proper subset of another HashSet instance, we use the We create a larger set When we want to join two sets, we perform a union operation. For example, when we want to perform a union between two sets, A and B, we copy the elements in set B over into set A.\u00a0<\/p>\n Let’s perform a The An intersection between sets A and B entails finding the common elements. To accomplish such an operation in C#, we use the inbuilt Let’s understand how to perform an intersection operation with an example:<\/p>\n Here, the This operation performs a set difference operation between two sets. If we perform a set difference between sets A and B, the operation returns the elements in A that are not present in B.<\/p>\n Let’s understand this concept with another example:<\/p>\n The Sometimes, we may want to modify a HashSet to store unique elements between two sets. That’s where the Let’s look at using the The First, since HashSets use hash tables, they facilitate quick insertion and retrieval operations as they have a constant access time of O(1).<\/strong><\/p>\n Also, we can use HashSets in applications that do not allow duplicate elements<\/strong>, which helps us eliminate data redundancy.<\/p>\n Finally, HashSets can be useful for quickly checking if an element is present in the set without having to iterate<\/strong> through all of the elements.\u00a0<\/p>\n One drawback of using a HashSet is that it does not maintain the order of its elements<\/strong>, so the order in which we iterate over them may vary.<\/p>\n Also, using HashSets may not be suitable for all situations where we need to store duplicate elements<\/strong>.<\/p>\n The HashSet data structure has limited methods available compared to other data structures such as lists<\/a> or dictionaries<\/a>.\u00a0<\/p>\n In this article, we learn that a HashSet can be a useful solution in C# when inserting and retrieving\u00a0elements as fast as possible<\/strong>. We can also use HashSets when we want to store unique elements<\/strong>.<\/p>\n However, it is important to consider our specific needs before deciding on a solution as it may not be suitable for all situations. Additionally, we have to keep in mind that a HashSet does not maintain the order of its elements<\/strong> and does not allow for accessing elements by their indices<\/strong>.<\/p>\n","protected":false},"excerpt":{"rendered":" In this article, we are going to take a look at the HashSet class in C#. We will discuss how to use it and its key features. Also, we are going to see some examples of how to use it in practice. Finally, we’ll compare it to other data structures available in C#. Without further […]<\/p>\n","protected":false},"author":6,"featured_media":62189,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_et_pb_use_builder":"","_et_pb_old_content":"","_et_gb_content_width":"","footnotes":""},"categories":[12],"tags":[1476,1477],"class_list":["post-76166","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-csharp","tag-hashset","tag-hashset-in-c","et-has-post-format-content","et_post_format-et-post-format-standard"],"yoast_head":"\nSystem.Collection.Generic<\/code> namespace and implements these interfaces:<\/p>\npublic class HashSet<T> : System.Collections.Generic.ICollection<T>,\r\nSystem.Collections.Generic.IEnumerable<T>, \r\nSystem.Collections.Generic.IReadOnlyCollection<T>,\r\nSystem.Collections.Generic.ISet<T>,\r\nSystem.Runtime.Serialization.IDeserializationCallback,\r\nSystem.Runtime.Serialization.ISerializable<\/pre>\n
<\/a>How to Create a HashSet in C#<\/h2>\n
var languages = new HashSet<string>();<\/code><\/p>\n<\/a>Add Items to a HashSet<\/h2>\n
HashSet<string><\/code> object by taking advantage of the Add()<\/code> method:<\/p>\npublic HashSet<string> ProgrammingLanguages() \r\n{\r\n var languages = new HashSet<string>();\r\n\r\n languages.Add(\"C\");\r\n languages.Add(\"C++\");\r\n languages.Add(\"C#\");\r\n languages.Add(\"Java\");\r\n languages.Add(\"Scala\");\r\n languages.Add(\"TypeScript\");\r\n languages.Add(\"Python\");\r\n languages.Add(\"JavaScript\");\r\n languages.Add(\"Rust\");\r\n\r\n return languages;\r\n}<\/pre>\nlanguages<\/code> HashSet by invoking the Add()<\/code> method.<\/p>\nvar languages = new HashSet<string> { \"C\", \"C++\", \"C#\", \"Java\" };<\/code><\/p>\nHashSetsInCSharpMethods hashSet = new HashSetsInCSharpMethods();<\/code><\/p>\nprivate readonly HashSet<string> _languages;\r\n\r\npublic HashSetInCSharpUnitTests()\r\n{\r\n _languages = hashSet.ProgrammingLanguages();\r\n}<\/pre>\nAssert.IsInstanceOfType(_languages, typeof(HashSet<string>));\r\nAssert.AreEqual(_languages.Count(), 9);\r\nAssert.IsTrue(_languages.Contains(\"C#\"));<\/pre>\n
_languages<\/code> is of type HashSet<string><\/code>. We use the inbuilt Count()<\/code> method to check the number of elements in our HashSet.<\/p>\nContains()<\/code> method to check if a HashSet has a specific element. The method takes the element as a parameter and returns a boolean value indicating whether or not the element is present in the set.<\/p>\n<\/a>Duplicate Elements in a HashSet<\/strong><\/h2>\n
_languages<\/code> HashSet:<\/p>\n_languages.Add(\"C\");\r\n_languages.Add(\"C++\");\r\n_languages.Add(\"C#\");\r\n\r\nAssert.IsInstanceOfType(_languages, typeof(HashSet<string>));\r\nAssert.AreEqual(_languages.Count(), 9);<\/pre>\n
_languages<\/code> HashSet doesn’t get modified, as the set already contains those values. Therefore, its count remains nine instead of twelve.<\/p>\n<\/a>Retrieve HashSet Elements<\/strong><\/h2>\n
Contains()<\/code> method to check whether a HashSet contains a specific value, we can use the inbuilt TryGetValue (T equalVal, out T actualVal)<\/code> technique to achieve the same result. The method takes two parameters, the first being the value to search for and the next being what the search finds or the default value when the search doesn’t yield any results.\u00a0<\/p>\nAssert.IsTrue(_languages.TryGetValue(\"C#\", out _));\r\nAssert.IsTrue(_languages.Contains(\"C#\"));\r\nAssert.IsFalse(_languages.TryGetValue(\"Assembly\", out _));\r\nAssert.IsFalse(_languages.Contains(\"Assembly\"));<\/pre>\n
_languages<\/code> does not contain “Assembly” but contains “C#” and uses the discard operator to ignore the TryGetValue()<\/code> method’s return value.\u00a0\u00a0<\/p>\n<\/a>Remove Elements From a HashSet<\/h2>\n
Remove()<\/code> method. Like the Add()<\/a> method,\u00a0 it takes the object as a parameter and removes it from the HashSet:\u00a0<\/p>\npublic HashSet<string> RemoveElement(HashSet<string> hashSet, string value) \r\n{\r\n hashSet.Remove(value);\r\n\r\n return hashSet;\r\n}<\/pre>\nRemoveElement()<\/code> method takes a HashSet<string><\/code> and a string<\/code> as parameters and uses the Remove()<\/code> method to remove an element before returning the updated HashSet.\u00a0<\/p>\nRemoveElement()<\/code> method successfully removes elements:<\/p>\nvar elementToRemove = \"Java\";\r\n\r\nvar updatedLanguages = hashSet.RemoveElement(_languages, elementToRemove);\r\n\r\nAssert.IsFalse(updatedLanguages.Contains(elementToRemove));\r\nAssert.AreEqual(_languages.Count(), 8);<\/pre>\n
RemoveElement()<\/code> method and pass our HashSet, and a string (“Java”), which we can prove is removed as the updated HashSet does not contain that value, and its count decreases by one.\u00a0<\/p>\n<\/a>RemoveWhere() Method<\/h3>\n
Remove()<\/code> method, we can use the RemoveWhere()<\/code> method that takes a predicate<\/a> as a parameter to set conditions that determine whether we remove an element. To illustrate this concept, let’s implement a HashSet that stores unique random numbers:<\/p>\npublic HashSet<int> RandomInts(int size) \r\n{\r\n var rand = new Random();\r\n var numbers = new HashSet<int>();\r\n\r\n for (int i = 0; i < size; i++) \r\n {\r\n numbers.Add(rand.Next());\r\n }\r\n\r\n return numbers;\r\n}<\/pre>\nRandomInts()<\/code> method takes the number of integers to generate as its sole input. It uses the inbuilt random<\/a> class to generate random numbers and inserts each value into a HashSet before returning it.\u00a0<\/p>\nRemoveWhereElement()<\/code> method:<\/p>\npublic bool IsOdd(int num) \r\n{\r\n return num % 2 == 1;\r\n}<\/pre>\nRemoveWhereElement()<\/code> method by passing the predicate function IsOdd()<\/code> as a parameter:<\/p>\npublic HashSet<int> RemoveWhereElement(HashSet<int> hashSet)\r\n{\r\n hashSet.RemoveWhere(IsOdd);\r\n\r\n return hashSet;\r\n}<\/pre>\nRemoveWhereElement()<\/code> method removes all the odd numbers in the HashSet:<\/p>\nvar numbers = hashSet.RandomInts(100);\r\nvar oddNumbers = new HashSet<int>();\r\n\r\nforeach (var item in numbers) \r\n{\r\n if (hashSet.IsOdd(item) == true) \r\n {\r\n oddNumbers.Add(item);\r\n }\r\n}\r\n\r\nhashSet.RemoveWhereElement(numbers);\r\nvar testValue = oddNumbers.First();\r\nvar checkValue = hashSet.IsOdd(testValue);\r\n\r\nAssert.IsTrue(checkValue);\r\nAssert.IsFalse(oddNumbers.IsSubsetOf(numbers));\r\nAssert.AreEqual(numbers.Union(oddNumbers).Count(), 100);<\/pre>\nRemoveWhereElement()<\/code> method to remove all odd numbers from numbers<\/code> (contains all the numbers, including odd numbers). Then, we check whether the first element in the oddNumbers<\/code> HashSet is an odd number. Finally, we assert that oddNumbers<\/code> is not a subset of numbers<\/code>, and verify that their union still adds up to 100 elements.\u00a0<\/p>\n<\/a>Remove Elements From a HashSet Through the Clear() Method<\/h3>\n
Clear()<\/code> inbuilt method.<\/p>\nClear()<\/code> method removes all elements from the _languages<\/code> HashSet:<\/p>\n_languages.Clear();\r\n\r\nAssert.AreEqual(0, _languages.Count());\r\nAssert.IsNull(_languages.FirstOrDefault());<\/pre>\n
Clear()<\/code> method, we can prove that we remove all the elements from the _languages<\/code> HashSet as it has a count of zero.\u00a0\u00a0<\/p>\n<\/a>Iterate Through a HashSet in C#<\/h2>\n
for<\/code>, foreach<\/code> and while<\/code> loops to achieve our goals:<\/p>\npublic List<int> CreateList(HashSet<int> hashSet)\r\n{\r\n var list = new List<int>();\r\n\r\n foreach (var item in hashSet) \r\n {\r\n list.Add(item);\r\n }\r\n\r\n return list;\r\n}<\/pre>\nCreateList()<\/code> method takes aHashSet<int><\/code> object as its sole parameter and adds all the elements to the list.<\/p>\nToList()<\/code> method to convert the HashSet into a list:<\/p>\nvar list = hashSet.ToList();<\/pre>\n
CreateList()<\/code> successfully returns a populated List<int><\/code> object:\u00a0<\/p>\nvar numbers = hashSet.RandomInts(100);\r\n\r\nvar numbersList = hashSet.CreateList(numbers);\r\n\r\nCollectionAssert.AllItemsAreInstancesOfType(numbersList, typeof(int));\r\nAssert.AreEqual(numbersList.Count(), numbers.Count());<\/pre>\n
<\/a>HashSet Set Operations Methods in C#<\/h2>\n
<\/a>IsProperSubsetOf\/IsProperSuperSetOf<\/h3>\n
IsProperSubsetOf()<\/code> method. Likewise, we can use the IsProperSupersetOf()<\/code> method to determine if a HashSet is a superset of another HashSet:<\/p>\nvar moreLanguages = new HashSet<string> {\"C\", \"C++\", \"C#\", \"Java\", \"Scala\", \"TypeScript\", \r\n \"Python\", \"JavaScript\", \"Rust\", \"Assembly\", \"Pascal\"};\r\n\r\nAssert.IsTrue(_languages.IsSubsetOf(moreLanguages));\r\nAssert.IsTrue(_languages.IsProperSubsetOf(moreLanguages));\r\nAssert.IsTrue(moreLanguages.IsSupersetOf(_languages));\r\nAssert.IsTrue(moreLanguages.IsProperSupersetOf(_languages));<\/pre>\nmoreLanguages<\/code> that contains more elements, including all the elements in the languages<\/code> set. Therefore, languages<\/code> is a proper subset of moreLanguages<\/code> , and the latter is the proper superset of the former.\u00a0<\/p>\n<\/a>UnionWith<\/h3>\n
UnionWith()<\/code> operation between _languages<\/code> and moreLanguages<\/code> HashSet to illustrate this concept:<\/p>\nvar moreLanguages = new HashSet<string> { \"Assembly\", \"Pascal\", \"HTML\", \"CSS\", \"PHP\" };\r\n\r\n_languages.UnionWith(moreLanguages);\r\nAssert.AreEqual(_languages.Count(), 14);<\/pre>\nUnionWith()<\/code> method copies the elements in moreLanguages<\/code> HashSet into the _languages<\/code> HashSet hence, the latter now has fourteen elements instead of nine.\u00a0<\/p>\n<\/a>IntersectWith<\/h3>\n
IntersetWith()<\/code> method.\u00a0<\/p>\nvar moreLanguages = new HashSet<string> { \"C\", \"C++\", \"C#\", \"Java\", \"Scala\", \"Assembly\", \r\n \"Pascal\", \"HTML\", \"CSS\", \"PHP\" };\r\n\r\n_languages.IntersectWith(moreLanguages);\r\n\r\nAssert.AreEqual(_languages.Count(), 5);\r\nAssert.IsTrue(_languages.Contains(\"C\"));\r\nAssert.IsTrue(_languages.Contains(\"C++\"));\r\nAssert.IsTrue(_languages.Contains(\"C#\"));\r\nAssert.IsTrue(_languages.Contains(\"Java\"));\r\nAssert.IsTrue(_languages.Contains(\"Scala\"));\r\nAssert.IsFalse(_languages.Contains(\"Assembly\"));<\/pre>\nIntersectWith()<\/code> method selects the elements that are common in both _languages<\/code> and moreLanguages<\/code> sets.\u00a0<\/p>\n<\/a>ExceptWith<\/h3>\n
var moreLanguages = new HashSet<string> { \"C\", \"C++\", \"C#\", \"Java\", \"Scala\", \"Assembly\", \r\n \"Pascal\", \"HTML\", \"CSS\", \"PHP\" };\r\n\r\n_languages.ExceptWith(moreLanguages);\r\n\r\nAssert.AreEqual(_languages.Count(), 4);\r\nAssert.IsTrue(_languages.Contains(\"TypeScript\"));\r\nAssert.IsTrue(_languages.Contains(\"Python\"));\r\nAssert.IsTrue(_languages.Contains(\"JavaScript\"));\r\nAssert.IsTrue(_languages.Contains(\"Rust\"));\r\nAssert.IsFalse(_languages.Contains(\"Assembly\"));<\/pre>\nExceptWith()<\/code> method returns the elements that are in _languages<\/code> but not in moreLanguages<\/code>, which are: “TypeScript”, “Python”, “JavaScript” and “Rust”.\u00a0<\/p>\n<\/a>SymmetricExceptWith<\/h3>\n
SymmetricExceptWith()<\/code> method comes into play, as we can use it to accomplish our purpose.<\/p>\nSymmetricExceptWith()<\/code> method:<\/p>\nvar moreLanguages = new HashSet<string> { \"Assembly\", \"Pascal\", \"HTML\", \"CSS\", \"PHP\" };\r\n\r\n_languages.SymmetricExceptWith(moreLanguages);\r\n\r\nAssert.AreEqual(_languages.Count(), 14);<\/pre>\nSymmetricExceptWith()<\/code> method modifies the _languages<\/code> HashSet to make it have unique elements from both itself and moreLanguages<\/code> HashSet. Therefore, since both sets have unique values, the modified _languages<\/code> HashSet now contains fourteen elements.\u00a0<\/p>\n<\/a>Benefits of a HashSet in C#<\/h2>\n
<\/a>Drawbacks of a HashSet in C#<\/h2>\n
<\/a>Conclusion<\/h2>\n