C# - Memory allocation for arrays

Memory Allocation for Arrays in .NET

Memory allocation for arrays in .NET (C#) involves understanding how arrays are stored in memory, the difference between value types and reference types, and how the runtime handles allocation for arrays. Let’s dive into the details:

1. Arrays in C#: Value vs. Reference

Value Type Arrays: If the array is of a value type (e.g., int, double), the actual data (elements) are stored in contiguous memory locations on the heap when using a reference type array.

Reference Type Arrays: If the array is of a reference type (e.g., string, class objects), the array itself is a reference object on the heap, and it contains references (pointers) to the actual objects stored elsewhere in memory.

2. Memory Layout of an Array

Arrays in .NET are reference types, even if they store value types.

The array object itself contains metadata, including:

1. A type handle: Identifies the type of the array.
2. A length field: Stores the size of the array.
3. Data pointers: For value types, points to the actual values; for reference types, points to the memory locations of the objects.

Example 1:

int[] numbers = new int[5];

A single block of memory is allocated:

• Metadata (type, length)
• Space for 5 integers (20 bytes for a 4-byte int).

Example 2

Employee[] employees = new Employee[3];

a. Memory is allocated for

• Metadata: Contains type information, length, etc.
• References: Space for 3 pointers (8 bytes each on a 64-bit system).

2.Initially, the references are null.

3. When you assign an Employee object to an index, memory is allocated for that object on the heap, and the reference in the array is updated.

Understanding of Stack and Heap Allocation

The stack stores the reference to the array if it is declared in a local scope (e.g., inside a method)

The heap stores

• The array object (metadata + actual elements for value types or references for reference types).
• The objects themselves (if it's an array of reference types).

Memory Allocation Process

1. Array Declaration:

Employee[] employees;

No memory is allocated yet, just a reference on the stack (set to null).

2. Array Initialization:

employees = new Employee[3];

Memory is allocated on the heap for the array object (metadata + 3 null references).

3. Object Assignment:

employees[0] = new Employee(1, "John", "HR");

• Memory is allocated on the heap for the Employee object.
• The array's reference at employees[0] points to this memory location.
  

Array Memory Allocation Example

public class Employee
{
    public int Id;
    public string Name;
    public string Department;
}

Employee[] employees = new Employee[3];
employees[0] = new Employee { Id = 1, Name = "John", Department = "HR" };
employees[1] = new Employee { Id = 2, Name = "Jane", Department = "Finance" };
employees[2] = new Employee { Id = 3, Name = "Mike", Department = "IT" };

Memory Layout

1. Heap Allocation for Array Object:

• Metadata (type, length).
• Array of 3 references (all null initially).

2. Heap Allocation for Each Employee Object:

• Memory for Id, Name, Department.
• Name and Department themselves point to string objects in the heap.