Dictionary Properties and Methods in c#

1. Add(TKey, TValue)

Adds a new key-value pair to the dictionary.

dict.Add(4, "Python");

Throws ArgumentException if key already exists.

2. ContainsKey(TKey)

Checks whether a specific key exists in a dictionary. Returns true if the key is present, otherwise false.

if (dict.ContainsKey(2))
    Console.WriteLine("Key 2 exists!");

Use ContainsKey before accessing a key to avoid exceptions when the key might not exist.

3. ContainsValue(TValue)

Checks whether a specific value exists in a dictionary. Returns true if the value is found, otherwise false.

if (dict.ContainsValue("C#"))
    Console.WriteLine("C# is available!");

Use ContainsValue when you need to verify the presence of a value before performing operations like updates or removals.

4. Clear()

The Clear() method removes all key-value pairs from a dictionary, effectively emptying the collection.

dict.Clear();
Console.WriteLine(dict.Count); // 0

Time Complexity : O(n) ,The method needs to remove all n elements from the collection.

Use Case: Use Clear() when you want to reset a collection without creating a new instance.

5. EnsureCapacity(Int32)

The EnsureCapacity method ensures that the internal data structures of a Dictionary<TKey, TValue> can hold at least the specified number of entries without resizing. This helps improve performance when adding a large number of items.

var dict = new Dictionary<int, string>();

// Pre-allocate space for 1000 entries
dict.EnsureCapacity(1000);

Time Complexity : O(n) only if the dictionary needs to resize internally. Otherwise, checking or setting capacity is O(1).

Use Case : Ideal when you know in advance that many entries will be added. It will prevents frequent rehashing/resizing, which improves insertion performance.

6. Equals(Object)

The Equals method checks whether the current dictionary is equal to another object. For Dictionary<TKey, TValue>, this performs a reference comparison, not a value comparison. Returns true if both references point to the same dictionary instance, otherwise returns false.

var dict1 = new Dictionary<int, string>();
var dict2 = dict1;

Console.WriteLine(dict1.Equals(dict2));  // Output: True

Time Complexity : O(1) , Reference comparison is constant time.

Use Case : Use Equals to check if two variables refer to the same dictionary object, not for checking if contents are identical.

7. GetEnumerator()

The GetEnumerator() method returns an enumerator that allows you to iterate over all key-value pairs in a Dictionary<TKey, TValue>. In C#, this is usually used implicitly with a foreach loop.

var enumerator = dict.GetEnumerator();
while (enumerator.MoveNext())
{
    var kvp = enumerator.Current;
    Console.WriteLine($"{kvp.Key} = {kvp.Value}");
}

Time Complexity : O(n) , Iterates through all n elements.

• Use GetEnumerator() to loop through all dictionary entries efficiently.
• Typically used in foreach, but can also be used explicitly if you need manual control over iteration.

8. GetHashCode()

GetHashCode() returns a hash code for the current Dictionary<TKey, TValue> instance. It is mostly used internally by .NET for hash-based collections and comparisons, rather than for manual operations.

dict.GetHashCode()

Time Complexity : O(1) , Returns the hash code of the dictionary instance.

• Rarely needed in regular coding.
• Primarily used by the runtime to identify objects in hash-based structures like HashSet or as a key in another dictionary.

9. GetType()

GetType() returns the runtime type of the dictionary instance. This is useful for reflection, type checks or debugging.

var dict = new Dictionary<int, string>();
Console.WriteLine(dict.GetType());

System.Collections.Generic.Dictionary`2[System.Int32,System.String]

Time Complexity : O(1) , Retrieving the type is a constant-time operation.

• To determine the exact runtime type of a dictionary.
• Useful in reflection, logging or when working with generic collections dynamically.

10. Remove(TKey)

Remove(TKey) deletes the key-value pair with the specified key from the dictionary. Returns true if the key was found and removed otherwise, false.

dict.Remove(i);

• O(1) on average : Dictionary uses a hash table for quick key lookup.
• Worst case: O(n) if many keys collide (rare).

Use Remove to delete an entry safely without throwing an exception if the key doesn’t exist.

11. Remove(TKey, TValue)

Remove(TKey, TValue) removes the key-value pair only if both the key and its associated value match. Returns true if the pair was found and removed, otherwise false.

dict.Remove(i, x);

• O(1) on average : Hash table lookup.
• Worst case O(n) in rare collisions.

• Use when you want to ensure both key and value match before removing an entry.
• Safer for scenarios where the value might have changed and you don’t want accidental deletions.

12. TryAdd(TKey, TValue)

TryAdd attempts to add a new key-value pair to the dictionary. It does not overwrite an existing key. Returns true if the pair was added successfully, otherwise false.

dict.TryAdd(i, x); // Safe add

• O(1) on average , hash table lookup to check the key.
• Worst case: O(n) in rare collisions.

• Use TryAdd when you want to add an entry only if the key does not exist, preventing accidental overwrites.

13. TryGetValue(TKey, out TValue)

if (dict.TryGetValue(1, out string name))
    Console.WriteLine("Value: " + name);
else
    Console.WriteLine("Key not found");

• O(1) on average : hash table lookup.
• Worst case: O(n) in rare collisions.

• Use TryGetValue for safe, efficient retrieval when you’re not sure if the key exists, avoiding exceptions

14. TrimExcess() and TrimExcess(Int32)

var dict = new Dictionary<int, string>(1000); // Large initial capacity

dict.Add(1, "Apple");
dict.Add(2, "Mango");

// Trim excess memory
dict.TrimExcess(); 

// Optional: ensure a specific capacity
dict.TrimExcess(500);

Time Complexity : O(n) , Copies existing elements into a new internal array when resizing occurs.

• Reduce memory usage after adding and removing many elements.
• Optimize dictionaries that grow dynamically but won’t need full allocated space anymore.

15. ToString()

ToString() returns a string representation of the dictionary object.

dict.ToString();

Useful for logging or debugging to check the type of the dictionary.