/// <summary>
        /// 获取所有对象池。
        /// </summary>
        /// <param name="sort">是否根据对象池的优先级排序。</param>
        /// <returns>所有对象池。</returns>
        public ObjectPoolBase[] GetAllObjectPools(bool sort)
        {
            if (sort)
            {
                List <ObjectPoolBase> results = new List <ObjectPoolBase>();
                foreach (KeyValuePair <string, ObjectPoolBase> objectPool in objectPools)
                {
                    results.Add(objectPool.Value);
                }

                results.Sort(ObjectPoolComparer);
                return(results.ToArray());
            }
            else
            {
                int index = 0;
                ObjectPoolBase[] results = new ObjectPoolBase[objectPools.Count];
                foreach (KeyValuePair <string, ObjectPoolBase> objectPool in objectPools)
                {
                    results[index++] = objectPool.Value;
                }

                return(results);
            }
        }
        private bool InnerDestroyObjectPool(string fullName)
        {
            ObjectPoolBase objectPool = null;

            if (objectPools.TryGetValue(fullName, out objectPool))
            {
                objectPool.ReleaseAll();
                return(objectPools.Remove(fullName));
            }

            return(false);
        }
        private ObjectPoolBase InnerCreateObjectPool(Type objectType, string name, bool allowMultiSpawn, int capacity, float autoReleaseInterval, float expireTime, int priority)
        {
            Guard.Verify <ArgumentException>(objectType == null, "Object type is invalid.");
            Guard.Verify <ArgumentException>(!typeof(ObjectBase).IsAssignableFrom(objectType), string.Format("Object type '{0}' is invalid.", objectType.FullName));
            Guard.Verify <ArgumentException>(HasObjectPool(objectType, name), string.Format("Already exist object pool '{0}'.", Utility.Text.GetFullName(objectType, name)));

            Type           objectPoolType = typeof(ObjectPool <>).MakeGenericType(objectType);
            ObjectPoolBase objectPool     = (ObjectPoolBase)Activator.CreateInstance(objectPoolType, name, allowMultiSpawn, capacity, autoReleaseInterval, expireTime, priority);

            objectPools.Add(Utility.Text.GetFullName(objectType, name), objectPool);
            return(objectPool);
        }
        /// <summary>
        /// 获取对象池。
        /// </summary>
        /// <param name="fullName">对象池完整名称。</param>
        /// <returns>要获取的对象池。</returns>
        public ObjectPoolBase GetObjectPool(string fullName)
        {
            Guard.NotEmptyOrNull(fullName, "Full name is invaild.");

            ObjectPoolBase objectPool = null;

            if (objectPools.TryGetValue(fullName, out objectPool))
            {
                return(objectPool);
            }

            return(null);
        }
 private int ObjectPoolComparer(ObjectPoolBase a, ObjectPoolBase b)
 {
     return(a.Priority.CompareTo(b.Priority));
 }
        /// <summary>
        /// 销毁对象池。
        /// </summary>
        /// <param name="objectPool">要销毁的对象池。</param>
        /// <returns>是否销毁对象池成功。</returns>
        public bool DestroyObjectPool(ObjectPoolBase objectPool)
        {
            Guard.Verify <ArgumentException>(objectPool == null, "Object type is invalid.");

            return(InnerDestroyObjectPool(Utility.Text.GetFullName(objectPool.ObjectType, objectPool.Name)));
        }