CODEWITHSUNDEEP
c#.netimmutability
Biswanath
Biswanath

Reputation: 9185

How do I create an immutable Class?

I am working on creating an immutable class.
I have marked all the properties as read-only.

I have a list of items in the class.
Although if the property is read-only the list can be modified.

Exposing the IEnumerable of the list makes it immutable.
I wanted to know what is the basic rules one has to follow to make a class immutable ?

Upvotes: 129

Views: 66551

Answers (8)

KUTlime
KUTlime

Reputation: 8017

All you need is L... Ehm record and C# 9.0 or newer.

public record Customer(string FirstName, string LastName, IEnumerable<string> Items);

//...

var person = new Customer("Test", "test", new List<string>() { "Test1", "Test2", "Test3" });
// you can't change anything within person variable
// person.FirstName = "NewName";

This gets translated into immutable class called Customer with three properties, FirstName, LastName and Items.

If you need an immutable (a read-only) collection as a property of the class, it is better to expose it as IEnumerable<T> or ReadOnlyCollection<T> than something from System.Collections.Immutable

Upvotes: 9

Eric Wood
Eric Wood

Reputation: 361

The original question and answer date from the end of 2008, there is now a System.Collections.Immutable namespace that I believe dates from the earliest .NET Core (1.0) . The namespace is still not available in .NET Standard (current version 2.1) and .NET framework (current version 4.8). This namespace has lots of immutable collections including the ImmutableList, which is asked about in the original question. However, I believe the System.Collections.Immutable namespace may appear in .NET 5 which is at release candidate 2 at the moment.

Also, starting with C# 6 you can have immutable auto-implemented properties using just { get; } .

Upvotes: 1

Imad
Imad

Reputation: 7490

Using ReadOnlyCollection will restrict client from modifying it.

Upvotes: 2

mbillard
mbillard

Reputation: 38842

Use the ReadOnlyCollection class. It's situated in the System.Collections.ObjectModel namespace.

On anything that returns your list (or in the constructor), set the list as a read-only collection.

using System.Collections.ObjectModel;

...

public MyClass(..., List<ListItemType> theList, ...)
{
    ...
    this.myListItemCollection= theList.AsReadOnly();
    ...
}

public ReadOnlyCollection<ListItemType> ListItems
{
     get { return this.myListItemCollection; }
}

Upvotes: 5

Andrew
Andrew

Reputation: 12009

Another option would be to use a visitor pattern instead of exposing any internal collections at all.

Upvotes: 2

Blair Conrad
Blair Conrad

Reputation: 241790

I think you're on the right track -

  • all information injected into the class should be supplied in the constructor
  • all properties should be getters only
  • if a collection (or Array) is passed into the constructor, it should be copied to keep the caller from modifying it later
  • if you're going to return your collection, either return a copy or a read-only version (for example, using ArrayList.ReadOnly or similar - you can combine this with the previous point and store a read-only copy to be returned when callers access it), return an enumerator, or use some other method/property that allows read-only access into the collection
  • keep in mind that you still may have the appearance of a mutable class if any of your members are mutable - if this is the case, you should copy away whatever state you will want to retain and avoid returning entire mutable objects, unless you copy them before giving them back to the caller - another option is to return only immutable "sections" of the mutable object - thanks to @Brian Rasmussen for encouraging me to expand this point

Upvotes: 132

lubos hasko
lubos hasko

Reputation: 25052

Also, keep in mind that:

public readonly object[] MyObjects;

is not immutable even if it's marked with readonly keyword. You can still change individual array references/values by index accessor.

Upvotes: 12

to StackOverflow
to StackOverflow

Reputation: 124696

To be immutable, all your properties and fields should be readonly. And the items in any list should themselves be immutable.

You can make a readonly list property as follows:

public class MyClass
{
    public MyClass(..., IList<MyType> items)
    {
        ...
        _myReadOnlyList = new List<MyType>(items).AsReadOnly();
    }

    public IList<MyType> MyReadOnlyList
    {
        get { return _myReadOnlyList; }
    }
    private IList<MyType> _myReadOnlyList

}

Upvotes: 21

Related Questions