Variable X value

Values can be mutable or immutable, variables containing values are always, by definition, mutable. Variable refers to something that varies, that changes, that is changeable.

It is common for those who write about the subject to use a looser and not so academic language, which can lead to a misinterpretation even. You're right in doubt. It is rare who writes with all the specified details as correctly as possible in these cases. And that's what I did there in the question. That is why this new question is up. So if someone says "the variable x is immutable", read"the contents of the variable x is immutable".

Constants

Just like a constant, by definition, is immutable. I would like to say that the values of the constant are also always immutable. In C# they are, but some languages have managed to let a constant have the mutable value. It's a conceptual mistake that C# didn't make.

At least C# makes it clear that PI and MaxValue of type int are constants. Whereas MaxThreads and PercentualDeDesconto are readonly, that is, they do not change during the entire execution of an application instance, but can change from one execution to another, or from one version to another. There are some other differences that do not come to the case now.

Struct X Class

It is highly recommended that structs have their immutable values. This is in the C#documentation. It is very strange to have an object for value let it be changeable. Technically it is possible because may exist some situation that this is really useful and correct.

Classthey are usually changeable. But they don't have to be. The largest example is string which is a type by reference but has value semantics, that is, its value is immutable.

But how? I can change the value of a string. I can do:

var s = "teste";
s = "mudei";

There was a change in the value of the variable and not the value of the string. You don't changed the text, you created a new text and changed the reference (which is in the variable) to this new text.

Immutability example

See this struct:

struct Point {
    public float X;
    public float Y;
}

It is changeable. You shouldn't. Why?

You can change the value of X and Y independently. You are changing the value itself and not the variable. And a struct should not allow that.

Isn't it strange to change a part of the point without it being another point?

struct Point {
    private int x;
    private int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

Already changes everything. The only way to change a value of the variable is to completely change the value contained in it. In this case you create a new value and allocate in the variable, you do not change the value allocated in it. Its use would be:

var p = new Point(2, 5);
// p.x = 7; seria um erro, você nem consegue acessar os membros individualmente.
p = new Point(7, 5);

Did you realize that you can't change just one member of the value? has to create a new value and associate that new value with the variable. This is immutability .

You change not only the value, you change the identity of it. Cartesian point 2.5 is different from point 7.5, it is not the same point with a different characteristic.

Note that adding public properties to access members x and y does not cause a problem. But if you allow assigning values to them, you fall into the same problem as the previous example of Point. Then you could create a property with only get.

Example of mutability

Now see this code:

struct Pessoa {
    public string nome; 
    public int idade;
    public Decimal salario;
    public DateTime CadastradaEm;
}

public class Exemplo {
    static void Main() {
        Pessoa p;
        p.nome = "João";
        p.idade = 18;
        Console.WriteLine("{0} tem {1} anos", p.nome, p.idade);
       
        p.idade = 20;
        Console.WriteLine("{0} tem {1} anos", p.nome, p.idade);
    }
}

Another problem

Leaving aside that this is exposing fields to external direct access (it's just a simplified example, I don't need to follow such "good practices" here), what's the problem with this code?

If this is a struct it should be immutable but this is not the error. The way it is, it is clearly a changeable object, you can change the members individually. No problem. That's probably what you want in this case.

If this structure has multiple fields, it becomes very large. Large objects do not look good on a struct. Finally struct s are copied by value. Copies of large objects are inefficient. So we already have two reasons, inefficiency and mutability to say that this should be a class. The error was to set this structure to struct instead of class. More details in this question .

Identity

In this example above despite changing the age of the person, the person is the same, the identity of the object is the same, so the object is changeable. Object characteristics can be changed without the object becoming something else. Even if you change the name from "John" to "Mary" (very common nowadays:)) it would still be the same person. A name can be changed by several factors, such as typo or change of marital status, just to name the most common.

When you use the code:

var i = 0;
i = 5;

Semantically is the same as saying:

var i = new Int32(0);
i = new Int32(5);

Int32 it is such struct that equals int. Note that each change in the value, you are creating a new object, with equivalent identity. By chance it is being "saved" in the same place, it is replacing the previous value, but not only the variable has changed, but its value as a whole has changed.

Then in the example:

int i = 0;
i++;

Is the same as:

int i = default(Int32); //só para mostrar outra forma de interpretar a mesma coisa
i = new Int32(i + 1);

Does not mean that the compiler interprets it exactly like that, but it is a way that helps to understand.

Note that the value of i is being changed as a whole, as per the definition I gave above.

Conclusion

Seems strange at first glance, but if you look at the variable itself and its value as distinct things it becomes easy to understand that the value never changes, it is exchanged for another.

The easiest way to understand immutability is to look at whether the change can occur in parts of the object (fields, properties, elements of a array , etc.) or if it can occur only in its whole.

Immutability does not need to fit any definition strict object orientation. It is a concept applied to any paradigm.

The subject is quite vast and is something that few understand correctly. I think I do not understand everything correctly. But here already has an important part about it.

More info (The question is about Java, but the idea is the same).

Exercise

Answer if a phone that has the DDD (area code) and the number itself, can exchange your DDD and stay with it identity? And can he switch carriers and keep his identity?

If you create a variable (of type) int with value 0 and then assign the value 0 in it, did it change the identity?

_{answers in the comment below}

I put on GitHub for future reference.