Immutable object pattern in C# - what do you think? [closed]

Answer 1

My problem with this pattern is that you're not imposing any compile-time restraints upon immutability. The coder is responsible for making sure an object is set to immutable before for example adding it to a cache or another non-thread-safe structure.

That's why I would extend this coding pattern with a compile-time restraint in the form of a generic class, like this:

public class Immutable where T : IElement
{
    private T value;

    public Immutable(T mutable) 
    {
        this.value = (T) mutable.Clone();
        this.value.MakeReadOnly();
    }

    public T Value 
    {
        get 
        {
            return this.value;
        }
    }

    public static implicit operator Immutable(T mutable) 
    {
        return new Immutable(mutable);
    }

    public static implicit operator T(Immutable immutable)
    {
        return immutable.value;
    }
}

Here's a sample how you would use this:

// All elements of this list are guaranteed to be immutable
List> elements = 
    new List>();

for (int i = 1; i < 10; i++) 
{
    SampleElement newElement = new SampleElement();
    newElement.Id = Guid.NewGuid();
    newElement.Name = "Sample" + i.ToString();

    // The compiler will automatically convert to Immutable for you
    // because of the implicit conversion operator
    elements.Add(newElement);
}

foreach (SampleElement element in elements)
    Console.Out.WriteLine(element.Name);

elements[3].Value.Id = Guid.NewGuid();      // This will throw an ImmutableElementException