Everything a C# Developer Needs to Know, in Bite-Sized Chunks
January 3, 2011 Leave a comment
Static data and constants defined in a C# program are stored on the heap. Since they exist for the lifetime of the application, they do not need to be garbage collected and are therefore stored in a loader heap, rather than the normal Garbage Collected heap. Specifically, static data is stored on the high-frequency heap–one of the loader heaps that exists for each AppDomain.
January 2, 2011 2 Comments
You create a new instance of a reference type by using the new operator and declaring a reference to the new object. Memory for the object is allocated on the heap and the reference to the object is stored on the stack.
The object itself is able to be destroyed, i.e. its memory freed, when there are no longer any variables that reference it. This is done automatically by the Garbage Collector (GC) in .NET.
Unlike with C++, you cannot explicitly delete a heap-based object and free its memory. Only the Garbage Collector can release the memory for the object. The Garbage Collector will not actually destroy the object unless a) there are no longer any references to the object and b) the CLR invokes the Garbage Collector because it needs memory.
December 24, 2010 Leave a comment
In C#, you create an object on the heap when you instantiate an object using the new keyword.
Person general = new Person("Julius", "Caesar");
We now have a Person object on the heap and a reference to that object–the variable general.
We can also declare a second variable that references the same object.
Person antonysFriend = general;
Now we have one Person object on the heap and two references to it.
The memory for an object on the heap can be freed when it’s no longer being referenced by any variables. This can happen when the variables that reference it go out of scope, or when they are set to point to another object.
More precisely, the memory will be reclaimed by the Garbage Collector (GC) in .NET. When an application needs more memory, the GC is triggered and it releases memory for any dead objects.
December 22, 2010 1 Comment
When you instantiate an object, an area of memory on the heap is allocated to store the object’s data. So we typically say that the object is on the heap.
Person thatGuy = new Person("Julius", "Caesar");
In the above example, a new instance of the Person class is created and the data for this Person is stored on the heap.
But in creating a new instance of a Person, we also had to declare and instantiate a reference to the Person object that we just created. That reference is stored on the stack.
In the same way that value types are normally stored on the stack, but can be on the heap if they exist within another object, object references can also be on the heap if they are contained within other objects.
December 20, 2010 1 Comment
Value types are normally allocated on the stack. They can, however, be allocated on the heap–when they are declared within an object. When an object is instantiated, memory for the entire object, including all of its data, is allocated on the heap.
For example, assume we define a Person class with some properties that are value types (int) and some that are reference types (string).
public class Person
{
string FirstName;
string LastName;
int Age;
int HeightInInches; // also on heap
public Person(string firstName, string lastName)
{
FirstName = firstName;
LastName = lastName;
}
}
When you create an instance of the Person object,
Person p = new Person("Zsa Zsa", "Gabor");
the Person object is created on the heap and all of its data members, including the Age and HeightInInches value types, are also on the heap.
December 19, 2010 3 Comments
In C#, all objects are created on either the heap or the stack.
The stack is an area of memory where the following is stored:
The heap is an area of memory where the following is stored:
Memory for objects created on the stack is allocated when a method is called or when the object is instantiated. The memory is released when the method that instantiated the object exits.
Memory for objects created on the heap is allocated when the object is instantiated and managed by the CLR garbage collector, which frees memory periodically.
July 31, 2010 Leave a comment
If you assign a variable that points to a reference type to another variable of the same type, both variables end up pointing to the same object in memory. This means that changing the contents of the object through the first reference results in changes that are also seen by the second reference.
The following code:
Person p1 = new Person("Sean", 46); // New Person object
Person p2 = p1; // Points to same object
Results in this situation:
Also, if we change one of the properties of the Person object using the p2 reference, we see the same change when using p1. This confirms that both variables are pointing to the same object.
p2.Age = 50; int age = p1.Age; // Also now = 50
July 30, 2010 Leave a comment
When you instantiate a reference type using the new operator, you are creating a new instance of that type. The object is created on what’s known as the managed heap. In other words, memory is allocated to store the member data of the object and that memory is allocated from an area of memory known as the heap.
For example, when you execute the following line to create a new Person object:
Person myPerson = new Person("Sean", 46);
You’ve created an instance of a Person, storing the data on the heap. You’ve also created a reference variable, myPerson, that references (or points to) the new object.
