1. The contents of a value type are copied from the stack into the memory allocated on the managed heap
   
2. Memory is copied from the managed heap to the stack
   
3. All the local variables within a function are unboxed from a class
   
4. All the variables within a function are unboxed from a class

object o = 3;
int x = (int)o;//распаковка
int y = (int)o;//распаковка
x = x + 1;
Console.WriteLine(y);//Выведет 3

M>object o = 3;
M>int x = (int)o;//распаковка
M>int y = (int)o;//распаковка
M>x = x + 1;
M>Console.WriteLine(y);//Выведет 3
M>

int x = 3;
int y = 3;
x = x + 1;
Console.WriteLine(y);//Выведет 3

Now that you know how boxing works, let’s talk about unboxing. Let’s say that you want to grab the first element out of the ArrayList by using the following code:

Point p = (Point) a[0];

Here you’re taking the reference (or pointer) contained in element 0 of the ArrayList and trying to put it into a Point value type instance, p. For this to work, all of the fields contained in the boxed Point object must be copied into the value type variable, p, which is on the thread’s stack. The CLR accomplishes this copying in two steps. First, the address of the Point fields in the boxed Point object is obtained. This process is called unboxing. Then, the values of these fields are copied from the heap to the stack-based value type instance.

Unboxing is not the exact opposite of boxing. The unboxing operation is much less costly than boxing. Unboxing is really just the operation of obtaining a pointer to the raw value type (data fields) contained within an object. In effect, the pointer refers to the unboxed portion in the boxed instance. So, unlike boxing, unboxing doesn’t involve the copying of any bytes in memory. Having made this important clarification, it is important to note that an unboxing operation is typically followed by copying the fields.

Подтянться 50 раз — легче легкого. Это делается за 2 шага. Сначала просто подходишь к перекладине, протягиваешь руки и хватаешься за нее. Это называется "подтягивание". Потом 50 раз тянешь свою тушку вверх.

Point p = (Point) a[0];

var x = ((Point) a[0]).X;

Point p = (Point) a[0];

var x = ((Point) a[0]).X;

object p = new Point(1, 1);
int x = ((Point)p).X;

.method private hidebysig static void Main(string[] args) cil managed
{
    .entrypoint
    .maxstack 3
    .locals init (
        [0] object p,
        [1] int32 x,
        [2] valuetype [System.Drawing]System.Drawing.Point CS$0$0000)
    L_0000: nop 
    L_0001: ldc.i4.1 
    L_0002: ldc.i4.1 
    L_0003: newobj instance void [System.Drawing]System.Drawing.Point::.ctor(int32, int32)
    L_0008: box [System.Drawing]System.Drawing.Point
    L_000d: stloc.0 
    L_000e: ldloc.0 
    L_000f: unbox.any [System.Drawing]System.Drawing.Point
    L_0014: stloc.2 
    L_0015: ldloca.s CS$0$0000
    L_0017: call instance int32 [System.Drawing]System.Drawing.Point::get_X()
    L_001c: stloc.1 
    L_001d: ret 
}

#include "stdafx.h"

using namespace System;

value struct Point
{
    int X,Y;
    Point(int x, int y):X(x),Y(y){}
};

int main(array<System::String ^> ^args)
{
    Point a(1,2);
    Object ^ o = a;

    dynamic_cast<Point^>(o)->X=42;
}

.method assembly static int32 main(string[] args) cil managed
{
    .maxstack 3
    .locals (
        [0] object o,
        [1] valuetype Point a)
    L_0000: ldnull 
    L_0001: stloc.0 
    L_0002: ldloca.s a
    L_0004: ldc.i4.1 
    L_0005: ldc.i4.2 
    L_0006: call instance void Point::.ctor(int32, int32)
    L_000b: ldloc.1 
    L_000c: box Point
    L_0011: stloc.0 
    L_0012: ldloc.0 
    L_0013: isinst Point
    L_0018: unbox Point
    L_001d: ldc.i4.s 0x2a
    L_001f: stfld int32 Point::X
    L_0024: ldc.i4.0 
    L_0025: ret 
}