Unity对象池、泛型单例

MonoSingleton泛型单例类这是继承MonoVehaviour的泛型单例：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 泛型单例约束在Component
/// </summary>
/// <typeparam name="T"></typeparam>
public class MonoSingleton<T> : MonoBehaviour
    //泛型单例的约束
    where T : Component
{

    #region 泛型单例的创建
    /// <summary>
    /// 泛型单例的创建
    /// </summary>
    private static T t;
    public static T Instance
    {
        get
        {
            if (t == null)
            {
                t = FindObjectOfType(typeof(T)) as T;
            }
            if (t == null)
            {
                GameObject go = new GameObject();
                t = go.AddComponent<T>();
            }
            return t;
        }
    }
    #endregion
}

不继承MonoBehavior的泛型单例

public class Singleton<T>where T:new ()
{
    private static T instance;
    public static T Instance
    {
        get
        {
            if (instance==null)
            {
                instance = new T();
            }
            return instance;
        }
    }
}

对象池脚本：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PoolManager : MonoSingleton<PoolManager>
{

    #region 集合 保存对象信息
    //集合 保存对象信息
    public Dictionary<string, List<GameObject>>
    objPool = new Dictionary<string, List<GameObject>>();
    #endregion

    #region 将物体添加进对象池中
    /// <summary>
    /// 将物体添加进对象池中
    /// </summary>
    /// <param name="objName"></param>
    /// <param name="obj"></param>
    public void Add(string objName, GameObject obj)
    {
        //如果对象池中不含有这个键
        if (!objPool.ContainsKey(objName))
        {
            //添加键和值
            objPool.Add(objName, new List<GameObject>());
        }
        //如果有键 在当前键中添加游戏对象
        objPool[objName].Add(obj);
    }
    #endregion

    #region 在对象池中取出可使用的物体
    /// <summary>
    /// 在对象池中取出可使用的物体
    /// </summary>
    /// <param name="objName"></param>
    /// <param name="go"></param>
    /// <param name="postin"></param>
    /// <param name="quaternion"></param>
    /// <returns></returns>
    public GameObject CreatObj(string objName, GameObject go, Vector3 postin,
    Quaternion quaternion)
    {
        GameObject item = null;
        item = FindUseObject(objName, go);
        //如果包含当前物体 返回可以使用的物体
        if (item != null)
        {
            item.transform.position = postin;
            item.transform.rotation = quaternion;
            //游戏对象每次使用完成 active=false
            item.SetActive(true);
        }
        else
        {
            //?没有的话怎么办
            //创建一个物体赋值并且存入集合中
            item = Instantiate(go, postin, quaternion) as GameObject;
            Add(objName, item);
        }
        return item;
    }
    #endregion

    #region 对象池中有没有可使用的物体
    /// <summary>
    /// 对象池中有没有可使用的物体
    /// </summary>
    /// <param name="objName"></param>
    /// <returns></returns>
    private GameObject FindUseObject(string objName, GameObject go)
    {
        if (objPool.ContainsKey(objName))
        {
            //在objName这个列表里面寻找p这个物体并将这个可以使用的游戏物体返回
            return objPool[objName].Find(p => !p.activeSelf);//这句话就是去 objPool[objName]这个集合里面寻找p这个物体如果有物体并且没有使用那就返回出去
                                                             //跟下面那个方法一样
            #region MyRegion
            //for (int i = 0; i < objPool[objName].Count; i++)
            //{
            // if (objPool[objName][i].activeSelf==false)
            // {
            // GameObject go = objPool[objName][i];
            // }
            //}
            #endregion
        }
        return null;
    }
    #endregion

    #region 游戏物体回收
    /// <summary>
    /// 游戏物体回收
    /// </summary>
    public void MyDestroy(GameObject go)
    {
        go.SetActive(false);
    }
    #endregion

    #region 延迟回收
    /// <summary>
    /// 延迟回收
    /// </summary>
    /// <param name="go"></param>
    /// <param name="delay"></param>
    ///
    public void MyDestroy(GameObject go, float delay)
    {
        //开启协程
        StartCoroutine(DelayRecycle(delay, go));
    }
    #endregion

    #region 延迟回收等待时间
    //延迟回收等待时间
    private IEnumerator DelayRecycle(float delay, GameObject go)
    {
        yield return new WaitForSeconds(delay);
        MyDestroy(go);
    }
    #endregion

    #region 清除列表
    /// <summary>
    /// 清除列表
    /// </summary>
    /// <param name="objName"></param>
    public void Clear(string objName)
    {
        objPool[objName].Clear();
    }
    #endregion
}

到此对象池封装也就完成了