How memory is allocated in .Net application

11y5kVisual Basic .NET

i like to know in details and want to visualize how memory is allocated in dotnet program. sorry because i will be asking few question. so please answer point wise in detail.

1) suppose i have class called employee which has data member called empNo, Name and Salary. so i like to know when we will create object of employee then how memory will be allocated ?

2) where memory will be allocated for employee object? in heap or stack?

3) why memory is allocated in heap for object and local variable in stack?

4) i hear some time memory is allocated in heap for local variable but when?

5) where actual data is stored like employee name or salary in heap or stack? if in stack why? why not in heap?

6) i heard that memory is allocated for static class in high frequency heap........what is high frequency heap and how it is different than normal heap?

4 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes11y ago
It's a common misconception that value types are ALWAYS stored on the stack.This isn't the case.

For example, if they are fields of an object (i.e. a reference type) then they are stored on the heap as part of the object's memory.

When I say that local variables are always stored on the stack, I mean ALL variables declared within methods or properties.

If the local variable is of a value type, then the variable actually contains an instance of the value type and so, in this case, the value type is stored on the stack.

However, if the local variable is of a reference type, then the variable contains a reference to where an object of that reference type is stored on the heap or, if it currently refers to no object, it contains a null reference.

A reference is simply a pointer which is tracked by the garbage collector. If memory is compacted following a collection, then the address of an object (and hence any references to it) may change.

Here's a simple example which might help to make all this clearer:

using System;

class Employee
{
int empNo; // struct instance stored in object's memory on heap
string name; // string reference stored in object's memory on heap,
// refers to string instance stored elsewhere on heap
double salary; // struct instance stroed in object's memory on heap

public int EmpNo
{
get { return empNo; }
set { empNo = value; }
}

public string Name
{
get { return name; }
set { name = value; }
}

public double Salary
{
get { return salary; }
set { salary = value; }
}

public Employee(int empNo, string name, double salary)
{
this.empNo = empNo;
this.name = name;
this.salary = salary;
}
}

class Program
{
static void Main(string[] args)
{
Employee emp; // local variable stored on stack
emp = new Employee(1, "Fred", 50000);
// emp now contains reference to new Employee
// object stored on heap
Console.WriteLine("Name : {0}", emp.Name);
Console.WriteLine("EmpNo : {0}", emp.EmpNo);
Console.WriteLine("Salary : {0}", emp.Salary);
int multiplier; // local variable stored on stack
multiplier = 2;
// multiplier now contains actual struct instance
double result; // another local variable stored on stack
result = multiplier * emp.Salary; // now contains computer double instance
Console.WriteLine("{0} x {1} : {2}", multiplier, emp.Salary, result);
Console.ReadKey();
}
}

0
11y ago
thanks for answer. it would br nice if you come with small sample code and then explain how memory is allocated for data member & function for instance. looking for more details with sample code as a result anyone can visualize.

you said : Suppose empNo is an int, Name is a string and Salary is a double. Sufficient memory will be allocated on the heap to accomodate these 3 fields plus overhead of 8 bytes (32 bit system) or 16 bytes (64 bit system).

empno & salary is value type then why u r saying value of those fields will be stored in heap? i guess they should be stored in stack because they are fixed size.

u said : Local variables must of necessity be stored on the stack

which local variable u r talking about? variable declared inside in function? if yes then we can declare ref type variable inside function then those variable should store on heap i guess ?

make all ur points more clear with sample code. thanks
0
Vulpes11y ago
Taking those questions in the same order:

1. Suppose empNo is an int, Name is a string and Salary is a double. Sufficient memory will be allocated on the heap to accomodate these 3 fields plus overhead of 8 bytes (32 bit system) or 16 bytes (64 bit system).

4 bytes will be needed for empNo, 8 bytes for salary plus either 8 or 16 bytes (depending on whether it's a 32/64 bit system) for the Name field. The latter will not actually contain the string object but a reference to where it's stored elsewhere on the heap. Padding might also be needed to ensure the fields are alllocated on processor memory boundaries.

2. Memory for the empoyee object will be allocated on the heap.

3. Objects (i.e. instances of reference types) can be very large whereas stack memory is limited by default to 1 MB per thread. It therefore makes sense to allocate objects on the heap whose size is only limited by available memory, rather than the stack.

Local variables must of necessity be stored on the stack because their lifetime is limited to that of the method which contains them.

In any case, they require little memory. In the case of a local variable of a reference type this will be either the 8 or 16 bytes needed to store a reference to where the object is stored on the heap.

However, in the case of a local variable of a value type (struct or enum), the variable will store the actual instance which will typically be small - usually no more than 16 bytes.

4. You heard wrongly - local variables are always stored on the stack.

5. I think my answers to the previous questions will have already answered this question.

6. A static class cannnot be instantiated. However, all types have an internal structure - known as a type object - which contains their method table and memory slots for their static fields which are the only fields a static class can have. These internal structures are stored in the 'high frequency heap', rather than the normal 'object' heap. This is because they are accessed much more frequently on average and the algorithms needed to access them can be tuned accordingly.
+1
Vithal Wadje11y ago
refer this article

http://www.c-sharpcorner.com/UploadFile/tkagarwal/MemoryManagementInNet11232005064832AM/MemoryManagementInNet.aspx
0