Click here to Skip to main content
15,612,441 members
Articles / Programming Languages / C#
Posted 27 Apr 2010

Tagged as


659 bookmarked

Six Important .NET Concepts: Stack, Heap, Value Types, Reference Types, Boxing, and Unboxing

Rate me:
Please Sign up or sign in to vote.
4.90/5 (434 votes)
23 Jun 2021CPOL7 min read
An introduction to stack, heap, value types, reference types, boxing, and unboxing
In this article, you will learn about what happens internally when you declare a variable followed by an explanation of two important concepts: stack and heap. The article then talks about reference types and value types and clarifies some of the important fundamentals around them. Finally, you will see a demonstration of how performance is hampered due to boxing and unboxing, with sample code.

Table of Contents

In case you do not want to read my complete article , you can watch the below video on Stack vs Heap | Boxing vs Unboxing | Value Type vs Reference Type .

Image 1


For further reading, do watch the below interview preparation videos and step by step video series.


This article will explain six important concepts: stack, heap, value types, reference types, boxing, and unboxing. This article starts explaining what happens internally when you declare a variable and then it moves ahead to explain two important concepts: stack and heap. The article then talks about reference types and value types and clarifies some of the important fundamentals around them.

The article concludes by demonstrating how performance is hampered due to boxing and unboxing, with a sample code.

Image 2

What Goes Inside When You Declare a Variable?

When you declare a variable in a .NET application, it allocates some chunk of memory in the RAM. This memory has three things: the name of the variable, the data type of the variable, and the value of the variable.

That was a simple explanation of what happens in the memory, but depending on the data type, your variable is allocated that type of memory. There are two types of memory allocation: stack memory and heap memory. In the coming sections, we will try to understand these two types of memory in more detail.

Image 3

Stack and Heap

In order to understand stack and heap, let’s understand what actually happens in the below code internally.

public void Method1()
    // Line 1
    int i=4;

    // Line 2
    int y=2;

    //Line 3
    class1 cls1 = new class1();

It’s a three line code, let’s understand line by line how things execute internally.

Memory allocation and de-allocation is done using LIFO (Last In First Out) logic. In other words, memory is allocated and de-allocated at only one end of the memory, i.e., top of the stack.

  • Line 1: When this line is executed, the compiler allocates a small amount of memory in the stack. The stack is responsible for keeping track of the running memory needed in your application.
  • Line 2: Now the execution moves to the next step. As the name says stack, it stacks this memory allocation on top of the first memory allocation. You can think about stack as a series of compartments or boxes put on top of each other.
  • Line 3: In line 3, we have created an object. When this line is executed, it creates a pointer on the stack and the actual object is stored in a different type of memory location called ‘Heap’. ‘Heap’ does not track running memory, it’s just a pile of objects which can be reached at any moment of time. Heap is used for dynamic memory allocation.

One more important point to note here is reference pointers are allocated on stack. The statement, Class1 cls1; does not allocate memory for an instance of Class1, it only allocates a stack variable cls1 (and sets it to null). The time it hits the new keyword, it allocates on "heap".

Exiting the method (the fun): Now finally the execution control starts exiting the method. When it passes the end control, it clears all the memory variables which are assigned on stack. In other words, all variables which are related to int data type are de-allocated in ‘LIFO’ fashion from the stack.

The big catch – It did not de-allocate the heap memory. This memory will be later de-allocated by the garbage collector.

Image 4

Now many of our developer friends must be wondering why two types of memory, can’t we just allocate everything on just one memory type and we are done?

If you look closely, primitive data types are not complex, they hold single values like ‘int i = 0’. Object data types are complex, they reference other objects or other primitive data types. In other words, they hold reference to other multiple values and each one of them must be stored in memory. Object types need dynamic memory while primitive ones needs static type memory. If the requirement is of dynamic memory, it’s allocated on the heap or else it goes on a stack.

Image 5

Value Types and Reference Types

Now that we have understood the concept of Stack and Heap, it’s time to understand the concept of value types and reference types. Value types are types which hold both data and memory on the same location. A reference type has a pointer which points to the memory location.

Below is a simple integer data type with name i whose value is assigned to another integer data type with name j. Both these memory values are allocated on the stack.

When we assign the int value to the other int value, it creates a completely different copy. In other words, if you change either of them, the other does not change. These kinds of data types are called as ‘Value types’.

Image 6

When we create an object and when we assign an object to another object, they both point to the same memory location as shown in the below code snippet. So when we assign obj to obj1, they both point to the same memory location.

In other words, if we change one of them, the other object is also affected; this is termed as ‘Reference types’.

Image 7

So Which Data Types Are Ref Types and Which Are Value Types?

In .NET, depending on the data type, the variable is either assigned on the stack or on the heap. ‘String’ and ‘Objects’ are reference types, and any other .NET primitive data types are assigned on the stack. The figure below explains the same in a more detailed manner.

Image 8

Boxing and Unboxing

