The true definition of immutability?

I am wondering how immutability is defined? If the values aren't exposed as public, so can't be modified, then it's enough?

Can the values be modified inside the type, not by the customer of the type?

Or can one only set them inside a constructor? If so, in the cases of double initialization (using the this keyword on structs, etc) is still ok for immutable types?

How can I guarantee that the type is 100% immutable?

Answers


If the values aren't exposed as public, so can't be modified, then it's enough?

No, because you need read access.

Can the values be modified inside the type, not by the customer of the type?

No, because that's still mutation.

Or can one only set them inside a constructor?

Ding ding ding! With the additional point that immutable types often have methods that construct and return new instances, and also often have extra constructors marked internal specifically for use by those methods.

How can I guarantee that the type is 100% immutable?

In .Net it's tricky to get a guarantee like this, because you can use reflection to modify (mutate) private members.


The previous posters have already stated that you should assign values to your fields in the constructor and then keep your hands off them. But that is sometimes easier said than done. Let's say that your immutable object exposes a property of the type List<string>. Is that list allowed to change? And if not, how will you control it?

Eric Lippert has written a series of posts in his blog about immutability in C# that you might find interesting: you find the first part here.


One thing that I think might be missed in all these answers is that I think that an object can be considered immutable even if its internal state changes - as long as those internal changes are not visible to the 'client' code.

For example, the System.String class is immutable, but I think it would be permitted to cache the hash code for an instance so the hash is only calculated on the first call to GetHashCode(). Note that as far as I know, the System.String class does not do this, but I think it could and still be considered immutable. Of course any of these changes would have to be handled in a thread-safe manner (in keeping with the non-observable aspect of the changes).

To be honest though, I can't think of many reasons one might want or need this type of 'invisible mutability'.


Here is the definition of immutability from Wikipedia (link)

"In object-oriented and functional programming, an immutable object is an object whose state cannot be modified after it is created."

Essentially, once the object is created, none of its properties can be changed. An example is the String class. Once a String object is created it cannot be changed. Any operation done to it actually creates a new String object.


Lots of questions there. I'll try to answer each of them individually:

  • "I am wondering how immutability is defined?" - Straight from the Wikipedia page (and a perfectly accurate/concise definition)

    An immutable object is an object whose state cannot be modified after it is created

  • "If the values aren't exposed as public, so can't be modified, then it's enough?" - Not quite. It can't be modified in any way whatsoever, so you've got to insure that methods/functions don't change the state of the object, and if performing operations, always return a new instance.

  • "Can the values be modified inside the type, not by the customer of the type?" - Technically, it can't be modified either inside or by a consumer of the type. In pratice, types such as System.String (a reference type for the matter) exist that can be considered mutable for almost all practical purposes, though not in theory.

  • "Or can one only set them inside a constructor?" - Yes, in theory that's the only place where state (variables) can be set.

  • "If so, in the cases of double initialization (using the this keyword on structs, etc) is still ok for immutable types?" - Yes, that's still perfectly fine, because it's all part of the initialisation (creation) process, and the instance isn't returned until it has finished.

  • "How can I guarantee that the type is 100% immutable?" - The following conditions should insure that. (Someone please point out if I'm missing one.)

    1. Don't expose any variables. They should all be kept private (not even protected is acceptable, since derived classes can then modify state).
    2. Don't allow any instance methods to modify state (variables). This should only be done in the constructor, while methods should create new instances using a particular constructor if they require to return a "modified" object.
    3. All members that are exposed (as read-only) or objects returned by methods must themselves be immutable.

    Note: you can't insure the immutability of derived types, since they can define new variables. This is a reason for marking any type you wan't to make sure it immutable as sealed so that no derived class can be considered to be of your base immutable type anywhere in code.

Hope that helps.


I've learned that immutability is when you set everything in the constructor and cannot modify it later on during the lifetime of the object.


The definition of immutability can be located on Google .

Example:

immutable - literally, not able to change. www.filosofia.net/materiales/rec/glosaen.htm

In terms of immutable data structures, the typical definition is write-once-read-many, in other words, as you say, once created, it cannot be changed.

There are some cases which are slightly in the gray area. For instance, .NET strings are considered immutable, because they can't change, however, StringBuilder internally modifies a String object.


An immutable is essentially a class that forces itself to be final from within its own code. Once it is there, nothing can be changed. In my knowledge, things are set in the constructor and then that's it. I don't see how something could be immutable otherwise.


There's unfortunately no immutable keywords in c#/vb.net, though it has been debated, but if there's no autoproperties and all fields are declared with the readonly (readonly fields can only bet assigned in the constructor) modfier and that all fields is declared of an immutable type you will have assured your self immutability.


An immutable object is one whose observable state can never be changed by any plausible sequence of code execution. An immutable type is one which guarantees that any instances exposed to the outside world will be immutable (this requirement is often stated as requiring that the object's state may only be set in its constructor; this isn't strictly necessary in the case of objects with private constructors, nor is it sufficient in the case of objects which call outside methods on themselves during construction).

A point which other answers have neglected, however, is a definition of an object's state. If Foo is a class, the state of a List<Foo> consists of the sequence of object identities contained therein. If the only reference to a particular List<Foo> instance is held by code which will neither cause that sequence to be changed, nor expose it to code that might do so, then that instance will be immutable, regardless of whether the Foo objects referred to therein are mutable or immutable.

To use an analogy, if one has a list of automobile VINs (Vehicle Identification Numbers) printed on tamper-evident paper, the list itself would be immutable even though cars aren't. Even if the list contains ten red cars today, it might contain ten blue cars tomorrow; they would still, however, be the same ten cars.


Need Your Help

System.Net.Http could not be resolved in the currently targeted framework .NET 4.0

asp.net asp.net-mvc msbuild cruisecontrol.net

Got a nasty error after moving a solution from Visual Studio 2010 to 2012. Build is fine and everything works perfect localhost. I have one new MVC4 project that requires .NET 4.5 so I installed th...