Understanding Values and References in Microsoft Visual C#

11/18/2015

Contents

Copying value type variables and classes
Understanding null values and nullable types
Using ref and out parameters
How computer memory is organized
The System.Object class
Boxing
Unboxing
Casting data safely
Summary
Quick reference

How computer memory is organized

Computers use memory to hold programs that are being executed and the data that those programs use. To understand the differences between value and reference types, it is helpful to understand how data is organized in memory.

Operating systems and language runtimes such as that used by C# frequently divide the memory used for holding data into two separate areas, each of which is managed in a distinct manner. These two areas of memory are traditionally called the stack and the heap. The stack and the heap serve different purposes, which are described here:

When you call a method, the memory required for its parameters and its local variables is always acquired from the stack. When the method finishes (because it either returns or throws an exception), the memory acquired for the parameters and local variables is automatically released back to the stack and is available again when another method is called. Method parameters and local variables on the stack have a well-defined life span: they come into existence when the method starts, and they disappear as soon as the method completes.
NOTE

Actually, the same life span applies to variables defined in any block of code enclosed by opening and closing curly braces. In the following code example, the variable i is created when the body of the while loop starts, but it disappears when the while loop finishes and execution continues after the closing brace:
```
while (...)
{
    int i = ...; // i is created on the stack here
    ...
}
// i disappears from the stack here
```
When you create an object (an instance of a class) by using the new keyword, the memory required to build the object is always acquired from the heap. You have seen that the same object can be referenced from several places by using reference variables. When the last reference to an object disappears, the memory used by the object becomes available again (although it might not be reclaimed immediately). Chapter 14 includes a more detailed discussion of how heap memory is reclaimed. Objects created on the heap therefore have a more indeterminate life span; an object is created by using the new keyword, but it disappears only sometime after the last reference to the object is removed.

The names stack and heap come from the way in which the runtime manages the memory:

Stack memory is organized like a stack of boxes piled on top of one another. When a method is called, each parameter is put in a box that is placed on top of the stack. Each local variable is likewise assigned a box, and these are placed on top of the boxes already on the stack. When a method finishes, you can think of the boxes being removed from the stack.
Heap memory is like a large pile of boxes strewn around a room rather than stacked neatly on top of one another. Each box has a label indicating whether it is in use. When a new object is created, the runtime searches for an empty box and allocates it to the object. The reference to the object is stored in a local variable on the stack. The runtime keeps track of the number of references to each box. (Remember that two variables can refer to the same object.) When the last reference disappears, the runtime marks the box as not in use, and at some point in the future it will empty the box and make it available.

Using the stack and the heap

Now let’s examine what happens when a method named Method is called:

void Method(int param)
{
    Circle c;
    c = new Circle(param);
    ...
}

Suppose the argument passed into param is the value 42. When the method is called, a block of memory (just enough for an int) is allocated from the stack and initialized with the value 42. As execution moves inside the method, another block of memory big enough to hold a reference (a memory address) is also allocated from the stack but left uninitialized. This is for the Circle variable, c. Next, another piece of memory big enough for a Circle object is allocated from the heap. This is what the new keyword does. The Circle constructor runs to convert this raw heap memory to a Circle object. A reference to this Circle object is stored in the variable c. The following illustration shows the situation:

Click to view larger image

At this point, you should note two things:

Although the object is stored on the heap, the reference to the object (the variable c) is stored on the stack.
Heap memory is not infinite. If heap memory is exhausted, the new operator will throw an OutOfMemoryException exception and the object will not be created.

When the method ends, the parameters and local variables go out of scope. The memory acquired for c and for param is automatically released back to the stack. The runtime notes that the Circle object is no longer referenced and at some point in the future will arrange for its memory to be reclaimed by the heap. (See Chapter 14.)

Save to your account