How can I cache and read fields on non instantiated prefabs?

Question

Let's say I have a very simple 2D square prefab that has a script like this attached to it:

public class Square : MonoBehaviour
{
    public GameObject GameObject { get; private set; }
    public Transform Transform { get; private set; }
    public SpriteRenderer SpriteRenderer { get; private set; }

    private void Awake() 
    {
        GameObject = gameObject;
        Transform = transform;
        SpriteRenderer = GetComponent<SpriteRenderer>();
    }
}

I want to be able to arrange groups of these squares with different positions and sprite colors, saving them as prefabs to be used by a spawner (with object pooling), sort of like this:

public class SquareSpawner : MonoBehaviour
{
    [SerializeField]
    private Square[] squares;

    private ObjectPool<Square> pool;  

    public void Spawn(Vector2 position)
    {
        foreach (var square in squares)
        {
            /* Get a square prefab from object pool 
               (this will instantiate a Square prefab into the scene 
               if one does not yet exist) */
            Square pooledSquare = pool.Get();
            
            /* Set up the squares we got from the pool 
               to match the squares given to the squares array */
            pooledSquare.Transform.position = position + square.Transform.localPosition;
            pooledSquare.SpriteRenderer.Color = square.SpriteRenderer.Color;

            // etc.
        }          
    }
}

Basically, I'm trying to create a spawning system that is easily visualizable using prefabs. Since object pooling is used, I don't know the configuration of the square I'll be getting back, so I always have to set the given squares' properties to match the desired configuration (this could be size, color, position, etc.).

The issue is that I can't read the properties from the Square prefabs that are not being instantiated (the ones I'm putting into the Square[] squares array) because the Awake() method only gets called upon instantiation into the scene.

Perhaps there's a better way for me to set all of this up, but I'm wondering if there's a way for me to cache the properties in the Square class so that I can read them whether the script is on a prefab and/or an instantiated Square in the scene. It would also be nice if I could use a custom editor to test things in edit mode, which has also been hindered by my inability to cache these fields.

Answer 1

Simple: ensure the data you want to access is serialized and available in the saved version of the prefab.

[RequireComponent(typeof(SpriteRenderer))]
public class Square : MonoBehaviour
{
    [field:SerializeField, HideInInspector]
    public SpriteRenderer spriteRenderer { get; private set; }

    private void OnValidate() 
    {
        spriteRenderer = GetComponent<SpriteRenderer>();
    }
}

This will...

1. Ensure the object has a SpriteRenderer component when you add the Square component, if it didn't already, via the RequireComponent attribute.

2. Immediately call OnValidate when you edit the prefab in the inspector, caching a reference to that SpriteRenderer.

   (Technically here you could also use the Reset method which is called once when the component is added or manually reset to its defaults in the editor, rather than OnValidate which is called after every change or assembly reload in editor, as well as on entering play mode. But OnValidate is a bit more flexible if there's other stuff you want to set up that might not be available from the first moment the component is added. Note Philipp's caution from he comments that neither of these methods is called in the build, so use this only to set up data that you can serialize and load from disk already in the correct state)

3. Serialize that reference via the field:SerializeField attribute, so that it's saved with the prefab and available to read from the saved version without instantiating it.

I did not do this with the gameObject or transform members because those are already available to us in serialized prefabs through MonoBehaviour without needing to write any extra code of our own.

---

Alex Hetherington has created a handy editor script that simplifies this common task of linking-up component references. Now you can just add a [Resolve] attribute above the serialized component field you want to populate, and it will add a one-click button to populate the field (even populating an array of references), without you having to write your own initialization in OnValidate() or elsewhere. Here's a link to the GitHub repository with this and other utilities you can add to your project.