Защо типовете числа в C# са неизменни?

Първо:

Каква е целта на връщането на нов обект всеки път, когато искате да промените стойността?

Мисля, че може да грешите за това как работят типовете стойности. Това не е някаква скъпа операция, както може би си представяте; това е просто презаписване на данни (за разлика от, например, динамично разпределение на нова памет).

Второ: ето един много прост пример защо числата са неизменни:

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 cloud дни наред на 32 основни сървъра. При профилиране на приложението най-големият проблем с производителността е разпределението на двойно!! Би било честно да има специално пространство от имена с променливи типове. "небезопасни" ключови думи могат да бъдат наложени за допълнителна предпазна мярка.