CODEWITHSUNDEEP
c#.netstructurects
CSharp4eto
CSharp4eto

Reputation: 147

Common Type System - Structures

i am stuck in programming terminology here, which is getting me confused and i cannot gather my thoughts on how to actually and correctly express(write) these few MSDN theory sentences from the Common Type System page.

Would anyone help me on this one, i want to understand this! And if someone would be so kind to write some code and comment on this issue, it would be awesome and praiseworthy of you!

//This is the text(it is taken from the "Structures" paragraph): https://msdn.microsoft.com/en-us/library/zcx1eb1e(v=vs.110).aspx#

"For each value type, the common language runtime supplies a corresponding boxed type, which is a class that has the same state and behavior as the value type. An instance of a value type is boxed when it is passed to a method that accepts a parameter of type System.Object. It is unboxed (that is, converted from an instance of a class back to an instance of a value type) when control returns from a method call that accepts a value type as a by-reference parameter. Some languages require that you use special syntax when the boxed type is required; others automatically use the boxed type when it is needed. When you define a value type, you are defining both the boxed and the unboxed type."

Thank You in advance, best regards!

Upvotes: 0

Views: 464

Answers (2)

GTRekter
GTRekter

Reputation: 1007

.NET is language agnostic which allows programmers to write code in different languages (which can be compiled to IL), and that code can interact with other code written in different languages.

This feature is provided by the CTS (Common Type System), a standard that specifies how type definitions are represented in the memory and how types are declared, used, and managed in the CLR (Common Language Runtime).

Example

C# has an int data type and VB.NET has a Integer data type. After the compilation, both instances of int and Integer will use the same structure Int32 from CTS.

enter image description here

Upvotes: 0

Scott Hannen
Scott Hannen

Reputation: 29222

An object and a value type are stored differently. An object is a pointer to memory in the heap which contains the binary representation of that object. The stack is memory allocated to store pointers and value types. So a function doesn't have a pointer to an integer or bool. It is passed a copy of the actual value.

But if you have a method like this:

string GetString(object o)
{
    return o.ToString();
}

That method expects an object, a pointer to a location in memory, even if you pass a value type to it. So in order to do that, the framework has to create an object stored on the heap containing that int so that it can pass a reference (pointer) to that value to the function. That's boxing.

Boxing is implicit. You don't have to call some conversion function to convert an int to an object.

Unboxing occurs when you take that object and cast it as a value type. For example,

object x = 5;   //Boxes the value to create an object with a pointer
var y = (int)x; //Unboxes the value, creating an int on the stack.

When you unbox the object stored in the heap and referenced by x is inspected and its value retrieved. Unboxing is explicit. When you convert anything from object to a value type you must specify the type to which you are converting it.

Upvotes: 0

Related Questions