Memory allocation: Stack vs Heap?

Question

I am getting confused with memory allocation basics between Stack vs Heap. As per the standard definition (things which everybody says), all Value Types will get allocated onto a Stack and Reference Types will go into the Heap.

Now consider the following example:

class MyClass
{
    int myInt = 0;    
    string myString = "Something";
}

class Program
{
    static void Main(string[] args)
    {
       MyClass m = new MyClass();
    }
}

Now, how does the memory allocation will happen in c#? Will the object of MyClass (that is, m) will be completely allocated to the Heap? That is, int myInt and string myString both will go to heap?

Or, the object will be divided into two parts and will be allocated to both of the memory locations that is, Stack and Heap?

Answer 1

You should consider the question of where objects get allocated as an implementation detail. It does not matter to you exactly where the bits of an object are stored. It may matter whether an object is a reference type or a value type, but you don't have to worry about where it will be stored until you start having to optimize garbage collection behavior.

While reference types are always allocated on the heap in current implementations, value types may be allocated on the stack -- but aren't necessarily. A value type is only allocated on the stack when it is an unboxed non-escaping local or temporary variable that is not contained within a reference type and not allocated in a register.

• If a value type is part of a class (as in your example), it will end up on the heap.
• If it's boxed, it will end up on the heap.
• If it's in an array, it will end up on the heap.
• If it's a static variable, it will end up on the heap.
• If it's captured by a closure, it will end up on the heap.
• If it's used in an iterator or async block, it will end up on the heap.
• If it's created by unsafe or unmanaged code, it could be allocated in any type of data structure (not necessarily a stack or a heap).

Is there anything I missed?

Of course, I would be remiss if I didn't link to Eric Lippert's posts on the topic:

• The Stack Is An Implementation Detail, Part One
• The Stack Is An Implementation Detail, Part Two
• And perhaps the best one: The Truth About Value Types