Unity_对象池

介绍

在项目中合理的使用对象池，减少频繁的创建、销毁对象，能有效的节约性能的开销。主要思路是在需要创建对象时先检测对象池中是否有可用对象，如果有直接取出，没有时再进行新建；在对象不再需要时将对象隐藏放入对象池等待下次需要时取出。当某个对象彻底不用时，可以将对应的对象池销毁减少内存的占用。

关键字

1. 单例模式
2. 对象池

代码

• 单例

using UnityEngine;

/// <summary>
/// 单例
/// </summary>
public class MonoSingleton<T> : MonoBehaviour where T : MonoSingleton<T>
{
    private static T _instance;
    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = FindObjectOfType<T>();
                if (_instance == null)
                {
                    _instance = new GameObject(typeof(T).ToString()).AddComponent<T>();
                }
            }
            return _instance;
        }
    }
}

• 对象池

using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 对象池
/// </summary>
public class ObjectPool : MonoSingleton<ObjectPool>
{
    private Dictionary<string, List<GameObject>> _objectDict;
    private Dictionary<string, GameObject> _prefabDict;
    /// <summary>
    /// 对象池
    /// </summary>
    private Dictionary<string, List<GameObject>> ObjectDict
    {
        get
        {
            if (_objectDict == null) _objectDict = new Dictionary<string, List<GameObject>>();
            return _objectDict;
        }

        set
        {
            _objectDict = value;
        }
    }
    /// <summary>
    /// 预设体字典
    /// </summary>
    private Dictionary<string, GameObject> PrefabDict
    {
        get
        {
            if (_prefabDict == null) _prefabDict = new Dictionary<string, GameObject>();
            return _prefabDict;
        }

        set
        {
            _prefabDict = value;
        }
    }

    /// <summary>
    /// 记录预设体字典
    /// </summary>
    /// <param name="obj"></param>
    public void SetPrefab(GameObject obj)
    {
        if (PrefabDict.ContainsKey(obj.name)) return;
        PrefabDict.Add(obj.name, obj);
    }

    /// <summary>
    /// 从对象池中获取对象
    /// </summary>
    /// <param name="objName"></param>
    /// <returns></returns>
    public GameObject GetObject(string objName, Transform parent = null)
    {
        if (parent == null) parent = transform;
        GameObject result = null;
        if (ObjectDict.ContainsKey(objName))
        {
            if (ObjectDict[objName].Count > 0)
            {
                result = ObjectDict[objName][0];
                result.transform.SetParent(parent);
                ObjectDict[objName].RemoveAt(0);
                return result;
            }
        }
        GameObject prefab = null;
        if (PrefabDict.ContainsKey(objName))
        {
            prefab = PrefabDict[objName];
        }
        else
        {
            Debug.LogError("[ObjectPool]:   prefab is null");
            return null;
            //prefab = Resources.Load<GameObject>("Prefabs/" + objName);
            //_prefabDict.Add(objName, prefab);
        }
        result = Instantiate(prefab, parent);
        result.name = objName;
        return result;
    }

    /// <summary>
    /// 回收对象到对象池
    /// </summary>
    /// <param name="objName"></param>
    public void RecycleObj(GameObject obj, Transform parent = null)
    {
        if (parent == null) parent = transform;
        obj.SetActive(false);
        obj.transform.SetParent(parent);
        if (ObjectDict.ContainsKey(obj.name))
        {
            ObjectDict[obj.name].Add(obj);
        }
        else
        {
            ObjectDict.Add(obj.name, new List<GameObject>() { obj });
        }
    }

    /// <summary>
    /// 删除对象池
    /// </summary>
    /// <param name="poolName"></param>
    public void DestoryPool(string poolName)
    {
        if (!_objectDict.ContainsKey(poolName)) return;
        List<GameObject> objs = _objectDict[poolName];
        for (int i = 0; i < objs.Count;)
        {
            Destroy(objs[i]);
            objs.RemoveAt(i);
        }
        _objectDict.Remove(poolName);
    }
}