Unleashing the Speed: Exploring the Fastest Collection in C# for Ultimate Performance!

#coding #codingbootcamp #softwaredeveloper

Enter to win free tuition! Enter below!
https://startuphakk.com/start-now/?v=9bXvHtj2-4E

GitHub Repo: https://github.com/slthomason/StartupHakk/tree/main/35_Fastest_Collection_In_CSharp

Collections should be an essential element of your .NET dev toolbelt. But choosing the right one is a different challenge and crucial in performance.
The knowledge about them is what each developer should have. Wasting resources by making the wrong choice is made quickly and mostly hidden.
How often did you simply choose List and waste important resources?

HashSet
What’s your favorite collection?
I bet 100 bucks it is List. Most of the time, it is certainly often in the first place. For me, the decision is quite obvious. HashSet is an everyday companion.
HashSet is very similar to List. The only difference is that no entry in this collection can be duplicated.
Can you already guess the printout? Correct, you’ll get a 1 as an output. Internally, a hash code is calculated using the function GetHashCode() to determine a bucket.
That’s a subset of objects with the same hash code. Because the hashcode is only an Int32collisions are inevitable. The system searches for identical entries within a bucket to prevent the same thing from getting added twice.
It is fast because adding just requires hash calculation and bucket management, so the HashSet is less complicated. All entries in a HashSet are simply output in order.

Dictionary
Another underestimated collection is Dictionary
It is very similar to HashSet. There’s one big difference: it takes two generic arguments.
It’s one thing to have a key (Tkey) and another thing to have a value (TValue). The key is unique and only occurs once in the dictionary.
A dictionary thus guarantees the uniqueness of its keys. However, the actual purpose is not this guarantee at all. The main purpose is to search for this key.
When this happens, a Dictionary plays to its strengths. You can find a targeted entry very quickly with a dictionary. Remember that searching for the key is also super fast in a HashSet and Bucket principle.

LinkedList
If your favorite still might be List check out LinkedList.
This collection can exist as long as it’s clear why the list is useful. This is the only list that doesn’t store data in an internal array. Since no array has to be created or expanded in case of capacity overflow, LinkedList stores large amounts of data very efficiently.
Instead of using an array, the entries are linked together and put into context. This list is unbeatable regarding memory requirements and effort when adding an element.

Stack
Next is Stack and in some cases, this collection is a great help.
In contrast to all previous collections, a stack follows the LIFO principle (Last-In-First-Out). The lastly added element also gets removed first.
The example shows that the forEach loop outputs the elements in Stack in the reverse order in which they were added.

Queue
The last type in our series isn’t for everyday use. But when you need to use it, you’d better know about it and its sweet perks.
Queue queues entries using the FIFO (First-In-First-Out) principle. The entries are taken out in the order they were added.
Queues have their advantages. It’s easy to remove the first entry from the queue with Dequeue().
In comparison to List when you remove the first entry from a list, you must move all the remaining entries, which is performance intense.