Immutable Elegance: Modifying Records in C#

One of their key advantages is immutability, ensuring that data remains unchanged once created.

intro

Introduction:

Records in C# provide a concise and efficient way to define data structures. One of their key advantages is immutability, ensuring that data remains unchanged once created. This prevents accidental modifications and enhances code reliability. In this post, we’ll explore how to modify records while preserving their immutability.

Simple Record Modification:

public record Order(string ProductName, string Size, decimal Price);

// Create an immutable Order instance
Order tShirt = new Order("Multi Color Classic", "M", 50);

// Modify the Order by creating a new instance with updated properties
Order updatedTShirt = tShirt with { Price = 60 };

The with expression creates a new Order instance with the specified property modified. The original tShirt remains unchanged.

Nested Records and Immutability:

public record OrderItem(string Name, decimal Price, int Quantity);
public record Order(string CustomerName, List<OrderItem> Items);

// Create a new order
var customerOrder = new Order(
    "John Doe",
    new List<OrderItem>
    {
        new OrderItem("Laptop", 999.99M, 1),
        new OrderItem("Mouse", 29.99M, 2)
    }
);

// Add a new item to the order
var updatedOrder = customerOrder with { Items = customerOrder.Items.Append(new OrderItem("Keyboard", 49.99M, 1)).ToList() };

// Modify an existing item's price
var orderWithModifiedItem = updatedOrder with
{
    Items = updatedOrder.Items.Select(item =>
        item == updatedOrder.Items[0] ? item with { Price = 899.99M } : item)
    .ToList()
};

When dealing with nested records and lists, remember to create new instances with the desired modifications. Use functional-style methods like Append and Select to avoid directly altering the original data.

Best Practices:

• Use with expressions for concise modifications.
• Leverage functional methods like Select and Append.
• Avoid direct modifications to original records or lists.
• Consider immutability for data integrity and code reliability.

demo video

Conclusion:

By following these guidelines, you can effectively modify records in C# while preserving their immutability. This ensures data integrity and enhances the reliability of your code.