Какую роль играет неизменяемость строк в объяснении ссылок на строки для разработчиков?

Роль, которую играет утверждение в объяснении, зависит от самого объяснения. Это может быть вредным или полезным, в зависимости от остальной части объяснения.

Лично я бы не стал использовать это утверждение до довольно поздних объяснений (по крайней мере, в наши дни). Неизменяемость строк просто несколько мешает - как это происходит с объяснениями передачи параметров. Я бы начал с объяснения, используя изменяемый класс, например:

House x = new House(Color.Green); // The has a green front door
House y = x;
x = new House(Color.Red);
Console.WriteLine(y.FrontDoorColor); // Still green!

Здесь я бы объяснил, что x и y это как бумажки с адресами домов. Присваивание во второй строке не копирует дом — копирует адрес дома. Присваивание в третьей строке не меняет цвет входной двери в первом доме — оно создает новый дом, а затем стирает адрес на первой части бумаги (x) и пишет новый адрес. Это ничего не меняет ни в первом доме, ни во втором листе бумаги (y).

Затем я бы создал второй пример:

House x = new House(Color.Green); // The has a green front door
House y = x;
x.FrontDoorColor = Color.Red; // Repainting a front door
Console.WriteLine(y.FrontDoorColor); // Red!

На этот раз есть только один дом — если я покрашу дверь дома, и вы придете посмотреть на нее с адресом, который я дал вам ранее, вы увидите, что входная дверь теперь красная.

Все идет нормально. Теперь я мог бы вернуться к исходному примеру и сказать, что он уже выглядит как первый фрагмент дома, а не как второй, поэтому ведет себя точно так же. Затем я могу сказать, что неизменяемость строк означает, что вы даже не можете написать код, похожий на второй пример дома, но использующий строки. Таким образом, неизменяемость строк не была бы сразу актуальной для объяснения существующего кода, но все равно появилась бы в том же ответе.

(Я также должен указать, что, хотя ссылки ведут себя как адреса реального мира, я не утверждаю, что они такие же, как «адреса памяти» или указатели. Они не должны быть. Я использую этот термин в строгая аналогия с реальным миром, и все. Это минус примера, но я не думаю, что это сильно вредит.)

Я мог бы затем также поговорить о типах значений и рассмотреть, что произошло бы, если бы House был типом значения, а также не одобрять изменяемые типы значений.

Чтобы узнать, будет ли мой ответ актуален в языке с изменяемыми строками, нам нужно больше узнать о том, как ведут себя строковые литералы. Язык, который был бы таким же, как C# во всех отношениях, за исключением изменчивости строк, был бы ужасным языком, как вы могли бы написать:

// Hypothetical bad language
string x = "dog";
x.MutateTo("cat");
Console.WriteLine("dog"); // Prints cat!

Это явно нежелательно, поэтому, по-видимому, поведение строковых литералов должно измениться. Вы также говорите о возможных изменениях значения оператора присваивания и т. д. Трудно делать конкретные заявления о гипотетическом языке, не зная точно, как он себя ведет.

Это связано с тем, что знак равенства в компьютерном программировании является скорее оператором присваивания, чем условием «математического равенства». То, что строка неизменяема, не имеет к этому никакого отношения. Все дело в том, что знак равенства является оператором «присваивания», а не ограничением математической эквивалентности.

Это означает, что А = В; и В = С; не означает, что A = C;

вместо этого это означает

A было установлено, чтобы ссылаться на значение B, поэтому значение B теперь является значением A. B был установлен для ссылки на значение C, поэтому значение C теперь является значением B, но значение A остается неизменным.

Если бы строки не были неизменяемыми

String myString = "Hello";
myString.replace(3, "p"); // replace starting at char #3 (the second 'l')
System.out.println(myString); // would print "Help"

Но поскольку строки неизменяемы;

String myString = "Hello";
myString.replace(3, "p"); // returns a new string "help" which is not assigned to anything
// since the newly returned string was not assigned to anything, it was garbage collected
System.out.println(myString); // would print "Hello"

Объяснение в том, что этот пример не имеет ничего общего с неизменностью.

У вас есть две переменные, первоначально содержащие одно и то же значение, что для строки означает, что они указывают на один и тот же объект в памяти. Затем вы меняете значение одной из переменных и указываете его на другой объект в памяти.

Это ничем не отличается от того, чтобы сказать

int a = 4;
int b = a;
a = 5; 

Or

string x = "Foo";
string y = x;
x = "Bar";

Or

Foo foo = new Foo() { Bar = 42 };
Foo otherFoo = foo;
foo = new Foo() { Bar = 17; }

Переменные на мгновение ссылаются на одно и то же. В остальном они неразрывно связаны на все времена. Как только вы указываете одному на что-то другое, их общность заканчивается.