/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
public void Release(int toReleaseCount, ReleaseObjectFilterCallback <T> releaseObjectFilterCallback)
{
Guard.Verify <ArgumentException>(releaseObjectFilterCallback == null, "Release object filter callback is invalid.");
if (toReleaseCount < 0)
{
toReleaseCount = 0;
}
DateTime expireTime = DateTime.MinValue;
if (this.m_ExpireTime < float.MaxValue)
{
expireTime = DateTime.Now.AddSeconds(-this.m_ExpireTime);
}
m_AutoReleaseTime = 0f;
GetCanReleaseObjects(m_CachedCanReleaseObjects);
List <T> toReleaseObjects = releaseObjectFilterCallback(m_CachedCanReleaseObjects, toReleaseCount, expireTime);
if (toReleaseObjects == null || toReleaseObjects.Count <= 0)
{
return;
}
foreach (T toReleaseObject in toReleaseObjects)
{
Release(toReleaseObject);
}
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
public void Release(int toReleaseCount, ReleaseObjectFilterCallback <T> releaseObjectFilterCallback)
{
if (releaseObjectFilterCallback == null)
{
throw new GameFrameworkException("Release object filter callback is invalid.");
}
if (toReleaseCount < 0)
{
toReleaseCount = 0;
}
DateTime expireTime = DateTime.MinValue;
if (m_ExpireTime < float.MaxValue)
{
expireTime = DateTime.Now.AddSeconds(-m_ExpireTime);
}
m_AutoReleaseTime = 0f;
GetCanReleaseObjects(m_CachedCanReleaseObjects);
List <T> toReleaseObjects = releaseObjectFilterCallback(m_CachedCanReleaseObjects, toReleaseCount, expireTime);
if (toReleaseObjects == null || toReleaseObjects.Count <= 0)
{
return;
}
foreach (T toReleaseObject in toReleaseObjects)
{
ReleaseObject(toReleaseObject);
}
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
public void Release(int toReleaseCount, ReleaseObjectFilterCallback <T> releaseObjectFilterCallback)
{
if (releaseObjectFilterCallback == null)
{
throw new UnityEngine.UnityException("Release object filter callback is invalid.");
}
m_AutoReleaseTime = 0f;
if (toReleaseCount < 0)
{
toReleaseCount = 0;
}
DateTime expireTime = DateTime.MinValue;
if (m_ExpireTime < float.MaxValue)
{
expireTime = DateTime.Now.AddSeconds(-m_ExpireTime);
}
LinkedList <T> canReleaseObjects = GetCanReleaseObjects();
LinkedList <T> toReleaseObjects = releaseObjectFilterCallback(canReleaseObjects, toReleaseCount, expireTime);
if (toReleaseObjects == null || toReleaseObjects.Count <= 0)
{
return;
}
foreach (ObjectBase toReleaseObject in toReleaseObjects)
{
if (toReleaseObject == null)
{
throw new UnityEngine.UnityException("Can not release null object.");
}
bool found = false;
foreach (Object <T> obj in m_Objects)
{
if (obj.Peek() != toReleaseObject)
{
continue;
}
m_Objects.Remove(obj);
obj.Release();
UnityEngine.Debug.Log(string.Format("Object pool '{0}' release '{1}'.", Name, toReleaseObject.Name));
found = true;
break;
}
if (!found)
{
throw new UnityEngine.UnityException("Can not release object which is not found.");
}
}
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量。</param>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
public void Release(int toReleaseCount, ReleaseObjectFilterCallback <T> releaseObjectFilterCallback)
{
if (releaseObjectFilterCallback == null)
{
throw new Exception("Release object filter callback is invalid.");
}
m_AutoReleaseTime = 0f;
if (toReleaseCount < 0)
{
toReleaseCount = 0;
}
DateTime expireTime = DateTime.MinValue;
if (m_ExpireTime < float.MaxValue)
{
expireTime = DateTime.Now.AddSeconds(-m_ExpireTime);
}
GetCanReleaseObjects(m_CachedCanReleaseObjects);
List <T> toReleaseObjects = releaseObjectFilterCallback(m_CachedCanReleaseObjects, toReleaseCount, expireTime);
if (toReleaseObjects == null || toReleaseObjects.Count <= 0)
{
return;
}
foreach (ObjectBase toReleaseObject in toReleaseObjects)
{
if (toReleaseObject == null)
{
throw new Exception("Can not release null object.");
}
bool found = false;
foreach (Object <T> obj in m_Objects)
{
if (obj.Peek() != toReleaseObject)
{
continue;
}
m_Objects.Remove(obj);
obj.Release(false);
//GameFrameworkLog.Debug("Object pool '{0}' release '{1}'.", Utility.Text.GetFullName<T>(Name), toReleaseObject.Name);
found = true;
break;
}
if (!found)
{
throw new Exception("Can not release object which is not found.");
}
}
}
/// <summary>
/// 释放对象池中的可释放对象
/// </summary>
/// <param name="toReleaseCount">尝试释放对象数量</param>
/// <param name="releaseObjectFilterCallback">释放对象筛选方法</param>
public void Release(int toReleaseCount, ReleaseObjectFilterCallback <T> releaseObjectFilterCallback)
{
//重置计时
AutoReleaseTime = 0;
if (toReleaseCount <= 0)
{
return;
}
//计算对象过期参考时间
DateTime expireTime = DateTime.MinValue;
if (m_ExpireTime < float.MaxValue)
{
//当前时间 - 过期秒数 = 过期参考时间
expireTime = DateTime.Now.AddSeconds(-m_ExpireTime);
}
//获取可释放的对象和实际要释放的对象
LinkedList <T> canReleaseObjects = GetCanReleaseObjects();
LinkedList <T> toReleaseObjects = releaseObjectFilterCallback(canReleaseObjects, toReleaseCount, expireTime);
if (toReleaseObjects == null || toReleaseObjects.Count <= 0)
{
return;
}
//遍历实际要释放的对象
foreach (ObjectBase toReleaseObject in toReleaseObjects)
{
if (toReleaseObject == null)
{
Debug.LogError("无法释放空对象");
}
foreach (ObjectBase obj in m_Objects)
{
if (obj != toReleaseObject)
{
continue;
}
//释放对象
m_Objects.Remove(obj);
obj.Release();
Debug.Log("对象被释放了：" + obj.Name);
break;
}
}
}
/// <summary>
/// 初始化对象池的新实例。
/// </summary>
/// <param name="name">对象池名称。</param>
/// <param name="allowMultiSpawn">是否允许对象被多次获取。</param>
/// <param name="autoReleaseInterval">对象池自动释放可释放对象的间隔秒数。</param>
/// <param name="capacity">对象池的容量。</param>
/// <param name="expireTime">对象池对象过期秒数。</param>
/// <param name="priority">对象池的优先级。</param>
public ObjectPool(string name, bool allowMultiSpawn, float autoReleaseInterval, int capacity, float expireTime, int priority)
: base(name)
{
m_Objects = new Dictionary <string, List <Object <T> > >();
m_ObjectMap = new Dictionary <object, Object <T> >();
m_DefaultReleaseObjectFilterCallback = DefaultReleaseObjectFilterCallback;
m_CachedCanReleaseObjects = new List <T>();
m_CachedToReleaseObjects = new List <T>();
m_AllowMultiSpawn = allowMultiSpawn;
m_AutoReleaseInterval = autoReleaseInterval;
Capacity = capacity;
ExpireTime = expireTime;
m_Priority = priority;
m_AutoReleaseTime = 0f;
}
public void Release(int toReleaseCount, ReleaseObjectFilterCallback <T> releaseObjectFilterCallback)
{
if (releaseObjectFilterCallback == null)
{
throw;
}
m_AutoReleaseTime = 0f;
if (toReleaseCount < 0)
{
toReleaseCount = 0;
}
LinkedList <T> canReleaseObjects = GetCanReleaseObjects();
LinkedList <T> toReleaseObjects = releaseObjectFilterCallback(canReleaseObjects, toReleaseCount, expireTime);
if (toReleaseObjects == null || toReleaseObjects.Count < 0)
{
return;
}
foreach (ObjectBase toReleaseObject in toReleaseObjects)
{
if (toReleaseObject == null)
{
throw;
}
bool found = false;
foreach (Object <T> obj in m_Objects)
{
if (obj.Peek() != m_Objects)
{
continue;
}
m_Objects.Remove(obj);
obj.Release();
Log.Debug();
found = true;
break;
}
if (!found)
{
throw;
}
}
}
///<summary>
///release the releasable object in the object pool.(Update excute interval =AutoReleaseTime)
///</summary>
///<param name = "toReleaseCount" > attempts to release the number of objects </param>
///<param name = "releaseObjectFilterCallback" > release object filter method</param>
public void Release(int toReleaseCount, ReleaseObjectFilterCallback <T> releaseObjectFilterCallback)
{
AutoReleaseTime = 0;
if (toReleaseCount < 0)
{
return;
}
//Calculate object expiration reference time
DateTime expireTime = DateTime.MinValue;
if (m_ExpireTime < float.MaxValue)
{
//expiration reference time=current time - number of expired seconds
expireTime = DateTime.Now.AddSeconds(-m_ExpireTime);
Debug.Log(" expireTime :=" + expireTime);
}
//get the releasable object and the object to be released.
LinkedList <T> canReleaseObjects = GetCanReleaseObjects();
LinkedList <T> toReleaseObjects = releaseObjectFilterCallback(canReleaseObjects, toReleaseCount, expireTime);
if (toReleaseObjects == null || toReleaseObjects.Count < 0)
{
return;
}
foreach (ObjectBase toReleaseObject in toReleaseObjects)
{
if (toReleaseObject == null)
{
Debug.LogError("Can't release Object");
}
foreach (ObjectBase obj in m_Objects)
{
if (obj != toReleaseObject)
{
continue;
}
m_Objects.Remove(obj);
obj.Release();
Debug.Log("Obj is being Release" + obj.Name);
break;
}
}
}
/// <summary>
/// 释放对象池中的可释放对象。
/// </summary>
/// <param name="releaseObjectFilterCallback">释放对象筛选函数。</param>
public void Release(ReleaseObjectFilterCallback <T> releaseObjectFilterCallback)
{
Release(Count - m_Capacity, releaseObjectFilterCallback);
}
