Check if ListDictionary has a fixed size in C#

The ListDictionary class in C# provides the IsFixedSize property to determine whether the dictionary has a fixed size. A ListDictionary is a lightweight collection that stores key-value pairs using a singly linked list implementation, making it ideal for small collections (typically 10 or fewer items).

Syntax

Following is the syntax for checking if a ListDictionary has a fixed size −

bool isFixed = listDictionary.IsFixedSize;

Return Value

The IsFixedSize property returns a bool value −

• true − The ListDictionary has a fixed size and cannot grow or shrink

• false − The ListDictionary can dynamically add or remove elements

For a standard ListDictionary, this property always returns false since ListDictionary collections can be modified after creation.

Example 1: Basic Fixed Size Check

using System;
using System.Collections;
using System.Collections.Specialized;

public class Demo {
   public static void Main() {
      ListDictionary dict1 = new ListDictionary();
      dict1.Add("A", "Books");
      dict1.Add("B", "Electronics");
      dict1.Add("C", "Smart Wearables");
      dict1.Add("D", "Pet Supplies");
      dict1.Add("E", "Clothing");
      dict1.Add("F", "Footwear");
      
      Console.WriteLine("ListDictionary1 elements...");
      foreach(DictionaryEntry d in dict1) {
         Console.WriteLine(d.Key + " " + d.Value);
      }
      
      Console.WriteLine("Is the ListDictionary1 having fixed size? = " + dict1.IsFixedSize);
      Console.WriteLine("If ListDictionary1 read-only? = " + dict1.IsReadOnly);
      Console.WriteLine("Is ListDictionary1 synchronized = " + dict1.IsSynchronized);
      Console.WriteLine("The ListDictionary1 has the key M? = " + dict1.Contains("M"));
      
      ListDictionary dict2 = new ListDictionary();
      dict2.Add("1", "One");
      dict2.Add("2", "Two");
      dict2.Add("3", "Three");
      dict2.Add("4", "Four");
      dict2.Add("5", "Five");
      dict2.Add("6", "Six");
      
      Console.WriteLine("\nListDictionary2 key-value pairs...");
      IDictionaryEnumerator demoEnum = dict2.GetEnumerator();
      while (demoEnum.MoveNext())
         Console.WriteLine("Key = " + demoEnum.Key + ", Value = " + demoEnum.Value);
         
      Console.WriteLine("Is the ListDictionary2 having fixed size? = " + dict2.IsFixedSize);
      Console.WriteLine("If ListDictionary2 read-only? = " + dict2.IsReadOnly);
      Console.WriteLine("Is ListDictionary2 synchronized = " + dict2.IsSynchronized);
      Console.WriteLine("The ListDictionary2 has the key 5? = " + dict2.Contains("5"));
   }
}

The output of the above code is −

ListDictionary1 elements...
A Books
B Electronics
C Smart Wearables
D Pet Supplies
E Clothing
F Footwear
Is the ListDictionary1 having fixed size? = False
If ListDictionary1 read-only? = False
Is ListDictionary1 synchronized = False
The ListDictionary1 has the key M? = False

ListDictionary2 key-value pairs...
Key = 1, Value = One
Key = 2, Value = Two
Key = 3, Value = Three
Key = 4, Value = Four
Key = 5, Value = Five
Key = 6, Value = Six
Is the ListDictionary2 having fixed size? = False
If ListDictionary2 read-only? = False
Is ListDictionary2 synchronized = False
The ListDictionary2 has the key 5? = True

Example 2: Dynamic Size Verification

using System;
using System.Collections;
using System.Collections.Specialized;

public class Demo {
   public static void Main() {
      ListDictionary dict = new ListDictionary();
      dict.Add("1", "SUV");
      dict.Add("2", "Sedan");
      dict.Add("3", "Utility Vehicle");
      dict.Add("4", "Compact Car");
      dict.Add("5", "SUV");
      dict.Add("6", "Sedan");
      dict.Add("7", "Utility Vehicle");
      dict.Add("8", "Compact Car");
      dict.Add("9", "Crossover");
      dict.Add("10", "Electric Car");
      
      Console.WriteLine("ListDictionary elements...");
      foreach(DictionaryEntry d in dict) {
         Console.WriteLine(d.Key + " " + d.Value);
      }
      
      Console.WriteLine("\nIs the ListDictionary having fixed size? = " + dict.IsFixedSize);
      Console.WriteLine("If ListDictionary read-only? = " + dict.IsReadOnly);
      Console.WriteLine("Is ListDictionary synchronized = " + dict.IsSynchronized);
      Console.WriteLine("The ListDictionary has the key K? = " + dict.Contains("K"));
      Console.WriteLine("The ListDictionary has the key 9? = " + dict.Contains("9"));
   }
}

The output of the above code is −

ListDictionary elements...
1 SUV
2 Sedan
3 Utility Vehicle
4 Compact Car
5 SUV
6 Sedan
7 Utility Vehicle
8 Compact Car
9 Crossover
10 Electric Car

Is the ListDictionary having fixed size? = False
If ListDictionary read-only? = False
Is ListDictionary synchronized = False
The ListDictionary has the key K? = False
The ListDictionary has the key 9? = True

Key Properties Comparison

Conclusion

The IsFixedSize property of ListDictionary always returns false because ListDictionary collections are dynamic and allow adding or removing elements after creation. This property is useful when working with different collection types that may have varying size constraints.