Choosing the Right C# Collection Type for Performance

Choosing the right collection type can significantly improve C# program performance. 1. Frequently insert or delete in the middle with LinkedList, 2. Quickly search using HashSet or Dictionary, 3. Fixed arrays for fixed number of elements, 4. Select HashSet when unique values are required, 5. Frequently searching using Dictionary or SortedDictionary, 6. Consider ConcurrentBag or ConcurrentDictionary in a multi-threaded environment.

When writing C# programs, many people only need to use them at the beginning, but when the code runs, they find that they are stuck and have high memory usage. In fact, many times the problem lies in the wrong selection of the set type. Choosing the right collection type has a great impact on performance , especially when the data volume is large or frequent operations are performed.

Let’s start from several common scenarios to see which collection classes are more suitable for your needs.

When to use List<t></t> and when to change to something else?

List<t></t> is one of the most commonly used collection types, suitable for most scenarios where sequential storage and traversal are performed. It supports index access, and is quite fast to add, delete, modify and check, especially when adding or deleting it at the end, it is very efficient.

But alternatives should be considered in the following situations:

• Frequently insert or delete elements in the middle : consider using LinkedList<t></t> . Although the search is slow, insert/delete is fast.
• You need to quickly find an element : you can consider HashSet<t></t> or Dictionary<tkey tvalue></tkey> .
• The number of elements is fixed or close to fixed : using arrays ( T[] ) is more efficient because there is no extra overhead.

For example, if you maintain a player list, you often need to delete a player according to the ID. At this time, Dictionary<int player></int> is more suitable than List<player></player> .

Need a unique value? Priority to HashSet<t></t>

If you want to avoid duplicates automatically and don't need sorting, then HashSet<t></t> is the first choice. It is implemented based on a hash table, and the time complexity of insertion and search is O(1), which is much faster than repeatedly calling Contains() in List<t></t> .

For example, if you are processing user input tags and want to automatically deduplicate them, you can write this:

 var tags = new HashSet<string>();
tags.Add("C#");
tags.Add("Performance");
tags.Add("C#"); // will not be added repeatedly

It should be noted that HashSet<T> does not guarantee the order. If the order is important, you have to maintain it yourself or consider other structures, such as combining List<T> and HashSet<T> .

Frequent searches? Try Dictionary<TKey, TValue> and SortedDictionary<TKey, TValue>

Dictionary<TKey, TValue> is almost standard when you need to quickly find the corresponding value through keys. Its search speed is very fast and is suitable for caching, mapping relationships and other scenarios.

If you still need to sort by keys, use SortedDictionary<TKey, TValue> , but the performance is slightly lower because it has a red and black tree structure inside.

To give a practical example: you have a bunch of user data, and you often need to query information based on the user ID. At this time:

 var users = new Dictionary<int, User>();
users.Add(1001, new User { Name = "Alice" });
User user;
if (users.TryGetValue(1001, out user)) {
    Console.WriteLine(user.Name);
}

This method is much faster than traversing List<user></user> , especially when there are many users.

How to choose in a multi-threaded environment?

If you read and write a collection at the same time in multiple threads, you cannot directly use the normal List<t></t> or Dictionary<tkey tvalue></tkey> because they are not thread-safe. You can consider this at this time:

• ConcurrentBag<t></t> : Suitable for multiple threads to add and read separately, without caring about the order.
• ConcurrentDictionary<tkey tvalue></tkey> : A thread-safe dictionary, rich in features, suitable for concurrent search and update.
• If order consistency is required, locking mechanisms may be required, or thread-safe data structures may be designed specifically.

For example, if you have a background task pool and multiple threads continuously add tasks to it, you can use ConcurrentBag<task></task> .

Basically that's it. The choice of collection type may seem like a small detail, but it will really affect program performance, especially in high-frequency calls or large data volume scenarios. Don't use List<t></t> as soon as you come up, first think about how you want to use this data.

The above is the detailed content of Choosing the Right C# Collection Type for Performance. For more information, please follow other related articles on the PHP Chinese website!