Pooling

Pooling. There are some tools for this on Asset Store, but in general, pooling goes like this:

[code]
private List<GameObject> objectPool;

objectPool = new List <GameObject>();

// optionally one can instantiate any number of object in Awake()

if (Input.GetButton ("Fire1")  && canFire) {
	GameObject myObject = GetObject ();
	DoSomethingWith (myObject);
}

void GetObject () {
	foreach (GameObject thisObject in objectPool) {
		if (thisObject.gameObject.active = false) {
			thisObject.SetActiveRecursively (true);
			return thisObject;
		}
	}
	GameObject newObject = (GameObject)Instantiate (objectPrefab, poolSpawnPoint.position, Quaternion.identity);
	newObject.transform.parent = poolSpawnPoint; // for organizational purposes only
	objectPool.Add (newObject);
	return newObject;
}
[/code]

You create a list of objects that you pool. When you want an object, you check the object pool for an inactive object. If there is no inactive object in the pool, then you create a new object and add it to the pool. When you are done with the object, don't destroy, simply set it to inactive. Optionally (and it's probably a good idea) just after initializing the pool list in awake, one could go through an arbitrary number of iterations and instantiate & add items to the pool - 5, 10, 50, 100 depending on how many you think you might need. When making the shots in the video, both the laser bolts and torpedoes are pooled, so I reuse them all the time. This prevents excessive use of the garbage collector removing destroyed objects.

Where I run into trouble is that I am also pooling the explosion prefabs, and I was setting an instance of the explosion prefab to follow the asteroids and as they were being destroyed, it was screwing up my references by destroying the explosion prefabs along with them which were being tracked by the pool.

In general, instantiate/destroy is simple and the pattern supplied by Unity as the "typical" solution. Coming from Unity mobile gaming, I love pools, and I am so used to them, I don't see any real overhead in using them over instantiate/destroy.

Your static cache seems to be doing some of this work as well - preinstantiating the prefabs.