.NET Memory Types

🚀 .NET Memory Types — What They Are, When to Use Them, and Why They Matter

Memory issues in .NET rarely come from “not enough RAM”.
They come from using the wrong memory model for the job.

Understanding how .NET manages memory helps you:

• Avoid performance traps
• Reduce GC pressure
• Write safer, faster code

Let’s break it down clearly and practically 👇

🧠 The Big Picture

In .NET, memory is mainly divided into:

• Stack
• Managed Heap
• Unmanaged Memory

And inside the managed heap, the GC uses generations and specialized heaps.

1️⃣ Stack Memory — Fast, Scoped, Automatic

Used for:

• Local variables
• Method parameters
• Value types (usually)
• References to heap objects

void Process()
{
    int count = 10;          // stack
    var order = new Order(); // reference on stack, object on heap
}

✅ Pros

• Extremely fast
• Automatically cleaned up
• No GC involvement

⚠️ Limits

• Small size
• Short lifetime
• Not suitable for large objects

👉 Think: temporary, short-lived data

2️⃣ Managed Heap — Flexible, GC-Controlled

Used for:

• Reference types
• Objects created with new
• Long-lived data

var customer = new Customer();

✅ Pros

• Flexible lifetimes
• Automatic memory management
• Safer than manual allocation

⚠️ Trade-offs

• Garbage Collection pauses
• Fragmentation risks
• Allocation cost under pressure

3️⃣ Garbage Collector Generations (Gen 0, 1, 2)

The GC optimizes based on object lifetime.

• Gen 0 → short-lived objects
• Gen 1 → survivors
• Gen 2 → long-lived objects (caches, singletons)

Gen 0 → Gen 1 → Gen 2

💡 Most objects die young — and the GC is optimized for that.

4️⃣ Large Object Heap (LOH)

Objects ≥ ~85 KB go to the LOH.

var buffer = new byte[100_000];

⚠️ Important characteristics

• Collected only during Gen 2 GC
• Historically not compacted by default
• Fragmentation can be expensive

👉 Avoid frequent allocation of large arrays.

5️⃣ Pinned Object Heap (POH)

Used when objects must not move in memory.

GCHandle.Alloc(buffer, GCHandleType.Pinned);

Used for:

• Interop
• Native APIs
• Fixed buffers

⚠️ Overuse causes heap fragmentation.

6️⃣ Unmanaged Memory — Manual but Predictable

Allocated outside the GC.

IntPtr ptr = Marshal.AllocHGlobal(1024);
Marshal.FreeHGlobal(ptr);

✅ Pros

• No GC impact
• Predictable lifetime
• Required for interop

❌ Cons

• Manual cleanup
• Memory leaks if misused
• More error-prone

👉 Use only when necessary.

7️⃣ Span<T> — Stack-Friendly, Zero Allocation

Represents a slice of memory.

Span<byte> buffer = stackalloc byte[256];

✅ Benefits

• No heap allocation
• Extremely fast
• Great for parsing, IO, serialization

⚠️ Constraints

• Stack-only
• Cannot escape the method
• No async/await

8️⃣ Memory<T> — Heap-Friendly Span

Safe alternative to Span<T> for async scenarios.

Memory<byte> buffer = new byte[256];
await stream.ReadAsync(buffer);

✔️ Can live on the heap
✔️ Async-safe
❌ Slightly slower than Span<T>

🧠 Choosing the Right Memory Type

⚠️ Common Memory Mistakes

❌ Allocating large arrays repeatedly
❌ Ignoring LOH fragmentation
❌ Pinning too much memory
❌ Overusing unmanaged memory
❌ Not pooling buffers

Most performance bugs are allocation bugs.

🎯 Final Takeaway

.NET memory management is automatic — but performance is still your responsibility.

Know where your data lives.
Know how long it lives.
And choose the right memory tool.

That’s how you write high-performance .NET code.

#dotnet #csharp #memorymanagement #performance #gc #softwareengineering #backend