In this lesson, you will learn how to utilize memory snapshots to identify "orphaned" objects that persist in RAM, preventing long-term memory bloat.
Even after you've optimized Update loops and reduced garbage collection, your game might still suffer from memory leaks where objects stay in memory long after they should have been destroyed. This typically happens when a script or a static collection holds a "strong reference" to an object (like a projectile, an enemy, or a UI panel), preventing the Garbage Collector from reclaiming that memory.
Using the Memory Profiler
To diagnose this, navigate to Window > Analysis > Memory Profiler. Once open, capture a Snapshot at the start of a session, play your game for a few minutes, destroy the objects in question, and then capture a second Snapshot.
When comparing these two snapshots, look for objects that should be zero but still appear in the list. This is where the Reference Graph becomes essential. By selecting an orphaned object, the Memory Profiler reveals the "References" or "Paths to Root."
Reading the Reference Graph
The graph displays a chain of connections leading from your object back to a "Root" (the objects that keep it alive). A typical leak often looks like this:
YourObject -> List<GameObject> (in a static Manager) -> Static Root
If you see your object being held by a static list or an event delegate that was never unsubscribed, you have found your culprit. To fix this, you must explicitly nullify the reference or unsubscribe from the event:
// The source of the leak:
public static List<Enemy> ActiveEnemies = new List<Enemy>();
// The fix:
public void OnDestroy() {
ActiveEnemies.Remove(this);
}
By tracing the Reference Graph, you can identify exactly which lingering reference is preventing the cleanup. If you don't break these chains, the memory usage will climb steadily during extended sessions, eventually leading to a crash or severe stuttering.
Key Takeaway: A memory leak is essentially a "dangling pointer" in C#; use the Reference Graph in the Memory Profiler to find which static or persistent object is keeping your orphaned instances from being garbage collected.