5 Essential Benefits of Immutability in C# Programming

using System;
using System.Collections.Immutable;
using System.Threading.Tasks;

public class ThreadSafetyDemo
{
    public static void Main()
    {
        // Just a simple immutable array
        var numbers = ImmutableArray.Create(1, 2, 3, 4, 5);

        // Look Ma, no locks!
        Parallel.For(0, 100, i =>
        {
            // Any thread can read the array safely
            var sum = 0;
            foreach (var num in numbers)
            {
                sum += num;
            }
            Console.WriteLine($"Thread {Task.CurrentId} calculated sum: {sum}");

            // Need to "change" something? You get a new copy
            var myThreadCopy = numbers.Add(i);
            Console.WriteLine($"Thread {Task.CurrentId} added: {myThreadCopy[myThreadCopy.Length - 1]}");
        });

        // Our original array is untouched
        Console.WriteLine($"Original array still has {numbers.Length} elements");
    }
}

public class UserProfile
{
    public string Name { get; set; }
    public int Age { get; set; }
    public List<string> Permissions { get; set; } = new List<string>();
}

public class SecurityService
{
    public static void ValidateAndProcessUser(UserProfile user)
    {
        // This silently changes the user object!
        if (user.Age >= 18)
        {
            user.Permissions.Add("BasicAccess");
        }
    }
}

// Somewhere else in your code
public void ProcessUserRequest(UserProfile user)
{
    // Did this change something? Who knows!
    SecurityService.ValidateAndProcessUser(user);

    // Surprise! The user's permissions might have changed
    if (!user.Permissions.Contains("BasicAccess"))
    {
        // Good luck figuring out if this runs or not without tracing the code
    }
}

public sealed class UserProfile
{
    public string Name { get; }
    public int Age { get; }
    public ImmutableList<string> Permissions { get; }

    public UserProfile(string name, int age, ImmutableList<string> permissions)
    {
        Name = name;
        Age = age;
        Permissions = permissions ?? ImmutableList<string>.Empty;
    }

    // Need to add a permission? Get a new profile
    public UserProfile WithPermission(string permission)
    {
        return new UserProfile(
            Name,
            Age,
            Permissions.Add(permission)
        );
    }
}

public class SecurityService
{
    public static UserProfile ValidateAndProcessUser(UserProfile user)
    {
        // Changes are explicit and returned as a new object
        if (user.Age >= 18)
        {
            return user.WithPermission("BasicAccess");
        }
        return user;
    }
}

// Somewhere else in your code
public void ProcessUserRequest(UserProfile user)
{
    // Crystal clear, we get back a potentially different object
    UserProfile processedUser = SecurityService.ValidateAndProcessUser(user);

    // No surprises here, we know exactly what we're checking
    if (!processedUser.Permissions.Contains("BasicAccess"))
    {
        // Now we can reason about this code
    }
}

public class ConfigManager
{
    private readonly ImmutableDictionary<string, string> _settings;

    public ConfigManager(ImmutableDictionary<string, string> settings)
    {
        // No need to make a copy -> it can't be changed anyway
        _settings = settings;
    }

    public ImmutableDictionary<string, string> GetSettings()
    {
        // Safe to return the actual instance -> nothing can mess it up
        return _settings;
    }
}

var original = ImmutableDictionary<string, int>.Empty
    .Add("one", 1)
    .Add("two", 2)
    .Add("three", 3);

// This doesn't copy the whole dictionary -> just the changed part
var modified = original.SetItem("two", 22);

// Both versions work exactly as you'd expect
Console.WriteLine(original["two"]);    // 2
Console.WriteLine(modified["two"]);    // 22

public class DataProcessor
{
    private readonly Dictionary<string, ImmutableList<Result>> _cache
        = new Dictionary<string, ImmutableList<Result>>();

    public ImmutableList<Result> ProcessData(string key, ImmutableList<DataPoint> data)
    {
        // Safe caching with no worries about someone changing the cached results
        if (_cache.TryGetValue(key, out var results))
        {
            return results;
        }

        // Process and cache
        var newResults = DoExpensiveCalculation(data);
        _cache[key] = newResults;
        return newResults;
    }
}

public void ProcessOrder(Order order)
{
    try
    {
        // Each step produces a new state that's easy to track
        var validated = _validator.Validate(order);
        var priced = _pricingService.CalculateTotals(validated);
        var processed = _paymentProcessor.Process(priced);
        var completed = _fulfillmentService.Schedule(processed);

        // We know exactly what state we're logging
        _logger.LogInfo($"Order {completed.Id} processed successfully");
    }
    catch (Exception ex)
    {
        // The original order is still intact for troubleshooting
        _logger.LogError($"Failed to process order {order.Id}: {ex.Message}");

        // No need to worry if something changed the order during processing
    }
}

[Fact]
public void PremiumCustomer_Gets20PercentDiscount()
{
    // Arrange
    var customer = new Customer("John", CustomerTier.Premium, 5);
    var order = new Order(
        id: "12345",
        items: ImmutableList.Create(
            new OrderItem("Product1", 100.0m, 2),
            new OrderItem("Product2", 50.0m, 1)
        ),
        customer: customer
    );

    // Act
    var discountedOrder = _discountService.ApplyDiscounts(order);

    // Assert
    Assert.Equal(200.0m, order.Subtotal);           // Still exactly what we created
    Assert.Equal(160.0m, discountedOrder.Subtotal); // New object with the discount
}

[Theory]
[InlineData(CustomerTier.Regular, 0)]
[InlineData(CustomerTier.Gold, 10)]
[InlineData(CustomerTier.Premium, 20)]
public void Discount_Varies_By_CustomerTier(
    CustomerTier tier, int expectedDiscountPercentage)
{
    // This test customer won't change between test runs
    var customer = new Customer("Test", tier, 1);

    // Act
    var discount = _discountCalculator.GetDiscountPercentage(customer);

    // Assert
    Assert.Equal(expectedDiscountPercentage, discount);
}