Unable to understand how boxing is done

Question

I was studying boxing and unboxing.

I went through this example, I am unable to understand the answer.

Can anyone explain to me please.

I know what boxing and unboxing does now, by looking at a simple example, but this example, confuses a bit.

An example of boxing and then unboxing, a tricky example.

[struct|class] Point {
    public int x, y;    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}    
Point p = new Point(1, 1);
object o = p; p.x = 2;
Console.WriteLine(((Point)o).x);

I read the answer as:

It depends! If Point is a struct then the output is 1 but if Point is a class then the output is 2! A boxing conversion makes a copy of the value being boxed explaining the difference in behavior.

Here is ((point)o).x a boxing or unboxing?

Didn't understand, can anyone explain to me please.

I know that the answer should come 1, but if class then how 2?

Answer 1

I don't know why everyone is writing an essay, it's pretty simple to explain:

• When you cast a struct into object, it is copied into a new object.

• When you cast an object into a struct, it is copied into a new struct.

• When you cast between classes, the object's contents are not copied; only the reference is copied.

Hope that helps.

Answer 2

Although C# tries to pretend that structure types derive from Object, that's only half true. According to the CLI spec, a structure type specification actually defines two kinds of thing: a type of heap object which derives from System.ValueType (and in turn System.Object), and a kind of storage location (local variable, static variable, class field, struct field, parameter, or array slot) which does not derive from anything, but is implicitly convertible to the heap object type.

Every heap object instance contains all the fields defined by the type or its parent classes (if any), along with a header which identifies its type and some other information about the instance. Every struct-type storage location contains either the bytes necessary to hold its value (if a primitive type), or else holds the concatenated values of all its fields; in neither case does it contain any sort of header that identifies its type. Instead, value types rely upon information in the generated code to know what they are.

If one stores a value type to a storage location of that value type, the compiler will overwrite all the bytes occupied by the destination with values taken from the original value type. If, however, one tries to store a value type to a reference-type storage location (like Object), the runtime will generate a new heap object with enough space to hold all the data from the value type, along with a header identifying its type, and store in the destination location a reference to that new object. If one tries to typecast a reference type to a value type, the runtime will first verify that the object is of the proper type and, if so, copy the data from the heap object to the destination.

There are a couple of tricky scenarios involving interfaces and generics. Interface types are reference types, but if a struct implements an interface, the implementing methods may act directly upon a boxed struct instance without having to unbox and rebox it. Further, interface types used as generic constraints do not require boxing. If one passes a variable of a value type like List<int>.Enumerator to a function EnumerateThings<TEnumerator>(ref TEnumerator it) where TEnumerator: IEnumerator<int>, that method will be able to accept a reference to that variable without boxing.

Answer 3

Since Point is Struct and Structs are value types which means they are copied when they are passed around.

So if you change a copy you are changing only that copy, not the original.

However if Point was a class, then it was passed by reference.

So if you change a copy you are changing only that copy and also the original.

As for your confusion

object o = p; is boxing

whereas

(Point)o is unboxing

Answer 4

To understand boxing you need to understand the difference between Value types and Reference types.

I think the simplest way to understand it is:

"Value types are allocated in-line. Reference types are always allocated on the Heap"

meaning, that if you add a value type (struct, int, float, bool) inside of a reference-type as a class variable (public or private), that value-type's data is embedded wherever that reference-type lives on the Heap.

If you create a value-type inside of a function, but do NOT assign it to a public/private variable, that value-type is allocated in the Function-Stack (meaning once you leave that function it will get collected)

So, given that background knowledge, it should be pretty self-explanatory what happens when you "box" a value-type: you have to take that value type (wherever it was in-line allocated) and turn it into a reference-type (create a new object for it on the Heap).

Answer 5

First you need to know where objects are stored. Structs, enums and other value types are stored on the stack, in registers, or on the heap; classes and other reference types are stored on the heap. A good tutorial is here.

Boxing is done when a value type is being stored in a heap. A copy is being made from stack to heap. Unboxing is the other way around, a copy of a value will be made from heap to stack.

   1 Point p = new Point(1, 1);
   2 object o = p; 
   3 p.x = 2;
   4 Console.WriteLine(((Point)o).x);

In your code above, if Point is a struct, a copy will be made to object "o". On your line 3, what you modified is is the Point in stack. On the last line you unboxed the object "o" but the value you will get is the copied value from the heap.

If the Point is class, in line 1, a space is created for the Point in the heap. Line 2, creates a new variable "o" that references to the same memory space. Remember that "p" & "o" are referencing on the same memory address location, so if you modify any of the variable just like in line 3, you will get the modified value on both variable.