[unity learning 023] object pool Pro

Design an object pool manager , Used to control different object pools , Get objects from different pools through parameters , The corresponding pool returns the required object according to its own situation .

The script is as follows :

1. The design of the pool . Include new / Delete / Recycling and other methods .

public class Pool
{
    private GameObject ori; 
    public Pool(GameObject ori)
    {
        this.ori = ori;
    }

    public List<GameObject> store = new List<GameObject>();
    public List<GameObject> uesd = new List<GameObject>(); 

    public GameObject GetObj()
    {
        GameObject temp;
        if (store.Count > 0)
        {
            temp = store[0];
            store.RemoveAt(0);
        }
        else
        {
            temp = GameObject.Instantiate(ori);
            var key = temp.AddComponent<PoolKey>();
            key.key = ori.name;
        }
        uesd.Add(temp); 
        return temp;
    }

    public void RestoreObj(GameObject temp)
    { 
        if (uesd.Contains(temp))
        {
            uesd.Remove(temp);
        }
        store.Add(temp);
    } 
    public void DestoryObj(GameObject obj)
    {
        if (Application.isPlaying)
        {
            UnityEngine.GameObject.Destroy(obj);
        }
        else
        {
            UnityEngine.Object.DestroyImmediate(obj);
        }
    }


    public void Clear()
    {
        int length = store.Count;
        for (int i = length - 1; i >= 0; i--)
        {
            DestoryObj(store[i]);
        }
        length = uesd.Count;
        for (int i = length - 1; i >= 0; i--)
        {
            DestoryObj(uesd[i]);
        }
        store.Clear();
        uesd.Clear();

    }
}

2. Controller design .

/// <summary>
///  Universal object pool controller   , It is used to control different pools to corresponding objects from different pools 
/// </summary>
public class ObjController : MonoBehaviour
{
    [ShowInInspector]
    public static Dictionary<string, Pool> poolManager = new Dictionary<string, Pool>();

    // Generate a game object 
    public static GameObject CreateObj(GameObject ori)
    {
        GameObject temp;
        if (poolManager.ContainsKey(ori.name) == false)
        {
            poolManager[ori.name] = new Pool(ori);
        }
        temp = poolManager[ori.name].GetObj();
        return temp;
    }

    // Recycle a game object 
    public static void Restore(GameObject obj)
    {
        var poolKey = obj.GetComponent<PoolKey>();
        if (poolKey && poolManager.ContainsKey(poolKey.key))
        {
            poolManager[poolKey.key].RestoreObj(obj);
        }
        else
        {
            Debug.Log($"<color=red>{obj.name}  This object cannot be recycled , speculation 1:poolKey==null({poolKey == null}),2: Without this pool </color>");
        }
    }

    // Empty the object pool of a game object , By the way, delete all objects in the pool 
    public static void ClearObjPool(GameObject obj)
    {
        if (poolManager.ContainsKey(obj.name))
        {
            poolManager[obj.name].Clear();
            poolManager.Remove(obj.name);
        }
        else
        {
            Debug.Log("<color=red> Clearing failed </color>");
        }
    }


    public static void ClearAll()
    {
        foreach (var item in poolManager)
        {
            item.Value.Clear();
        }
        poolManager.Clear();
    }

}

3. For the convenience of finding , Each object has a key.

public class PoolKey : MonoBehaviour
{
    public string key;
    [ShowInInspector]
    public int id { get => GetInstanceID(); }
}

There's room for optimization . Use... For the time being .