c# immutable dictionary

c# immutable dictionary



C# Immutable Dictionary

In C#, an ImmutableDictionary<TKey, TValue> is a thread-safe, read-only collection that stores key-value pairs. Once created, its content cannot be modified directly. Instead, any "modification" operation, such as adding or removing an element, returns a new instance, leaving the original collection unchanged. This makes it a valuable tool for applications requiring data integrity and thread safety.

Key Benefits of ImmutableDictionary

  • Thread Safety: Immutable collections prevent race conditions because they cannot be altered once created.
  • Predictable State: Any function or method using immutable dictionaries has predictable results, as the collection's state is consistent.
  • Efficient Changes: Returns new dictionaries with changes applied, sharing unchanged data efficiently.

Creating and Using ImmutableDictionary

Example: Adding and Modifying Key-Value Pairs

Here's how to create and modify an immutable dictionary in C#:

 

using System;
using System.Collections.Immutable;

public class ImmutableDictionaryExample
{
    public static void Main()
    {
        // Create an immutable dictionary
        var capitals = ImmutableDictionary<string, string>.Empty
            .Add("USA", "Washington, D.C.")
            .Add("UK", "London")
            .Add("France", "Paris");

        // Add a new key-value pair, returns a new dictionary
        var updatedCapitals = capitals.Add("Germany", "Berlin");

        // Modify an existing value, returns a new dictionary
        var modifiedCapitals = updatedCapitals.SetItem("UK", "Edinburgh");

        Console.WriteLine("Original Dictionary:");
        foreach (var entry in capitals)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }

        Console.WriteLine("\nUpdated Dictionary (Added Germany):");
        foreach (var entry in updatedCapitals)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }

        Console.WriteLine("\nModified Dictionary (Changed UK):");
        foreach (var entry in modifiedCapitals)
        {
            Console.WriteLine($"{entry.Key}: {entry.Value}");
        }
    }
}

Other Common Operations

  1. Remove: Removes a key-value pair, returning a new dictionary.
  2. TryGetValue: Attempts to retrieve a value without exceptions.
  3. ContainsKey: Checks if a key exists in the dictionary.
  4. SetItems: Adds or updates multiple key-value pairs at once.

Best Practices for ImmutableDictionary

  • Avoid Frequent Copies: Minimize intermediate copies when chaining multiple operations to reduce overhead.
  • Thread Safety: Take advantage of the inherent thread safety for concurrent data access.
  • Capacity Management: Use the builder pattern to efficiently add or modify multiple items.

Conclusion

The ImmutableDictionary<TKey, TValue> in C# is a valuable collection for applications requiring predictable state and thread safety. By understanding how to use its methods effectively, you can build efficient and reliable collections that are easy to manage.


Leave a reply Your email address will not be published. Required fields are marked*

Popular Posts

c# xdocument add element

5 months ago
c# xdocument add element

hashset vs list and to list in c#

5 months ago
hashset vs list and to list in c#

c# lambda select from list of objects

5 months ago
c# lambda select from list of objects

c# read xml file

5 months ago
c# read xml file

Tags