Почему в var a = new int[1] {5} нет упаковки?

Question

[footballer]

Говорят, что упаковка - тяжелая операция из-за того, что структура копируется из стека в кучу.
В качестве примера упаковки приводят такой код:
var a = new object[1] {5};
то есть когда мы int помещаем в массив object-ов.
Но ведь даже если мы создаем массив int-ов так:
var a = new int[1] {5} ;
то все-равно наш int 5 должен скопироваться в кучу, т.к. память под массив выделяется в куче. Но почему в этом случае не считается, что это не упаковка, и считается, что это не тяжелая операция?

Answer 1

[eRKa]

Я, думаю, Вы что-то не так поняли. Массив, это ссылочный тип и в случае
var a = new int[1] {5}
значение переменной a будет лежать в стеке, но значением будет ссылка на место в куче, указывающая на массив интов. Тоже самое касается и
a = new object[1] {5}

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

int a = 5;
var b = (object)a;

В первой строке мы положили в стек пятерку, а во второй эту пятерку мы помещаем в кучу. Переменная b будет лежать в стеке, значение которой будет указывать на адрес в куче, где лежит тип object, со значением value равным 5. И то, что у объекта поле будет интовое, не означает, что оно будет в стеке.

Comments

[footballer]

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

Так в этом случае в первой строке мы тоже сначала выделяем память под инт в стеке и и присваиваем туда значение 42, а во второй строке мы КОПИРУЕМ значение инта в кучу в область памяти, выделенную под массив, почему тогда это не считается медленной упаковкой, раз есть копирование?

int i = 42;
myIntegers[0] = 42;

[eRKa]

footballer, во второй строке мы не копируем значение из стека. myIntegers это ссылочный тип, т.к. массив. В куче будет выделен неприрывный кусок памяти под значения int и 42 будет хранится в куче как часть массива. Это при условии, что myIntegers объявлялся как int[] myIntegers, в общем упаковки не будет.

Упаковка, это когда значимый тип приводится к более общему типу и затратный он, потому что нужно создать объект, выделить под него память в куче и туда копирнуть это значение. Вот если будет так object[] myIntegers, тогда при myIntegers[0] = i произойдет упаковка значения 42 в object.

PS Вот ссылка, мне кажется там все очень доходчиво.

[eRKa]

footballer,

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

Я не совсем точно сформулировал. Упаковка не просто копирование, это создание оболочки для значения.

[footballer]

>. В куче будет выделен неприрывный кусок памяти под значения int и 42 будет хранится в куче как часть массива.

Это я понимаю. Но разве при добавлении в массив интов значения переменной инт из стэка не происходит копирование значения этой стэковой переменной в память массива? По-моему, как раз таки должно быть такое копирование. Поэтому это я не понимаю:

>во второй строке мы не копируем значение из стека

почему не копируем?

>Упаковка не просто копирование, это создание оболочки для значения.

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

В общем, я так и не понял причин, почему int[] намного быстрее , чем object[]

>При упаковке типа значения в куче выделяется экземпляр объекта и выполняется копирование значения в этот новый объект.

Для int[] в куче тоже должно выполняться копирование значения из стэка в сам массив.

[eRKa]

footballer,
1) Копирование происходит, но не происходит алокации (выделения памяти в куче под объект), а это затратно по вычислениям.

myIntegers[0] = 42; // значения 42 в стеке нет, оно сразу уходит в кучу как значение массива.

Чтобы было копирование из стека, надо сделать так

int a = 42;  // положили в стек
myIntegers[0] = a; // скопировали из стека в выделенное место в куче, упаковки нет, лишних алокаций нет.
myObjects[0] = a; //  выделили место в куче под object, создали экземпляр object, в него скопировали значение a, в массив, с нулевым смещением, занесли ссылку на этот экземпляр.

[footballer]

eRKa,

>Чтобы было копирование из стека, надо сделать так
int a = 42; // положили в стек
myIntegers[0] = a; // скопировали из стека в выделенное место в куче, упаковки нет, алокаций нет.

Получается, что в упаковку не входит копирование? Но ведь чаще всего пишут, что именно из-за копирования упаковка медленная? Но тут получается, что копирование из стэка в кучу на самом деле не медленная операции, что противоречит многим статьям в инете. Да и чисто логически, структура может содержать тысячи полей с итн/лонг и т.д, т.е. иметь большой размер, тогда копирование в myInteger[] уж точно должно быть медленным.

>но не происходит алокации (выделения памяти в куче под объект), а это затратно по вычислениям.

Если выделение памяти в куче под объект затратно, тогда нужно вообще стараться как можно реже создавать экземпляры типов по ссылке, но про это же никто не говорит.

[eRKa]

footballer, Вы зациклились вообще не понять на чем. В любой статье говорится, что упаковка, это создание объекта-оболочки над значимым типом. Упаковка затратна потому, что происходит алокация. Но нигде не говорится, что это запрещено. Нужно избегать ЛИШНИХ алокаций. Все четко и конкретно, чего Вам еще не хватает для понимания?))

Например спецом для этого создали дженерик списки. До этого были списки, которые внутри были типа object и при добавление и чтении постоянно происходил боксинг/анбоксинг, что было затратно по ресурсам. Вот в java настоящих дженериков нет до сих пор, и там как раз при использовании списков происходит упаковка/распаковка. Без этого, в java нормально сделать списки было бы не возможно.

И что значит "реже создавать экземпляры типов по ссылке"? Вообще C# это объектно ориентированный язык, в нем оперируют объектами, а не только значениями. Он таким создавался для упрощения и увеличения скорости разработки, и для упрощенной поддержки кода. И выделение ресурсов в процессе выполнения программы, это нормальный естественный и неизбежный процесс.

Хотите чтобы все было в стеке? Ну пишите в процедурном стиле. И то алокаций в куче Вы не избежите, ибо весь .net это сплошной объект и состоит из кучи экземпляров других объектов.

В процессе работы над кодом не удастся избежать упаковок. Упаковка и распаковка, это нужные и полезные вещи в ООП. Просто нужно знать механизм и понимать, когда это ЛИШНЕЕ.

На этом прошу меня извинить, я откланяюсь, т.к. у меня складывается впечатление, что это будет бесконечно. Просто внимательно и вдумчиво еще раз прочитайте в литературе "матчасть" .net.