The core of designing immutable objects and data structures in C# is to ensure that the state of the object is not modified after creation, thereby improving thread safety and reducing bugs caused by state changes. 1. Use readonly fields and initialize them with constructors to ensure that the fields are only assigned values during construction, as shown in the Person class; 2. Encapsulate the collection type and use immutable collection interfaces such as ReadOnlyCollection or ImmutableList to prevent external modification of internal collections; 3. Use record to simplify the definition of immutable model, and generate read-only attributes and constructors by default, suitable for data modeling; 4. When creating immutable collection operations, it is recommended to use the types in System.Collections. Immutable, such as ImmutableList. Each modification returns a new instance to ensure that the original data remains unchanged and memory reuse is optimized. The above methods jointly ensure the immutability of the object throughout its life cycle.

In designing immutable objects and data structures in C#, the core is to ensure that once an object is created, its state cannot be modified. This not only helps to write thread-safe code, but also reduces potential bugs caused by state changes. The key to implementation is to use read-only fields, constructor initialization, and avoid exposing mutable states.

1. Initialize using readonly fields and constructors

The most basic immutable object in C# is implemented by initializing the readonly field and constructor. readonly ensures that fields can only be assigned once in the constructor and cannot be changed afterwards.

 public class Person
{
    public string FirstName { get; }
    public string LastName { get; }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

• This approach is suitable for small objects or value objects (such as DTO).
• All properties are read-only and cannot be modified externally.
• The constructor is responsible for all initializations, clear and clear.

This method is simple and effective, but when the object structure is complex, you may encounter some limitations, such as whether nested objects also remain immutable.

2. Encapsulate collection types to maintain immutability

If your object contains collection class members, returning List<T> or Dictionary<TKey, TValue> directly may break the immutability because the caller can modify the collection content.

The correct way to do this is to use ReadOnlyCollection<T> or ImmutableList<T> :

 public class Order
{
    private readonly List<string> _items;

    public IReadOnlyCollection<string> Items => _items.AsReadOnly();

    public Order(IEnumerable<string> items)
    {
        _items = new List<string>(items);
    }
}

Or use the type provided by System.Collections.Immutable :

 using System.Collections.Immutable;

public class Order
{
    public IImutableList<string> Items { get; }

    public Order(IImmutableList<string> items)
    {
        Items = items ?? ImmutableList<string>.Empty;
    }
}

• It is recommended to use interfaces such as IImmutableList<T> to pass invariant collections.
• Avoid exposing internal collections directly to external modifications.
• Deeply copy the original data during initialization to prevent subsequent changes in external references from affecting the internal state.

3. Simplify immutable models with records

Starting with C# 9, record is ideal for defining immutable types. It generates read-only properties by default and automatically implements equal logic and immutable semantics.

 public record Person(string FirstName, string LastName);

• The compiler automatically generates constructors, read-only properties, and With expressions.
• Supports pattern matching and value semantics, which are ideal for data modeling.
• If you need extension methods or extra logic, you can add them in record.

It should be noted that although the instance of record is immutable by default, if the field itself is a mutable object (such as a normal class), the entire structure may still be "shallow immutable". Therefore, it is necessary to ensure that nested objects are also immutable.

4. Operation suggestions for creating immutable collections

When you need to frequently operate collections (such as adding and deleting elements) and want to maintain immutability, it is recommended to use the types provided by System.Collections.Immutable , for example:

 using System.Collections.Immutable;

var list = ImmutableList<int>.Empty;
list = list.Add(1).Add(2); // Return new instance

• Each operation returns a new immutable instance instead of modifying the original object.
• Memory reuse is optimized internally, with better performance than creating new lists every time.
• Common types include ImmutableList<t></t> , ImmutableDictionary<tkey tvalue></tkey> and ImmutableHashSet<t></t> .

Be careful when using these types:

• Do not mix mutable and immutable sets, as they can easily lead to misoperation.
• Try to use IImmutableList<t></t> instead of concrete implementation classes in the API interface, for easy replacement and testing.
• During initialization, existing collections can be quickly converted through .ToImmutableList() .

Basically that's it. The design focus of immutable objects is to control state changes and to use language features and library support rationally. Although it is slightly more steps to write than the normal class, the benefits in terms of concurrency and data consistency are well worth it.

The above is the detailed content of Designing Immutable Objects and Data Structures in C#. For more information, please follow other related articles on the PHP Chinese website!