Почему компилятор c # в некоторых случаях выдает newobj / stobj, а не 'call instance .ctor' для инициализации структуры

Прежде всего, вы должны прочитать мою статью на эту тему. Он не касается вашего конкретного сценария, но содержит полезную справочную информацию:

https://ericlippert.com/2010/10/11/debunking-another-myth-about-value-types/

Хорошо, теперь, когда вы прочитали, что вы знаете, что спецификация C # утверждает, что создание экземпляра структуры имеет следующую семантику:

• Создайте временную переменную для хранения значения структуры, инициализированной значением структуры по умолчанию.
• Передайте ссылку на эту временную переменную в качестве this конструктора

Итак, когда вы говорите:

Foo foo = new Foo(123);

Это эквивалентно:

Foo foo;
Foo temp = default(Foo);
Foo.ctor(ref temp, 123); // "this" is a ref to a variable in a struct.
foo1 = temp;

Теперь вы можете спросить, зачем тратить время на выделение временного объекта, если у нас уже есть переменная foo, которая может быть this:

Foo foo = default(Foo);
Foo.ctor(ref foo, 123);

Эта оптимизация называется копированием. Компилятору C # и / или джиттеру разрешается выполнять исключение копии, когда они определяют с помощью своей эвристики, что это всегда невидимо. В редких случаях исключение копирования может вызвать заметное изменение в программе, и в этих случаях нельзя использовать оптимизацию. Например, предположим, что у нас есть структура из пары целых чисел:

Pair p = default(Pair);
try { p = new Pair(10, 20); } catch {}
Console.WriteLine(p.First);
Console.WriteLine(p.Second);

Мы ожидаем, что p здесь либо (0, 0), либо (10, 20), но никогда (10, 0) или (0, 20), даже если ctor выбрасывает на полпути. То есть, либо p было присвоено полностью сконструированное значение, либо p не было никаких изменений вообще. Копирование не может быть выполнено здесь; мы должны создать временное, передать временное в ctor, а затем скопировать временное в p.

Точно так же предположим, что у нас было это безумие:

Pair p = default(Pair);
p = new Pair(10, 20, ref p);
Console.WriteLine(p.First);
Console.WriteLine(p.Second);

Если компилятор C # выполняет исключение копирования, тогда this и ref p являются псевдонимами для p, что заметно отличается от того, если this является псевдонимом для временного! Контроллер мог заметить, что изменения в this вызывают изменения в ref p, если они являются псевдонимом одной и той же переменной, но не заметит этого, если они будут использовать псевдонимы для разных переменных.

Эвристика компилятора C # решает выполнить исключение копирования на foo1, но не на foo2 в вашей программе. Это значит увидеть, что в вашем методе есть ref foo2, и сразу же принять решение сдаться. Он мог бы провести более сложный анализ, чтобы определить, что это не в одной из этих безумных ситуаций с псевдонимом, но это не так. Самый дешевый и простой способ - просто пропустить оптимизацию, если есть хоть какой-то шанс, пусть даже маловероятный, что может возникнуть ситуация сглаживания, которая делает элизию видимой. Он генерирует newobj код и позволяет джиттеру решать, хочет ли он сделать исключение.

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

Это потому, что переменные foo1 и foo2 разные.

Переменная foo1 - это просто значение, а переменная foo2 является одновременно значением и указателем, поскольку она используется в вызове с ключевым словом ref.

Когда переменная foo2 инициализируется, указатель устанавливается так, чтобы указывать на значение, и конструктор вызывается со значением указателя, а не с адресом значения.

Если вы настроили два PrintFoo метода с той лишь разницей, что в одном есть ключевое слово ref, и вызываете их с одной переменной каждый:

Foo a = new Foo(10);
Foo b = new Foo(20);
PrintFoo(ref a);
PrintFoo(b);

Если декомпилировать сгенерированный код, разница между переменными видна:

&Foo a = new Foo(10);
Foo b = new Foo(20);
Program.PrintFoo(ref a);
Program.PrintFoo(b);