Почему числовые типы С# неизменяемы?

Во-первых:

Какова цель возврата нового объекта каждый раз, когда вы хотите изменить значение?

Я думаю, вы можете ошибаться в том, как работают типы значений. Это не какая-то дорогостоящая операция, как вы можете себе представить; это просто перезапись данных (в отличие, например, от динамического выделения новой памяти).

Во-вторых: вот очень простой пример того, почему числа неизменны:

5.Increase(1);
Console.WriteLine(5); // What should happen here?

Правда, это надуманный пример. Итак, давайте рассмотрим еще пару интересных идей.

Изменяемый ссылочный тип

Во-первых, вот что: что, если бы Integer был изменяемым ссылочным типом?

class Integer
{
    public int Value;
}

Тогда у нас может быть такой код:

class Something
{
    public Integer Integer { get; set; }
}

А также:

Integer x = new Integer { Value = 10 };

Something t1 = new Something();
t1.Integer = x;

Something t2 = new Something();
t2.Integer = t1.Integer;

t1.Integer.Value += 1;

Console.WriteLine(t2.Integer.Value); // Would output 11

Кажется, это противоречит интуиции: строка t2.Integer = t1.Integer просто скопирует значение (на самом деле так и есть, но это «значение» на самом деле является ссылкой) и, таким образом, t2.Integer останется независимым от t1.Integer.

Изменяемый тип значения

Конечно, к этому можно подойти и по-другому, сохранив Integer в качестве типа значения, но сохранив его изменчивость:

struct Integer
{
    public int Value;

    // just for kicks
    public static implicit operator Integer(int value)
    {
        return new Integer { Value = value };
    }
}

Но теперь допустим, что мы делаем это:

Integer x = 10;

Something t = new Something();
t.Integer = x;

t.Integer.Value += 1; // This actually won't compile; but if it did,
                      // it would be modifying a copy of t.Integer, leaving
                      // the actual value at t.Integer unchanged.

Console.WriteLine(t.Integer.Value); // would still output 10

По сути, неизменяемость значений — это очень интуитивно понятная вещь. Обратное очень неинтуитивно.

Я думаю, что это субъективно, хотя, если честно ;)

Целочисленные переменные являются изменяемыми. Однако целочисленные литералы являются константами, а значит, неизменяемыми.

int i = 0;

// Mutation coming!
i += 3;

// The following line will not compile.
3 += 7;

Целочисленное поле можно сделать неизменяемым, используя readonly. Точно так же целочисленное свойство может быть доступно только для чтения.

Как изменяемый объект, вы должны заблокировать переменную int перед ее изменением (в любом многопоточном коде, который записывает в ваш int из отдельных потоков).

Почему? Допустим, вы увеличивали int, например:

myInt++

Под капотом это 32-битное число. Теоретически на 32-битном компьютере к нему можно добавить 1, и эта операция может быть атомарной; то есть это будет выполнено за один шаг, потому что это будет выполнено в регистре ЦП. К сожалению, это не так; происходит нечто большее, чем это.

Что, если другой поток изменит это число, пока оно находится в процессе увеличения? Ваш номер будет поврежден.

Однако, если вы сделаете потокобезопасную копию вашего объекта перед его увеличением, будете работать с вашей потокобезопасной копией и вернете новый объект после завершения инкремента, вы гарантируете, что ваше приращение будет потокобезопасным; на него не могут повлиять никакие операции с исходным объектом, выполняемые в других потоках, поскольку вы больше не работаете с исходным объектом. По сути, вы сделали свой объект неизменным.

Это основной принцип функционального программирования; делая объекты неизменяемыми и возвращая новые объекты из функций, вы бесплатно получаете потокобезопасность.

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

Однако целые числа сами по себе не являются переменными, поэтому их нельзя изменять.

Все, что имеет семантику значений, должно быть неизменным в C#.

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

MyClass o1=new MyClass();
MyClass o2=o1;
o1.Mutate();
//o2 got mutated too
//=> no value but reference semantics

Изменяемые структуры уродливы, потому что вы можете легко вызвать изменяющий метод для временной переменной. В частности, свойства возвращают временные переменные.

MyStruct S1;
MyStruct S2{get;set;}

S1.Mutate(); //Changes S1
S2.Mutate();//Doesn't change S2

Вот почему мне не нравится, что большинство векторных библиотек используют мутирующие методы, такие как Normalize, в своей векторной структуре.

Я работаю над академическим проектом с нейронными сетями. Эти сети выполняют тяжелые вычисления с двойниками. Я запускаю его в облаке Amazon в течение нескольких дней на 32 основных серверах. При профилировании приложения главной проблемой производительности является выделение двойного!! Было бы справедливо иметь выделенное пространство имен с изменяемыми типами. В качестве дополнительной меры предосторожности можно использовать «небезопасные» ключевые слова.