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

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

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

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

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

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

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

footballer,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

eRKa,

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

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

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

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

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

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

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

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

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

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