Wow, you have given so much knowledge, so what’s the use of it in actual programming? One of the biggest implications is to understand the performance hit which is incurred due to data moving from stack to heap and vice versa.

Consider the below code snippet. When we move a value type to reference type, data is moved from the stack to the heap. When we move a reference type to a value type, the data is moved from the heap to the stack.

This movement of data from the heap to stack and vice-versa creates a performance hit.

When the data moves from value types to reference types, it is termed ‘Boxing’ and the reverse is termed ‘UnBoxing’.

Image 9

If you compile the above code and see the same in ILDASM, you can see in the IL code how ‘boxing’ and ‘unboxing’ looks. The figure below demonstrates the same:

Image 10

Performance Implication of Boxing and Unboxing

In order to see how the performance is impacted, we ran the below two functions 10,000 times. One function has boxing and the other function is simple. We used a stop watch object to monitor the time taken.

The boxing function was executed in 3542 ms while without boxing, the code was executed in 2477 ms. In other words, try to avoid boxing and unboxing. In a project where you need boxing and unboxing, use it when it’s absolutely necessary.

With this article, sample code is attached which demonstrates this performance implication.

Image 11

Currently, I have not included the source code for unboxing but the same holds true for it. You can write code and experiment it using the stopwatch class.

About the Source Code

Attached with the article is a simple code which demonstrates how boxing creates performance implications. You can download the source code here.


  • 27th April, 2010: Initial version
  • 24th June, 2021: Updated


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Written By
India India

Comments and Discussions

GeneralMy vote of 3 Pin
Răzvan Muntea13-Apr-22 3:11
Răzvan Muntea13-Apr-22 3:11 
QuestionMessage Closed Pin
26-Jul-21 21:39
paul vikram26-Jul-21 21:39 
GeneralMy vote of 3 Pin
tbayart28-Jun-21 11:38
professionaltbayart28-Jun-21 11:38 
QuestionWhat about string type? where its memory is created either in stack or heap? Pin
Adityakumar23186-Nov-19 1:12
Adityakumar23186-Nov-19 1:12 
QuestionUseful content Pin
Member 1392915728-Jul-18 20:52
Member 1392915728-Jul-18 20:52 
Question7 important .NET concepts: add Equality considerations Pin
TomEberhard18-Jul-18 10:08
TomEberhard18-Jul-18 10:08 
QuestionPerfect !! Pin
Robot10112-Feb-18 8:34
Robot10112-Feb-18 8:34 
GeneralCorrection + Praise Pin
Fernanda Gerhardt2-Jan-18 8:49
Fernanda Gerhardt2-Jan-18 8:49 
GeneralMy vote of 5 Pin
Saji John Miranda21-Aug-17 0:30
Saji John Miranda21-Aug-17 0:30 
PraiseShivprasad Koirala is a Legend Among Architects Pin
Saji John Miranda21-Aug-17 0:26
Saji John Miranda21-Aug-17 0:26 
GeneralNot Clear for Me Pin
Siffin5-Mar-17 22:36
professionalSiffin5-Mar-17 22:36 
GeneralRe: Not Clear for Me Pin
joviermark26-Jun-17 20:40
joviermark26-Jun-17 20:40 
Questionthanks Pin
Oleksiy Dymashok25-Jan-17 6:43
Oleksiy Dymashok25-Jan-17 6:43 
QuestionIf string is reference type then why its giving wrong output Pin
sunil mali5-Nov-16 23:48
sunil mali5-Nov-16 23:48 
AnswerRe: If string is reference type then why its giving wrong output Pin
Member 109454451-Mar-17 1:22
Member 109454451-Mar-17 1:22 
AnswerRe: If string is reference type then why its giving wrong output Pin
Robot10112-Feb-18 8:36
Robot10112-Feb-18 8:36 
AnswerRe: If string is reference type then why its giving wrong output Pin
TomEberhard18-Jul-18 10:20
TomEberhard18-Jul-18 10:20 
QuestionBest explanation of Stack and Heap I've seen so far Pin
Member 126254788-Jul-16 5:28
Member 126254788-Jul-16 5:28 
QuestionThanks a lot Pin
syynapse6-Jul-16 10:55
syynapse6-Jul-16 10:55 
QuestionThanks Pin
Member 1191819231-May-16 21:19
Member 1191819231-May-16 21:19 
Questionimportant link Pin
Member 120616009-May-16 10:49
Member 120616009-May-16 10:49 
SuggestionPerformance measurements are not accurate Pin
Dmitriy Gakh8-Apr-16 0:29
professionalDmitriy Gakh8-Apr-16 0:29 
PraiseAwesome explaination Pin
Member 1179010423-Jan-16 13:48
Member 1179010423-Jan-16 13:48 
QuestionConst field memory allocation Pin
Swapnil.Pednekar19-Nov-15 7:32
Swapnil.Pednekar19-Nov-15 7:32 
QuestionThanks Pin
Vo Thanh Bac3-Nov-15 15:48
Vo Thanh Bac3-Nov-15 15:48 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.