Question

A few weeks ago, I discovered that strings in C# are defined as reference types and not value types. Initially I was confused about this, but then after some reading, I suddenly understood why it is important to store strings on the heap and not the stack – because it would be very inefficient to have a very large string that gets copied over an unpredictable number of stack frames. I completely accept this.

I feel that my understanding is almost complete, but there is one element that I am missing – what language feature do strings use to keep them immutable? To illustrate with a code example:

string valueA = "FirstValue";
string valueB = valueA;
valueA = "AnotherValue";

Assert.AreEqual("FirstValue", valueB); // Passes

I do not understand what language feature makes a copy of valueA when I assign it to valueB. Or perhaps, the reference to valueA does not change when I assign it to valueB, only valueA gets a new reference to itself when I set the string. As this is an instance type, I do not understand why this works.

I understand that you can overload, for example, the == and != operators, but I cannot seem to find any documentation on overloading the = operators. What is the explanation?

Answer 1

what language feature do strings use to keep them immutable?

It is not a language feature. It is the way the class is defined.

For example,

class Integer {
    private readonly int value;

    public int Value { get { return this.value; } }
    public Integer(int value) { this.value = value; } }
    public Integer Add(Integer other) {
        return new Integer(this.value + other.value);
    }
}

is like an int except it’s a reference type, but it’s immutable. We defined it to be so. We can define it to be mutable too:

class MutableInteger {
    private int value;

    public int Value { get { return this.value; } }
    public MutableInteger(int value) { this.value = value; } }
    public MutableInteger Add(MutableInteger other) {
        this.value = this.value + other.value;
        return this;
    } 
}

See?

I do not understand what language feature makes a copy of valueA when I assign it to valueB.

It doesn’t copy the string, it copies the reference. strings are reference type. This means that variables of type strings are storage locations whose values are references. In this case, their values are references to instances of string. When you assign a variable of type string to another of type string, the value is copied. In this case, the value is a reference and it is copied by the assignment. This is true for any reference type, not just string or only immutable reference types.

Or perhaps, the reference to valueA does not change when I assign it to valueB, only valueA gets a new reference to itself when i set the string.

Nope, the values of valueA and valueB refer to the same instance of string. Their values are references, and those values are equal. If you could somehow mutate^* the instance of string referred to by valueA, the referrent of both valueA and valueB would see this mutation.

As this is an instance type, I do not understand why this works.

There is no such thing as an instance type.

Basically, strings are reference types. But string are immutable. When you mutate a string, what happens is that you get a reference to a new string that is the result of the mutation to the already existing string.

string s = "hello, world!";
string t = s;
string u = s.ToUpper();

Here, s and t are variables whose values refer to the same instance of string. The referrent of s is not mutated by the call to String.ToUpper. Instead, s.ToUpper makes a mutation of the referrent of s and returns a reference to a new instance of string that it creates in the process of apply the mutation. We assign that reference to u.

I understand that you can overload, for example, the == and != operators, but I cannot seem to find any documentation on overloading the = operators.

You can’t overload =.

^* You can, with some tricks. Ignore them.