Unity C# 对象池

using System.Collections.Generic;
using UnityEngine;

namespace TMoonObjectPool
{
    /// <summary>
    /// 对象池
    /// </summary>
    public class GameObjectPool
    {
        /// <summary>
        /// 对象池的名字
        /// </summary>
        public string name = string.Empty;

        /// <summary>
        /// 对象池拥有的对象
        /// </summary>
        public GameObject obj = null;

        /// <summary>
        /// 对有效的对象栈存储
        /// </summary>
        private Stack<GameObject> available;

        /// <summary>
        /// 保存所有的对象
        /// </summary>
        private List<GameObject> all;

        /// <summary>
        /// 构造函数初始化
        /// </summary>
        /// <param name="name"></param>
        /// <param name="obj"></param>
        public GameObjectPool(string name, GameObject obj)
        {
            this.name = name;
            this.obj = obj;
            available = new Stack<GameObject>();
            all = new List<GameObject>();
        }

        /// <summary>
        /// 从对象池中分配一个对象
        /// </summary>
        /// <returns></returns>
        public GameObject Allocate(Vector3 position, Quaternion rotation)
        {

            GameObject go;

            // 创建对象
            if (available.Count == 0)
            {
                go = GameObject.Instantiate(obj, position, rotation);
                all.Add(go);
            }
            // 使用已存在的
            else
            {
                go = available.Pop();
                go.transform.position = position;
                go.transform.rotation = rotation;
            }

            //激活对象并发送消息给对象已激活执行回调
            go.SetActive(true);
            //MessageDispatcher.SendMessage(go.name or go.tag);

            return go;
        }

        /// <summary>
        /// 从对象池中预先加载对象
        /// </summary>
        /// <param name="count">预先加载数量的数目</param>
        public void Preload(int count)
        {
            GameObject[] gos = new GameObject[count];
            GameObject parent = new GameObject(obj.name);
            // 创建预先加载的对象
            for (int i = 0; i < count; i++)
            {
                gos[i] = Allocate(Vector3.zero, Quaternion.identity);
                gos[i].transform.parent = parent.transform;
            }

            for (int i = 0; i < count; i++)
            {
                Release(gos[i]);
            }
        }

        /// <summary>
        /// 把对象回收到对象池中去
        /// </summary>
        /// <param name="obj"></param>
        public void Release(GameObject obj)
        {
            if (!available.Contains(obj))
            {
                available.Push(obj);

                //禁用对象并发送消息给对象已禁用执行回调
                //MessageDispatcher.SendMessage(go.name or go.tag);
                obj.SetActive(false);
            }
        }

        /// <summary>
        /// 对象池回收所有的对象
        /// </summary>
        public void ReleaseAll()
        {
            for (int i = 0; i < all.Count; i++)
            {
                GameObject go = all[i];
                if (go != null && go.activeInHierarchy)
                {
                    Release(go);
                }
            }
        }

        /// <summary>
        /// 清理对象池
        /// </summary>
        public void Clear()
        {
            ReleaseAll();
            available.Clear();
            all.Clear();
        }

        /// <summary>
        /// 返回已激活的对象
        /// </summary>
        /// <returns></returns>
        public int GetActiveCount()
        {
            return all.Count - available.Count;
        }

        /// <summary>
        /// 返回可用对象的数目
        /// </summary>
        /// <returns></returns>
        public int GetAvailableCount()
        {
            return available.Count;
        }

        /// <summary>
        /// 返回对象池中的对象
        /// </summary>
        /// <returns></returns>
        public GameObject GetObject()
        {
            return obj;
        }
    }
}

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

namespace TMoonObjectPool
{
    /// <summary>
    /// 对象池管理类
    /// </summary>
    public class PoolManager
    {
        private static PoolManager instance = null;
        public static PoolManager Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new PoolManager();
                }
                return instance;
            }
        }

        private List<GameObjectPool> pools = null;

        private PoolManager() { pools = new List<GameObjectPool>(); }

        //创建一个对象池
        public GameObjectPool Create(string name, GameObject obj)
        {
            GameObjectPool pool = new GameObjectPool(name, obj);
            pools.Add(pool);
            return pool;
        }

        //移除一个对象池
        public void Remove(string name)
        {
            int index = pools.FindIndex((pool) => pool.name == name);
            pools[index].Clear();
            pools.RemoveAt(index);
        }

        //移除所有的对象池
        public void RemoveAll()
        {
            pools.Clear();
        }

        /// <summary>
        /// 得到一个对象池
        /// </summary>
        /// <param name="name">对象池的名字</param>
        /// <returns></returns>
        public GameObjectPool GetPool(string name)
        {
            return pools.Find((pool) => pool.name == name);
        }
    }
}

示例代码：

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

public class test : MonoBehaviour
{
    public GameObject go;
    private GameObjectPool pool;
    void Start()
    {
        pool = PoolManager.Instance.Create("go", go);
        pool.Preload(5);
    }

    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            pool.Allocate(Vector3.zero,Quaternion.identity);
        }

        if (Input.GetKeyDown(KeyCode.R))
        {
            pool.ReleaseAll();
        }
    }
}

今天看了下Unity UGUI的源码，发现了一个对象池的工具类，觉得写得又简单又好，在下面直接贴代码上来了。

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

namespace UnityEngine.UI
{
    internal class ObjectPool<T> where T : new()
    {
        private readonly Stack<T> m_Stack = new Stack<T>();
        private readonly UnityAction<T> m_ActionOnGet;
        private readonly UnityAction<T> m_ActionOnRelease;

        public int countAll { get; private set; }
        public int countActive { get { return countAll - countInactive; } }
        public int countInactive { get { return m_Stack.Count; } }

        public ObjectPool(UnityAction<T> actionOnGet, UnityAction<T> actionOnRelease)
        {
            m_ActionOnGet = actionOnGet;
            m_ActionOnRelease = actionOnRelease;
        }

        public T Get()
        {
            T element;
            if (m_Stack.Count == 0)
            {
                element = new T();
                countAll++;
            }
            else
            {
                element = m_Stack.Pop();
            }
            if (m_ActionOnGet != null)
                m_ActionOnGet(element);
            return element;
        }

        public void Release(T element)
        {
            if (m_Stack.Count > 0 && ReferenceEquals(m_Stack.Peek(), element))
                Debug.LogError("Internal error. Trying to destroy object that is already released to pool.");
            if (m_ActionOnRelease != null)
                m_ActionOnRelease(element);
            m_Stack.Push(element);
        }
    }
}