The .NET 8 release introduces a new namespace, System.Collections.Frozen, which provides two new immutable collection types: FrozenDictionary<TKey, TValue> and FrozenSet<T>

These types are designed for scenarios where collections are created infrequently but are used frequently at runtime. They offer excellent lookup performance and are ideal for cases where a collection is created once, potentially at the startup of an application, and is used throughout the remainder of the life of the application.

Benefits of using frozen collections

• Immutability: Frozen collections cannot be modified after they are created. This makes them thread-safe and helps to prevent accidental mutations.
• Performance: Frozen collections are optimized for fast lookup and enumeration. This is because they do not need to perform any checks for modifications.
• Memory usage: Frozen collections can be more memory-efficient than mutable collections. This is because they do not need to store any additional information for tracking changes.

Examples of using frozen collections

• Configuration data: Frozen collections can be used to store configuration data that is read-only. This can help to prevent accidental changes to important settings.
• Lookup tables: Frozen collections can be used to create lookup tables that are used for fast lookups. For example, a frozen dictionary could be used to map from product IDs to product names.
• Cache data: Frozen collections can be used to store cache data that is not frequently updated. This can help to improve performance by avoiding the need to constantly update the cache.

Example 1: Using FrozenDictionary to store configuration data

var configuration = new FrozenDictionary<string, string>
{
  { "DatabaseConnectionString", "Server=localhost;Database=MyDatabase" },
  { "CacheTimeout", "10000" }
};

var databaseConnectionString = configuration["DatabaseConnectionString"];
var cacheTimeout = int.Parse(configuration["CacheTimeout"]);

In this example, the configuration variable is a FrozenDictionary that stores two key-value pairs. The DatabaseConnectionString key stores the connection string for a database, and the CacheTimeout key stores the cache timeout value in milliseconds.

The databaseConnectionString and cacheTimeout variables are then assigned the values of the corresponding keys in the configuration dictionary.

Example 2: Using FrozenSet to create a lookup table

var productIds = new FrozenSet<int>
{
  1,
  2,
  3
};

bool productExists(int productId)
{
  return productIds.Contains(productId);
}

In this example, the productIds variable is a FrozenSet that stores three product IDs.

The productExists() method takes a product ID as an argument and returns true if the product ID is in the productIds set, or false otherwise.

Benefits of using frozen collections in these examples

In the first example, using a FrozenDictionary to store configuration data helps to prevent accidental changes to important settings. This is because the FrozenDictionary cannot be modified after it is created.

In the second example, using a FrozenSet to create a lookup table helps to improve performance. This is because the FrozenSet does not need to perform any checks for modifications when the Contains() method is called.

In both of these examples, using frozen collections helps to improve the overall quality of the code. This is because frozen collections are less likely to introduce errors and are more performant than mutable collections.

Additional notes

• Frozen collections are not serializable.
• Frozen collections cannot be used as keys in dictionaries or other collections.
• Frozen collections can be used with the System.Linq namespace.

Conclusion

The System.Collections.Frozen namespace provides a new set of immutable collection types that can be used to improve performance, memory usage, and thread safety. These types are a valuable addition to the .NET Framework and can be used in a variety of scenarios.