diff --git a/Convention/[Architecture]/Architecture.cs b/Convention/[Architecture]/Architecture.cs
index 26dcf87..0a9d5d7 100644
--- a/Convention/[Architecture]/Architecture.cs
+++ b/Convention/[Architecture]/Architecture.cs
@@ -1,4 +1,7 @@
+using Convention.Collections;
+using Convention.Collections.Generic;
 using Convention.Experimental.PublicType;
+using Convention.ReferenceManagement;
 using System;
 using System.Collections.Generic;
 
diff --git a/Convention/[Architecture]/Modules/ActionManager.cs.meta b/Convention/[Architecture]/Modules/ActionManager.cs.meta
new file mode 100644
index 0000000..5a4b2d4
--- /dev/null
+++ b/Convention/[Architecture]/Modules/ActionManager.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d8ac4985ed7261b4eb47642f5a27a1f5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Convention/[Architecture]/PublicType/LinkedCacheList.cs b/Convention/[Architecture]/PublicType/LinkedCacheList.cs
index edaaa73..b9a37cc 100644
--- a/Convention/[Architecture]/PublicType/LinkedCacheList.cs
+++ b/Convention/[Architecture]/PublicType/LinkedCacheList.cs
@@ -7,449 +7,4 @@ using UnityEngine;
 namespace Convention.Experimental.PublicType
 {
 
-    /// <summary>
-    /// 附带有缓存机制的链表类。
-    /// </summary>
-    /// <typeparam name="T">指定链表的元素类型。</typeparam>
-    public sealed class LinkedCacheList<T> : ICollection<T>, IEnumerable<T>, ICollection, IEnumerable
-    {
-        private readonly LinkedList<T> m_LinkedList;
-        /// <summary>
-        /// 之所以需要这套缓存机制，主要有三点好处：
-        /// <list type="bullet">减少 GC 压力：大量频繁的插入/删除会产生很多短生命周期的节点对象，通过复用可以显著降低托管堆的分配与回收次数</list>
-        /// <list type="bullet">提升性能：避免频繁 new 和 GC，能减少停顿时间，提高链表在高频操作场景下的吞吐</list>
-        /// <list type="bullet">便于观察与管理：类中还提供了 CachedNodeCount 方便调试统计缓存规模，必要时可通过 ClearCachedNodes 主动释放</list>
-        /// 适用场景是节点使用模式“高频增删但总量有限”，此时缓存能稳定性能；若链表规模始终在增长且很少释放，缓存收益会较低。
-        /// </summary>
-        private readonly Queue<LinkedListNode<T>> m_CachedNodes;
-
-        /// <summary>
-        /// 初始化游戏框架链表类的新实例。
-        /// </summary>
-        public LinkedCacheList()
-        {
-            m_LinkedList = new LinkedList<T>();
-            m_CachedNodes = new Queue<LinkedListNode<T>>();
-        }
-
-        /// <summary>
-        /// 获取链表中实际包含的结点数量。
-        /// </summary>
-        public int Count
-        {
-            get
-            {
-                return m_LinkedList.Count;
-            }
-        }
-
-        /// <summary>
-        /// 获取链表结点缓存数量。
-        /// </summary>
-        public int CachedNodeCount
-        {
-            get
-            {
-                return m_CachedNodes.Count;
-            }
-        }
-
-        /// <summary>
-        /// 获取链表的第一个结点。
-        /// </summary>
-        public LinkedListNode<T> First
-        {
-            get
-            {
-                return m_LinkedList.First;
-            }
-        }
-
-        /// <summary>
-        /// 获取链表的最后一个结点。
-        /// </summary>
-        public LinkedListNode<T> Last
-        {
-            get
-            {
-                return m_LinkedList.Last;
-            }
-        }
-
-        /// <summary>
-        /// 获取一个值，该值指示 ICollection`1 是否为只读。
-        /// </summary>
-        public bool IsReadOnly
-        {
-            get
-            {
-                return ((ICollection<T>)m_LinkedList).IsReadOnly;
-            }
-        }
-
-        /// <summary>
-        /// 获取可用于同步对 ICollection 的访问的对象。
-        /// </summary>
-        public object SyncRoot
-        {
-            get
-            {
-                return ((ICollection)m_LinkedList).SyncRoot;
-            }
-        }
-
-        /// <summary>
-        /// 获取一个值，该值指示是否同步对 ICollection 的访问（线程安全）。
-        /// </summary>
-        public bool IsSynchronized
-        {
-            get
-            {
-                return ((ICollection)m_LinkedList).IsSynchronized;
-            }
-        }
-
-        /// <summary>
-        /// 在链表中指定的现有结点后添加包含指定值的新结点。
-        /// </summary>
-        /// <param name="node">指定的现有结点。</param>
-        /// <param name="value">指定值。</param>
-        /// <returns>包含指定值的新结点。</returns>
-        public LinkedListNode<T> AddAfter(LinkedListNode<T> node, T value)
-        {
-            LinkedListNode<T> newNode = AcquireNode(value);
-            m_LinkedList.AddAfter(node, newNode);
-            return newNode;
-        }
-
-        /// <summary>
-        /// 在链表中指定的现有结点后添加指定的新结点。
-        /// </summary>
-        /// <param name="node">指定的现有结点。</param>
-        /// <param name="newNode">指定的新结点。</param>
-        public void AddAfter(LinkedListNode<T> node, LinkedListNode<T> newNode)
-        {
-            m_LinkedList.AddAfter(node, newNode);
-        }
-
-        /// <summary>
-        /// 在链表中指定的现有结点前添加包含指定值的新结点。
-        /// </summary>
-        /// <param name="node">指定的现有结点。</param>
-        /// <param name="value">指定值。</param>
-        /// <returns>包含指定值的新结点。</returns>
-        public LinkedListNode<T> AddBefore(LinkedListNode<T> node, T value)
-        {
-            LinkedListNode<T> newNode = AcquireNode(value);
-            m_LinkedList.AddBefore(node, newNode);
-            return newNode;
-        }
-
-        /// <summary>
-        /// 在链表中指定的现有结点前添加指定的新结点。
-        /// </summary>
-        /// <param name="node">指定的现有结点。</param>
-        /// <param name="newNode">指定的新结点。</param>
-        public void AddBefore(LinkedListNode<T> node, LinkedListNode<T> newNode)
-        {
-            m_LinkedList.AddBefore(node, newNode);
-        }
-
-        /// <summary>
-        /// 在链表的开头处添加包含指定值的新结点。
-        /// </summary>
-        /// <param name="value">指定值。</param>
-        /// <returns>包含指定值的新结点。</returns>
-        public LinkedListNode<T> AddFirst(T value)
-        {
-            LinkedListNode<T> node = AcquireNode(value);
-            m_LinkedList.AddFirst(node);
-            return node;
-        }
-
-        /// <summary>
-        /// 在链表的开头处添加指定的新结点。
-        /// </summary>
-        /// <param name="node">指定的新结点。</param>
-        public void AddFirst(LinkedListNode<T> node)
-        {
-            m_LinkedList.AddFirst(node);
-        }
-
-        /// <summary>
-        /// 在链表的结尾处添加包含指定值的新结点。
-        /// </summary>
-        /// <param name="value">指定值。</param>
-        /// <returns>包含指定值的新结点。</returns>
-        public LinkedListNode<T> AddLast(T value)
-        {
-            LinkedListNode<T> node = AcquireNode(value);
-            m_LinkedList.AddLast(node);
-            return node;
-        }
-
-        /// <summary>
-        /// 在链表的结尾处添加指定的新结点。
-        /// </summary>
-        /// <param name="node">指定的新结点。</param>
-        public void AddLast(LinkedListNode<T> node)
-        {
-            m_LinkedList.AddLast(node);
-        }
-
-        /// <summary>
-        /// 从链表中移除所有结点。
-        /// </summary>
-        public void Clear()
-        {
-            LinkedListNode<T> current = m_LinkedList.First;
-            while (current != null)
-            {
-                ReleaseNode(current);
-                current = current.Next;
-            }
-
-            m_LinkedList.Clear();
-        }
-
-        /// <summary>
-        /// 清除链表结点缓存。
-        /// </summary>
-        public void ClearCachedNodes()
-        {
-            m_CachedNodes.Clear();
-        }
-
-        /// <summary>
-        /// 确定某值是否在链表中。
-        /// </summary>
-        /// <param name="value">指定值。</param>
-        /// <returns>某值是否在链表中。</returns>
-        public bool Contains(T value)
-        {
-            return m_LinkedList.Contains(value);
-        }
-
-        /// <summary>
-        /// 从目标数组的指定索引处开始将整个链表复制到兼容的一维数组。
-        /// </summary>
-        /// <param name="array">一维数组，它是从链表复制的元素的目标。数组必须具有从零开始的索引。</param>
-        /// <param name="index">array 中从零开始的索引，从此处开始复制。</param>
-        public void CopyTo(T[] array, int index)
-        {
-            m_LinkedList.CopyTo(array, index);
-        }
-
-        /// <summary>
-        /// 从特定的 ICollection 索引开始，将数组的元素复制到一个数组中。
-        /// </summary>
-        /// <param name="array">一维数组，它是从 ICollection 复制的元素的目标。数组必须具有从零开始的索引。</param>
-        /// <param name="index">array 中从零开始的索引，从此处开始复制。</param>
-        public void CopyTo(Array array, int index)
-        {
-            ((ICollection)m_LinkedList).CopyTo(array, index);
-        }
-
-        /// <summary>
-        /// 查找包含指定值的第一个结点。
-        /// </summary>
-        /// <param name="value">要查找的指定值。</param>
-        /// <returns>包含指定值的第一个结点。</returns>
-        public LinkedListNode<T> Find(T value)
-        {
-            return m_LinkedList.Find(value);
-        }
-
-        /// <summary>
-        /// 查找包含指定值的最后一个结点。
-        /// </summary>
-        /// <param name="value">要查找的指定值。</param>
-        /// <returns>包含指定值的最后一个结点。</returns>
-        public LinkedListNode<T> FindLast(T value)
-        {
-            return m_LinkedList.FindLast(value);
-        }
-
-        /// <summary>
-        /// 从链表中移除指定值的第一个匹配项。
-        /// </summary>
-        /// <param name="value">指定值。</param>
-        /// <returns>是否移除成功。</returns>
-        public bool Remove(T value)
-        {
-            LinkedListNode<T> node = m_LinkedList.Find(value);
-            if (node != null)
-            {
-                m_LinkedList.Remove(node);
-                ReleaseNode(node);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// 从链表中移除指定的结点。
-        /// </summary>
-        /// <param name="node">指定的结点。</param>
-        public void Remove(LinkedListNode<T> node)
-        {
-            m_LinkedList.Remove(node);
-            ReleaseNode(node);
-        }
-
-        /// <summary>
-        /// 移除位于链表开头处的结点。
-        /// </summary>
-        public void RemoveFirst()
-        {
-            LinkedListNode<T> first = m_LinkedList.First;
-            if (first == null)
-            {
-                throw new GameException("First is invalid.");
-            }
-
-            m_LinkedList.RemoveFirst();
-            ReleaseNode(first);
-        }
-
-        /// <summary>
-        /// 移除位于链表结尾处的结点。
-        /// </summary>
-        public void RemoveLast()
-        {
-            LinkedListNode<T> last = m_LinkedList.Last;
-            if (last == null)
-            {
-                throw new GameException("Last is invalid.");
-            }
-
-            m_LinkedList.RemoveLast();
-            ReleaseNode(last);
-        }
-
-        /// <summary>
-        /// 返回循环访问集合的枚举数。
-        /// </summary>
-        /// <returns>循环访问集合的枚举数。</returns>
-        public Enumerator GetEnumerator()
-        {
-            return new Enumerator(m_LinkedList);
-        }
-
-        private LinkedListNode<T> AcquireNode(T value)
-        {
-            LinkedListNode<T> node = null;
-            if (m_CachedNodes.Count > 0)
-            {
-                node = m_CachedNodes.Dequeue();
-                node.Value = value;
-            }
-            else
-            {
-                node = new LinkedListNode<T>(value);
-            }
-
-            return node;
-        }
-
-        private void ReleaseNode(LinkedListNode<T> node)
-        {
-            node.Value = default(T);
-            m_CachedNodes.Enqueue(node);
-        }
-
-        /// <summary>
-        /// 将值添加到 ICollection`1 的结尾处。
-        /// </summary>
-        /// <param name="value">要添加的值。</param>
-        void ICollection<T>.Add(T value)
-        {
-            AddLast(value);
-        }
-
-        /// <summary>
-        /// 返回循环访问集合的枚举数。
-        /// </summary>
-        /// <returns>循环访问集合的枚举数。</returns>
-        IEnumerator<T> IEnumerable<T>.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
-
-        /// <summary>
-        /// 返回循环访问集合的枚举数。
-        /// </summary>
-        /// <returns>循环访问集合的枚举数。</returns>
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
-
-        /// <summary>
-        /// 循环访问集合的枚举数。
-        /// </summary>
-        [StructLayout(LayoutKind.Auto)]
-        public struct Enumerator : IEnumerator<T>, IEnumerator
-        {
-            private LinkedList<T>.Enumerator m_Enumerator;
-
-            internal Enumerator(LinkedList<T> linkedList)
-            {
-                if (linkedList == null)
-                {
-                    throw new GameException("Linked list is invalid.");
-                }
-
-                m_Enumerator = linkedList.GetEnumerator();
-            }
-
-            /// <summary>
-            /// 获取当前结点。
-            /// </summary>
-            public T Current
-            {
-                get
-                {
-                    return m_Enumerator.Current;
-                }
-            }
-
-            /// <summary>
-            /// 获取当前的枚举数。
-            /// </summary>
-            object IEnumerator.Current
-            {
-                get
-                {
-                    return m_Enumerator.Current;
-                }
-            }
-
-            /// <summary>
-            /// 清理枚举数。
-            /// </summary>
-            public void Dispose()
-            {
-                m_Enumerator.Dispose();
-            }
-
-            /// <summary>
-            /// 获取下一个结点。
-            /// </summary>
-            /// <returns>返回下一个结点。</returns>
-            public bool MoveNext()
-            {
-                return m_Enumerator.MoveNext();
-            }
-
-            /// <summary>
-            /// 重置枚举数。
-            /// </summary>
-            void IEnumerator.Reset()
-            {
-                ((IEnumerator<T>)m_Enumerator).Reset();
-            }
-        }
-    }
 }
diff --git a/Convention/[Architecture]/PublicType/ReferencePool.cs b/Convention/[Architecture]/PublicType/ReferencePool.cs
index f6bfbd9..20d2569 100644
--- a/Convention/[Architecture]/PublicType/ReferencePool.cs
+++ b/Convention/[Architecture]/PublicType/ReferencePool.cs
@@ -7,485 +7,4 @@ using UnityEngine;
 
 namespace Convention.Experimental.PublicType
 {
-    /// <summary>
-    /// ���ýӿڡ�
-    /// </summary>
-    public interface IReference
-    {
-        /// <summary>
-        /// �������á�
-        /// </summary>
-        void Clear();
-    }
-
-    /// <summary>
-    /// ���ó�
-    /// </summary>
-    public static partial class ReferencePool
-    {
-        private static bool m_EnableStrictCheck = false;
-
-        /// <summary>
-        /// ��ȡ�������Ƿ���ǿ�Ƽ��
-        /// </summary>
-        public static bool EnableStrictCheck
-        {
-            get
-            {
-                return m_EnableStrictCheck;
-            }
-            set
-            {
-                m_EnableStrictCheck = value;
-            }
-        }
-
-
-        private sealed class ReferenceCollection
-        {
-            private readonly Queue<IReference> m_References;
-            private readonly Type m_ReferenceType;
-            private int m_UsingReferenceCount;
-            private int m_AcquireReferenceCount;
-            private int m_ReleaseReferenceCount;
-            private int m_AddReferenceCount;
-            private int m_RemoveReferenceCount;
-
-            public ReferenceCollection(Type referenceType)
-            {
-                m_References = new Queue<IReference>();
-                m_ReferenceType = referenceType;
-                m_UsingReferenceCount = 0;
-                m_AcquireReferenceCount = 0;
-                m_ReleaseReferenceCount = 0;
-                m_AddReferenceCount = 0;
-                m_RemoveReferenceCount = 0;
-            }
-
-            public Type ReferenceType
-            {
-                get
-                {
-                    return m_ReferenceType;
-                }
-            }
-
-            public int UnusedReferenceCount
-            {
-                get
-                {
-                    return m_References.Count;
-                }
-            }
-
-            public int UsingReferenceCount
-            {
-                get
-                {
-                    return m_UsingReferenceCount;
-                }
-            }
-
-            public int AcquireReferenceCount
-            {
-                get
-                {
-                    return m_AcquireReferenceCount;
-                }
-            }
-
-            public int ReleaseReferenceCount
-            {
-                get
-                {
-                    return m_ReleaseReferenceCount;
-                }
-            }
-
-            public int AddReferenceCount
-            {
-                get
-                {
-                    return m_AddReferenceCount;
-                }
-            }
-
-            public int RemoveReferenceCount
-            {
-                get
-                {
-                    return m_RemoveReferenceCount;
-                }
-            }
-
-            public T Acquire<T>() where T : class, IReference, new()
-            {
-                if (typeof(T) != m_ReferenceType)
-                {
-                    throw new GameException("Type is invalid.");
-                }
-
-                m_UsingReferenceCount++;
-                m_AcquireReferenceCount++;
-                lock (m_References)
-                {
-                    if (m_References.Count > 0)
-                    {
-                        return (T)m_References.Dequeue();
-                    }
-                }
-
-                m_AddReferenceCount++;
-                return new T();
-            }
-
-            public IReference Acquire()
-            {
-                m_UsingReferenceCount++;
-                m_AcquireReferenceCount++;
-                lock (m_References)
-                {
-                    if (m_References.Count > 0)
-                    {
-                        return m_References.Dequeue();
-                    }
-                }
-
-                m_AddReferenceCount++;
-                return (IReference)Activator.CreateInstance(m_ReferenceType);
-            }
-
-            public void Release(IReference reference)
-            {
-                reference.Clear();
-                lock (m_References)
-                {
-                    if (m_EnableStrictCheck && m_References.Contains(reference))
-                    {
-                        throw new GameException("The reference has been released.");
-                    }
-
-                    m_References.Enqueue(reference);
-                }
-
-                m_ReleaseReferenceCount++;
-                m_UsingReferenceCount--;
-            }
-
-            public void Add<T>(int count) where T : class, IReference, new()
-            {
-                if (typeof(T) != m_ReferenceType)
-                {
-                    throw new GameException("Type is invalid.");
-                }
-
-                lock (m_References)
-                {
-                    m_AddReferenceCount += count;
-                    while (count-- > 0)
-                    {
-                        m_References.Enqueue(new T());
-                    }
-                }
-            }
-
-            public void Add(int count)
-            {
-                lock (m_References)
-                {
-                    m_AddReferenceCount += count;
-                    while (count-- > 0)
-                    {
-                        m_References.Enqueue((IReference)Activator.CreateInstance(m_ReferenceType));
-                    }
-                }
-            }
-
-            public void Remove(int count)
-            {
-                lock (m_References)
-                {
-                    if (count > m_References.Count)
-                    {
-                        count = m_References.Count;
-                    }
-
-                    m_RemoveReferenceCount += count;
-                    while (count-- > 0)
-                    {
-                        m_References.Dequeue();
-                    }
-                }
-            }
-
-            public void RemoveAll()
-            {
-                lock (m_References)
-                {
-                    m_RemoveReferenceCount += m_References.Count;
-                    m_References.Clear();
-                }
-            }
-        }
-
-        private static readonly Dictionary<Type, ReferenceCollection> s_ReferenceCollections = new();
-
-        /// <summary>
-        /// ��ȡ���óص�������
-        /// </summary>
-        public static int Count
-        {
-            get
-            {
-                return s_ReferenceCollections.Count;
-            }
-        }
-
-        /// <summary>
-        /// ���ó���Ϣ
-        /// </summary>
-        [StructLayout(LayoutKind.Auto)]
-        public readonly struct ReferencePoolInfo
-        {
-            /// <summary>
-            /// ������
-            /// </summary>
-            public readonly Type Type;
-            /// <summary>
-            /// δʹ����������
-            /// </summary>
-            public readonly int UnusedReferenceCount;
-            /// <summary>
-            /// ����ʹ����������
-            /// </summary>
-            public readonly int UsingReferenceCount;
-            /// <summary>
-            /// ��ȡ��������
-            /// </summary>
-            public readonly int AcquireReferenceCount;
-            /// <summary>
-            /// �黹��������
-            /// </summary>
-            public readonly int ReleaseReferenceCount;
-            /// <summary>
-            /// ������������
-            /// </summary>
-            public readonly int AddReferenceCount;
-            /// <summary>
-            /// �Ƴ���������
-            /// </summary>
-            public readonly int RemoveReferenceCount;
-
-            /// <summary>
-            /// ��ʼ�����ó���Ϣ����ʵ����
-            /// </summary>
-            /// <param name="type">���ó����͡�</param>
-            /// <param name="unusedReferenceCount">δʹ������������</param>
-            /// <param name="usingReferenceCount">����ʹ������������</param>
-            /// <param name="acquireReferenceCount">��ȡ����������</param>
-            /// <param name="releaseReferenceCount">�黹����������</param>
-            /// <param name="addReferenceCount">��������������</param>
-            /// <param name="removeReferenceCount">�Ƴ�����������</param>
-            public ReferencePoolInfo(Type type,
-                                     int unusedReferenceCount,
-                                     int usingReferenceCount,
-                                     int acquireReferenceCount,
-                                     int releaseReferenceCount,
-                                     int addReferenceCount,
-                                     int removeReferenceCount)
-            {
-                this.Type = type;
-                this.UnusedReferenceCount = unusedReferenceCount;
-                this.UsingReferenceCount = usingReferenceCount;
-                this.AcquireReferenceCount = acquireReferenceCount;
-                this.ReleaseReferenceCount = releaseReferenceCount;
-                this.AddReferenceCount = addReferenceCount;
-                this.RemoveReferenceCount = removeReferenceCount;
-            }
-        }
-
-        /// <summary>
-        /// ��ȡ�������óص���Ϣ
-        /// </summary>
-        /// <returns>�������óص���Ϣ</returns>
-        public static ReferencePoolInfo[] GetAllReferencePoolInfos()
-        {
-            int index = 0;
-            ReferencePoolInfo[] results = null;
-
-            lock (s_ReferenceCollections)
-            {
-                results = new ReferencePoolInfo[s_ReferenceCollections.Count];
-                foreach (var (key,value) in s_ReferenceCollections)
-                {
-                    results[index++] = new ReferencePoolInfo(key,
-                                                             value.UnusedReferenceCount,
-                                                             value.UsingReferenceCount,
-                                                             value.AcquireReferenceCount,
-                                                             value.ReleaseReferenceCount,
-                                                             value.AddReferenceCount,
-                                                             value.RemoveReferenceCount);
-                }
-            }
-
-            return results;
-        }
-
-        /// <summary>
-        /// ����������ó�
-        /// </summary>
-        public static void ClearAll()
-        {
-            lock (s_ReferenceCollections)
-            {
-                foreach (var (_, value) in s_ReferenceCollections)
-                {
-                    value.RemoveAll();
-                }
-
-                s_ReferenceCollections.Clear();
-            }
-        }
-
-        private static ReferenceCollection GetReferenceCollection(Type referenceType)
-        {
-            if (referenceType == null)
-            {
-                throw new GameException("ReferenceType is invalid.");
-            }
-
-            ReferenceCollection referenceCollection = null;
-            lock (s_ReferenceCollections)
-            {
-                if (!s_ReferenceCollections.TryGetValue(referenceType, out referenceCollection))
-                {
-                    referenceCollection = new ReferenceCollection(referenceType);
-                    s_ReferenceCollections.Add(referenceType, referenceCollection);
-                }
-            }
-
-            return referenceCollection;
-        }
-
-        private static void InternalCheckReferenceType(Type referenceType)
-        {
-            if (!m_EnableStrictCheck)
-            {
-                return;
-            }
-
-            if (referenceType == null)
-            {
-                throw new GameException("Reference type is invalid.");
-            }
-
-            if (!referenceType.IsClass || referenceType.IsAbstract)
-            {
-                throw new GameException("Reference type is not a non-abstract class type.");
-            }
-
-            if (!typeof(IReference).IsAssignableFrom(referenceType))
-            {
-                throw new GameException($"Reference type '{referenceType.FullName}' is invalid.");
-            }
-        }
-
-        /// <summary>
-        /// �����óػ�ȡ����
-        /// </summary>
-        /// <param name="referenceType">��������</param>
-        /// <returns>����</returns>
-        public static IReference Acquire(Type referenceType)
-        {
-            InternalCheckReferenceType(referenceType);
-            return GetReferenceCollection(referenceType).Acquire();
-        }
-
-        /// <summary>
-        /// �����óػ�ȡ����
-        /// </summary>
-        /// <typeparam name="T">��������</typeparam>
-        /// <returns>����</returns>
-        public static T Acquire<T>() where T : class, IReference, new()
-        {
-            return GetReferenceCollection(typeof(T)).Acquire<T>();
-        }
-
-        /// <summary>
-        /// �����ù黹���ó�
-        /// </summary>
-        /// <param name="reference">����</param>
-        public static void Release(IReference reference)
-        {
-            if (reference == null)
-            {
-                throw new GameException("Reference is invalid.");
-            }
-
-            Type referenceType = reference.GetType();
-            InternalCheckReferenceType(referenceType);
-            GetReferenceCollection(referenceType).Release(reference);
-        }
-
-        /// <summary>
-        /// �����ó���׷��ָ������������
-        /// </summary>
-        /// <typeparam name="T">��������</typeparam>
-        /// <param name="count">׷������</param>
-        public static void Add<T>(int count) where T : class, IReference, new()
-        {
-            GetReferenceCollection(typeof(T)).Add<T>(count);
-        }
-
-        /// <summary>
-        /// �����ó���׷��ָ������������
-        /// </summary>
-        /// <param name="referenceType">��������</param>
-        /// <param name="count">׷������</param>
-        public static void Add(Type referenceType, int count)
-        {
-            InternalCheckReferenceType(referenceType);
-            GetReferenceCollection(referenceType).Add(count);
-        }
-
-        /// <summary>
-        /// �����ó����Ƴ�ָ������������
-        /// </summary>
-        /// <typeparam name="T">��������</typeparam>
-        /// <param name="count">�Ƴ�����</param>
-        public static void Remove<T>(int count) where T : class, IReference
-        {
-            GetReferenceCollection(typeof(T)).Remove(count);
-        }
-
-        /// <summary>
-        /// �����ó����Ƴ�ָ������������
-        /// </summary>
-        /// <param name="referenceType">��������</param>
-        /// <param name="count">�Ƴ�����</param>
-        public static void Remove(Type referenceType, int count)
-        {
-            InternalCheckReferenceType(referenceType);
-            GetReferenceCollection(referenceType).Remove(count);
-        }
-
-        /// <summary>
-        /// �����ó����Ƴ����е�����
-        /// </summary>
-        /// <typeparam name="T">��������</typeparam>
-        public static void RemoveAll<T>() where T : class, IReference
-        {
-            GetReferenceCollection(typeof(T)).RemoveAll();
-        }
-
-        /// <summary>
-        /// �����ó����Ƴ����е����á�
-        /// </summary>
-        /// <param name="referenceType">�������͡�</param>
-        public static void RemoveAll(Type referenceType)
-        {
-            InternalCheckReferenceType(referenceType);
-            GetReferenceCollection(referenceType).RemoveAll();
-        }
-    }
 }
\ No newline at end of file
diff --git a/Convention/[Runtime]/Config.cs b/Convention/[Runtime]/Config.cs
index 43631ab..c59e4d7 100644
--- a/Convention/[Runtime]/Config.cs
+++ b/Convention/[Runtime]/Config.cs
@@ -1,4 +1,7 @@
-using System;
+using Convention.Experimental.PublicType;
+using Convention.WindowsUI;
+using Sirenix.Utilities;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
@@ -7,8 +10,6 @@ using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
-using Convention.WindowsUI;
-using Sirenix.Utilities;
 using UnityEditor;
 using UnityEngine;
 using UnityEngine.Events;
@@ -2528,9 +2529,3 @@ namespace Convention
     }
 }
 
-namespace Convention.Collections
-{
-    namespace Generic
-    {
-    }
-}
diff --git a/Convention/[Runtime]/Convention.Collections.cs b/Convention/[Runtime]/Convention.Collections.cs
new file mode 100644
index 0000000..ec79408
--- /dev/null
+++ b/Convention/[Runtime]/Convention.Collections.cs
@@ -0,0 +1,456 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Convention.Collections
+{
+    namespace Generic
+    {
+        /// <summary>
+        /// �����л�����Ƶ�������
+        /// </summary>
+        /// <typeparam name="T">ָ��������Ԫ������</typeparam>
+        public sealed class LinkedCacheList<T> : ICollection<T>, IEnumerable<T>, ICollection, IEnumerable
+        {
+            private readonly LinkedList<T> m_LinkedList;
+            /// <summary>
+            /// ֮������Ҫ���׻�����ƣ���Ҫ������ô���
+            /// <list type="bullet">���� GC ѹ��������Ƶ���IJ���/ɾ��������ܶ���������ڵĽڵ����ͨ�����ÿ������������йܶѵķ�������մ���</list>
+            /// <list type="bullet">�������ܣ�����Ƶ�� new �� GC���ܼ���ͣ��ʱ�䣬��������ڸ�Ƶ���������µ�����</list>
+            /// <list type="bullet">���ڹ۲�����������л��ṩ�� CachedNodeCount �������ͳ�ƻ����ģ����Ҫʱ��ͨ�� ClearCachedNodes �����ͷ�</list>
+            /// ���ó����ǽڵ�ʹ��ģʽ����Ƶ��ɾ���������ޡ�����ʱ�������ȶ����ܣ���������ģʼ���������Һ����ͷţ����������ϵ͡�
+            /// </summary>
+            private readonly Queue<LinkedListNode<T>> m_CachedNodes;
+
+            /// <summary>
+            /// ��ʼ����Ϸ������������ʵ��
+            /// </summary>
+            public LinkedCacheList()
+            {
+                m_LinkedList = new LinkedList<T>();
+                m_CachedNodes = new Queue<LinkedListNode<T>>();
+            }
+
+            /// <summary>
+            /// ��ȡ������ʵ�ʰ����Ľ������
+            /// </summary>
+            public int Count
+            {
+                get
+                {
+                    return m_LinkedList.Count;
+                }
+            }
+
+            /// <summary>
+            /// ��ȡ������㻺������
+            /// </summary>
+            public int CachedNodeCount
+            {
+                get
+                {
+                    return m_CachedNodes.Count;
+                }
+            }
+
+            /// <summary>
+            /// ��ȡ�����ĵ�һ�����
+            /// </summary>
+            public LinkedListNode<T> First
+            {
+                get
+                {
+                    return m_LinkedList.First;
+                }
+            }
+
+            /// <summary>
+            /// ��ȡ���������һ�����
+            /// </summary>
+            public LinkedListNode<T> Last
+            {
+                get
+                {
+                    return m_LinkedList.Last;
+                }
+            }
+
+            /// <summary>
+            /// ��ȡһ��ֵ����ֵָʾ <see cref="ICollection{T}"/> �Ƿ�Ϊֻ��
+            /// </summary>
+            public bool IsReadOnly
+            {
+                get
+                {
+                    return ((ICollection<T>)m_LinkedList).IsReadOnly;
+                }
+            }
+
+            /// <summary>
+            /// ��ȡ������ͬ���� <see cref="ICollection"/> �ķ��ʵĶ���
+            /// </summary>
+            public object SyncRoot
+            {
+                get
+                {
+                    return ((ICollection)m_LinkedList).SyncRoot;
+                }
+            }
+
+            /// <summary>
+            /// ��ȡһ��ֵ����ֵָʾ�Ƿ�ͬ���� <see cref="ICollection"/> �ķ��ʣ��̰߳�ȫ����
+            /// </summary>
+            public bool IsSynchronized
+            {
+                get
+                {
+                    return ((ICollection)m_LinkedList).IsSynchronized;
+                }
+            }
+
+            /// <summary>
+            /// ��������ָ�������н������Ӱ���ָ��ֵ���½��
+            /// </summary>
+            /// <param name="node">ָ�������н��</param>
+            /// <param name="value">ָ��ֵ</param>
+            /// <returns>����ָ��ֵ���½��</returns>
+            public LinkedListNode<T> AddAfter(LinkedListNode<T> node, T value)
+            {
+                LinkedListNode<T> newNode = AcquireNode(value);
+                m_LinkedList.AddAfter(node, newNode);
+                return newNode;
+            }
+
+            /// <summary>
+            /// ��������ָ�������н�������ָ�����½��
+            /// </summary>
+            /// <param name="node">ָ�������н��</param>
+            /// <param name="newNode">ָ�����½��</param>
+            public void AddAfter(LinkedListNode<T> node, LinkedListNode<T> newNode)
+            {
+                m_LinkedList.AddAfter(node, newNode);
+            }
+
+            /// <summary>
+            /// ��������ָ�������н��ǰ���Ӱ���ָ��ֵ���½��
+            /// </summary>
+            /// <param name="node">ָ�������н��</param>
+            /// <param name="value">ָ��ֵ</param>
+            /// <returns>����ָ��ֵ���½��</returns>
+            public LinkedListNode<T> AddBefore(LinkedListNode<T> node, T value)
+            {
+                LinkedListNode<T> newNode = AcquireNode(value);
+                m_LinkedList.AddBefore(node, newNode);
+                return newNode;
+            }
+
+            /// <summary>
+            /// ��������ָ�������н��ǰ����ָ�����½��
+            /// </summary>
+            /// <param name="node">ָ�������н��</param>
+            /// <param name="newNode">ָ�����½��</param>
+            public void AddBefore(LinkedListNode<T> node, LinkedListNode<T> newNode)
+            {
+                m_LinkedList.AddBefore(node, newNode);
+            }
+
+            /// <summary>
+            /// �������Ŀ�ͷ�����Ӱ���ָ��ֵ���½��
+            /// </summary>
+            /// <param name="value">ָ��ֵ</param>
+            /// <returns>����ָ��ֵ���½��</returns>
+            public LinkedListNode<T> AddFirst(T value)
+            {
+                LinkedListNode<T> node = AcquireNode(value);
+                m_LinkedList.AddFirst(node);
+                return node;
+            }
+
+            /// <summary>
+            /// �������Ŀ�ͷ������ָ�����½��
+            /// </summary>
+            /// <param name="node">ָ�����½��</param>
+            public void AddFirst(LinkedListNode<T> node)
+            {
+                m_LinkedList.AddFirst(node);
+            }
+
+            /// <summary>
+            /// �������Ľ�β�����Ӱ���ָ��ֵ���½��
+            /// </summary>
+            /// <param name="value">ָ��ֵ</param>
+            /// <returns>����ָ��ֵ���½��</returns>
+            public LinkedListNode<T> AddLast(T value)
+            {
+                LinkedListNode<T> node = AcquireNode(value);
+                m_LinkedList.AddLast(node);
+                return node;
+            }
+
+            /// <summary>
+            /// �������Ľ�β������ָ�����½��
+            /// </summary>
+            /// <param name="node">ָ�����½��</param>
+            public void AddLast(LinkedListNode<T> node)
+            {
+                m_LinkedList.AddLast(node);
+            }
+
+            /// <summary>
+            /// ���������Ƴ����н��
+            /// </summary>
+            public void Clear()
+            {
+                LinkedListNode<T> current = m_LinkedList.First;
+                while (current != null)
+                {
+                    ReleaseNode(current);
+                    current = current.Next;
+                }
+
+                m_LinkedList.Clear();
+            }
+
+            /// <summary>
+            /// ���������㻺��
+            /// </summary>
+            public void ClearCachedNodes()
+            {
+                m_CachedNodes.Clear();
+            }
+
+            /// <summary>
+            /// ȷ��ijֵ�Ƿ���������
+            /// </summary>
+            /// <param name="value">ָ��ֵ</param>
+            /// <returns>ijֵ�Ƿ���������</returns>
+            public bool Contains(T value)
+            {
+                return m_LinkedList.Contains(value);
+            }
+
+            /// <summary>
+            /// ��Ŀ�������ָ����������ʼ�������������Ƶ����ݵ�һά����
+            /// </summary>
+            /// <param name="array">һά���飬���Ǵ��������Ƶ�Ԫ�ص�Ŀ�ꡣ���������д��㿪ʼ������</param>
+            /// <param name="index">array �д��㿪ʼ���������Ӵ˴���ʼ����</param>
+            public void CopyTo(T[] array, int index)
+            {
+                m_LinkedList.CopyTo(array, index);
+            }
+
+            /// <summary>
+            /// ���ض��� ICollection ������ʼ���������Ԫ�ظ��Ƶ�һ��������
+            /// </summary>
+            /// <param name="array">һά���飬���Ǵ� ICollection ���Ƶ�Ԫ�ص�Ŀ�ꡣ���������д��㿪ʼ������</param>
+            /// <param name="index">array �д��㿪ʼ���������Ӵ˴���ʼ����</param>
+            public void CopyTo(Array array, int index)
+            {
+                ((ICollection)m_LinkedList).CopyTo(array, index);
+            }
+
+            /// <summary>
+            /// ���Ұ���ָ��ֵ�ĵ�һ�����
+            /// </summary>
+            /// <param name="value">Ҫ���ҵ�ָ��ֵ</param>
+            /// <returns>����ָ��ֵ�ĵ�һ�����</returns>
+            public LinkedListNode<T> Find(T value)
+            {
+                return m_LinkedList.Find(value);
+            }
+
+            /// <summary>
+            /// ���Ұ���ָ��ֵ�����һ�����
+            /// </summary>
+            /// <param name="value">Ҫ���ҵ�ָ��ֵ</param>
+            /// <returns>����ָ��ֵ�����һ�����</returns>
+            public LinkedListNode<T> FindLast(T value)
+            {
+                return m_LinkedList.FindLast(value);
+            }
+
+            /// <summary>
+            /// ���������Ƴ�ָ��ֵ�ĵ�һ��ƥ����
+            /// </summary>
+            /// <param name="value">ָ��ֵ</param>
+            /// <returns>�Ƿ��Ƴ��ɹ�</returns>
+            public bool Remove(T value)
+            {
+                LinkedListNode<T> node = m_LinkedList.Find(value);
+                if (node != null)
+                {
+                    m_LinkedList.Remove(node);
+                    ReleaseNode(node);
+                    return true;
+                }
+
+                return false;
+            }
+
+            /// <summary>
+            /// ���������Ƴ�ָ���Ľ��
+            /// </summary>
+            /// <param name="node">ָ���Ľ��</param>
+            public void Remove(LinkedListNode<T> node)
+            {
+                m_LinkedList.Remove(node);
+                ReleaseNode(node);
+            }
+
+            /// <summary>
+            /// �Ƴ�λ��������ͷ���Ľ��
+            /// </summary>
+            public void RemoveFirst()
+            {
+                LinkedListNode<T> first = m_LinkedList.First;
+                if (first == null)
+                {
+                    throw new InvalidOperationException("Rmove first is invalid.");
+                }
+
+                m_LinkedList.RemoveFirst();
+                ReleaseNode(first);
+            }
+
+            /// <summary>
+            /// �Ƴ�λ��������β���Ľ�㡣
+            /// </summary>
+            public void RemoveLast()
+            {
+                LinkedListNode<T> last = m_LinkedList.Last;
+                if (last == null)
+                {
+                    throw new InvalidOperationException("Remove last is invalid.");
+                }
+
+                m_LinkedList.RemoveLast();
+                ReleaseNode(last);
+            }
+
+            /// <summary>
+            /// ����ѭ�����ʼ��ϵ�ö����
+            /// </summary>
+            /// <returns>ѭ�����ʼ��ϵ�ö����</returns>
+            public Enumerator GetEnumerator()
+            {
+                return new Enumerator(m_LinkedList);
+            }
+
+            private LinkedListNode<T> AcquireNode(T value)
+            {
+                LinkedListNode<T> node = null;
+                if (m_CachedNodes.Count > 0)
+                {
+                    node = m_CachedNodes.Dequeue();
+                    node.Value = value;
+                }
+                else
+                {
+                    node = new LinkedListNode<T>(value);
+                }
+
+                return node;
+            }
+
+            private void ReleaseNode(LinkedListNode<T> node)
+            {
+                node.Value = default(T);
+                m_CachedNodes.Enqueue(node);
+            }
+
+            /// <summary>
+            /// ��ֵ���ӵ� ICollection`1 �Ľ�β��
+            /// </summary>
+            /// <param name="value">Ҫ���ӵ�ֵ</param>
+            void ICollection<T>.Add(T value)
+            {
+                AddLast(value);
+            }
+
+            /// <summary>
+            /// ����ѭ�����ʼ��ϵ�ö����
+            /// </summary>
+            /// <returns>ѭ�����ʼ��ϵ�ö����</returns>
+            IEnumerator<T> IEnumerable<T>.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+            /// <summary>
+            /// ����ѭ�����ʼ��ϵ�ö����
+            /// </summary>
+            /// <returns>ѭ�����ʼ��ϵ�ö����</returns>
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+            /// <summary>
+            /// ѭ�����ʼ��ϵ�ö����
+            /// </summary>
+            [StructLayout(LayoutKind.Auto)]
+            public struct Enumerator : IEnumerator<T>, IEnumerator
+            {
+                private LinkedList<T>.Enumerator m_Enumerator;
+
+                internal Enumerator(LinkedList<T> linkedList)
+                {
+                    if (linkedList == null)
+                    {
+                        throw new InvalidOperationException("Linked list is invalid.");
+                    }
+
+                    m_Enumerator = linkedList.GetEnumerator();
+                }
+
+                /// <summary>
+                /// ��ȡ��ǰ���
+                /// </summary>
+                public T Current
+                {
+                    get
+                    {
+                        return m_Enumerator.Current;
+                    }
+                }
+
+                /// <summary>
+                /// ��ȡ��ǰ��ö����
+                /// </summary>
+                object IEnumerator.Current
+                {
+                    get
+                    {
+                        return m_Enumerator.Current;
+                    }
+                }
+
+                /// <summary>
+                /// ����ö����
+                /// </summary>
+                public void Dispose()
+                {
+                    m_Enumerator.Dispose();
+                }
+
+                /// <summary>
+                /// ��ȡ��һ�����
+                /// </summary>
+                /// <returns>������һ�����</returns>
+                public bool MoveNext()
+                {
+                    return m_Enumerator.MoveNext();
+                }
+
+                /// <summary>
+                /// ����ö����
+                /// </summary>
+                void IEnumerator.Reset()
+                {
+                    ((IEnumerator<T>)m_Enumerator).Reset();
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Convention/[Runtime]/Convention.Collections.cs.meta b/Convention/[Runtime]/Convention.Collections.cs.meta
new file mode 100644
index 0000000..bb751a0
--- /dev/null
+++ b/Convention/[Runtime]/Convention.Collections.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a40a6ad3561c922478840f163ea43790
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Convention/[Runtime]/Convention.ReferencePool.cs b/Convention/[Runtime]/Convention.ReferencePool.cs
new file mode 100644
index 0000000..d37f47d
--- /dev/null
+++ b/Convention/[Runtime]/Convention.ReferencePool.cs
@@ -0,0 +1,490 @@
+
+using Convention.Experimental.PublicType;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Convention.ReferenceManagement
+{
+    /// <summary>
+    /// ���ýӿ�
+    /// </summary>
+    public interface IReference
+    {
+        /// <summary>
+        /// ��������
+        /// </summary>
+        void Clear();
+    }
+
+    /// <summary>
+    /// ���ó�
+    /// </summary>
+    public static partial class ReferencePool
+    {
+        private static bool m_EnableStrictCheck = false;
+
+        /// <summary>
+        /// ��ȡ�������Ƿ���ǿ�Ƽ��
+        /// </summary>
+        public static bool EnableStrictCheck
+        {
+            get
+            {
+                return m_EnableStrictCheck;
+            }
+            set
+            {
+                m_EnableStrictCheck = value;
+            }
+        }
+
+
+        private sealed class ReferenceCollection
+        {
+            private readonly Queue<IReference> m_References;
+            private readonly Type m_ReferenceType;
+            private int m_UsingReferenceCount;
+            private int m_AcquireReferenceCount;
+            private int m_ReleaseReferenceCount;
+            private int m_AddReferenceCount;
+            private int m_RemoveReferenceCount;
+
+            public ReferenceCollection(Type referenceType)
+            {
+                m_References = new Queue<IReference>();
+                m_ReferenceType = referenceType;
+                m_UsingReferenceCount = 0;
+                m_AcquireReferenceCount = 0;
+                m_ReleaseReferenceCount = 0;
+                m_AddReferenceCount = 0;
+                m_RemoveReferenceCount = 0;
+            }
+
+            public Type ReferenceType
+            {
+                get
+                {
+                    return m_ReferenceType;
+                }
+            }
+
+            public int UnusedReferenceCount
+            {
+                get
+                {
+                    return m_References.Count;
+                }
+            }
+
+            public int UsingReferenceCount
+            {
+                get
+                {
+                    return m_UsingReferenceCount;
+                }
+            }
+
+            public int AcquireReferenceCount
+            {
+                get
+                {
+                    return m_AcquireReferenceCount;
+                }
+            }
+
+            public int ReleaseReferenceCount
+            {
+                get
+                {
+                    return m_ReleaseReferenceCount;
+                }
+            }
+
+            public int AddReferenceCount
+            {
+                get
+                {
+                    return m_AddReferenceCount;
+                }
+            }
+
+            public int RemoveReferenceCount
+            {
+                get
+                {
+                    return m_RemoveReferenceCount;
+                }
+            }
+
+            public T Acquire<T>() where T : class, IReference, new()
+            {
+                if (typeof(T) != m_ReferenceType)
+                {
+                    throw new GameException("Type is invalid.");
+                }
+
+                m_UsingReferenceCount++;
+                m_AcquireReferenceCount++;
+                lock (m_References)
+                {
+                    if (m_References.Count > 0)
+                    {
+                        return (T)m_References.Dequeue();
+                    }
+                }
+
+                m_AddReferenceCount++;
+                return new T();
+            }
+
+            public IReference Acquire()
+            {
+                m_UsingReferenceCount++;
+                m_AcquireReferenceCount++;
+                lock (m_References)
+                {
+                    if (m_References.Count > 0)
+                    {
+                        return m_References.Dequeue();
+                    }
+                }
+
+                m_AddReferenceCount++;
+                return (IReference)Activator.CreateInstance(m_ReferenceType);
+            }
+
+            public void Release(IReference reference)
+            {
+                reference.Clear();
+                lock (m_References)
+                {
+                    if (m_EnableStrictCheck && m_References.Contains(reference))
+                    {
+                        throw new GameException("The reference has been released.");
+                    }
+
+                    m_References.Enqueue(reference);
+                }
+
+                m_ReleaseReferenceCount++;
+                m_UsingReferenceCount--;
+            }
+
+            public void Add<T>(int count) where T : class, IReference, new()
+            {
+                if (typeof(T) != m_ReferenceType)
+                {
+                    throw new GameException("Type is invalid.");
+                }
+
+                lock (m_References)
+                {
+                    m_AddReferenceCount += count;
+                    while (count-- > 0)
+                    {
+                        m_References.Enqueue(new T());
+                    }
+                }
+            }
+
+            public void Add(int count)
+            {
+                lock (m_References)
+                {
+                    m_AddReferenceCount += count;
+                    while (count-- > 0)
+                    {
+                        m_References.Enqueue((IReference)Activator.CreateInstance(m_ReferenceType));
+                    }
+                }
+            }
+
+            public void Remove(int count)
+            {
+                lock (m_References)
+                {
+                    if (count > m_References.Count)
+                    {
+                        count = m_References.Count;
+                    }
+
+                    m_RemoveReferenceCount += count;
+                    while (count-- > 0)
+                    {
+                        m_References.Dequeue();
+                    }
+                }
+            }
+
+            public void RemoveAll()
+            {
+                lock (m_References)
+                {
+                    m_RemoveReferenceCount += m_References.Count;
+                    m_References.Clear();
+                }
+            }
+        }
+
+        private static readonly Dictionary<Type, ReferenceCollection> s_ReferenceCollections = new();
+
+        /// <summary>
+        /// ��ȡ���óص�������
+        /// </summary>
+        public static int Count
+        {
+            get
+            {
+                return s_ReferenceCollections.Count;
+            }
+        }
+
+        /// <summary>
+        /// ���ó���Ϣ
+        /// </summary>
+        [StructLayout(LayoutKind.Auto)]
+        public readonly struct ReferencePoolInfo
+        {
+            /// <summary>
+            /// ������
+            /// </summary>
+            public readonly Type Type;
+            /// <summary>
+            /// δʹ����������
+            /// </summary>
+            public readonly int UnusedReferenceCount;
+            /// <summary>
+            /// ����ʹ����������
+            /// </summary>
+            public readonly int UsingReferenceCount;
+            /// <summary>
+            /// ��ȡ��������
+            /// </summary>
+            public readonly int AcquireReferenceCount;
+            /// <summary>
+            /// �黹��������
+            /// </summary>
+            public readonly int ReleaseReferenceCount;
+            /// <summary>
+            /// ������������
+            /// </summary>
+            public readonly int AddReferenceCount;
+            /// <summary>
+            /// �Ƴ���������
+            /// </summary>
+            public readonly int RemoveReferenceCount;
+
+            /// <summary>
+            /// ��ʼ�����ó���Ϣ����ʵ����
+            /// </summary>
+            /// <param name="type">���ó����͡�</param>
+            /// <param name="unusedReferenceCount">δʹ������������</param>
+            /// <param name="usingReferenceCount">����ʹ������������</param>
+            /// <param name="acquireReferenceCount">��ȡ����������</param>
+            /// <param name="releaseReferenceCount">�黹����������</param>
+            /// <param name="addReferenceCount">��������������</param>
+            /// <param name="removeReferenceCount">�Ƴ�����������</param>
+            public ReferencePoolInfo(Type type,
+                                     int unusedReferenceCount,
+                                     int usingReferenceCount,
+                                     int acquireReferenceCount,
+                                     int releaseReferenceCount,
+                                     int addReferenceCount,
+                                     int removeReferenceCount)
+            {
+                this.Type = type;
+                this.UnusedReferenceCount = unusedReferenceCount;
+                this.UsingReferenceCount = usingReferenceCount;
+                this.AcquireReferenceCount = acquireReferenceCount;
+                this.ReleaseReferenceCount = releaseReferenceCount;
+                this.AddReferenceCount = addReferenceCount;
+                this.RemoveReferenceCount = removeReferenceCount;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ�������óص���Ϣ
+        /// </summary>
+        /// <returns>�������óص���Ϣ</returns>
+        public static ReferencePoolInfo[] GetAllReferencePoolInfos()
+        {
+            int index = 0;
+            ReferencePoolInfo[] results = null;
+
+            lock (s_ReferenceCollections)
+            {
+                results = new ReferencePoolInfo[s_ReferenceCollections.Count];
+                foreach (var (key, value) in s_ReferenceCollections)
+                {
+                    results[index++] = new ReferencePoolInfo(key,
+                                                             value.UnusedReferenceCount,
+                                                             value.UsingReferenceCount,
+                                                             value.AcquireReferenceCount,
+                                                             value.ReleaseReferenceCount,
+                                                             value.AddReferenceCount,
+                                                             value.RemoveReferenceCount);
+                }
+            }
+
+            return results;
+        }
+
+        /// <summary>
+        /// ����������ó�
+        /// </summary>
+        public static void ClearAll()
+        {
+            lock (s_ReferenceCollections)
+            {
+                foreach (var (_, value) in s_ReferenceCollections)
+                {
+                    value.RemoveAll();
+                }
+
+                s_ReferenceCollections.Clear();
+            }
+        }
+
+        private static ReferenceCollection GetReferenceCollection(Type referenceType)
+        {
+            if (referenceType == null)
+            {
+                throw new GameException("ReferenceType is invalid.");
+            }
+
+            ReferenceCollection referenceCollection = null;
+            lock (s_ReferenceCollections)
+            {
+                if (!s_ReferenceCollections.TryGetValue(referenceType, out referenceCollection))
+                {
+                    referenceCollection = new ReferenceCollection(referenceType);
+                    s_ReferenceCollections.Add(referenceType, referenceCollection);
+                }
+            }
+
+            return referenceCollection;
+        }
+
+        private static void InternalCheckReferenceType(Type referenceType)
+        {
+            if (!m_EnableStrictCheck)
+            {
+                return;
+            }
+
+            if (referenceType == null)
+            {
+                throw new GameException("Reference type is invalid.");
+            }
+
+            if (!referenceType.IsClass || referenceType.IsAbstract)
+            {
+                throw new GameException("Reference type is not a non-abstract class type.");
+            }
+
+            if (!typeof(IReference).IsAssignableFrom(referenceType))
+            {
+                throw new GameException($"Reference type '{referenceType.FullName}' is invalid.");
+            }
+        }
+
+        /// <summary>
+        /// �����óػ�ȡ����
+        /// </summary>
+        /// <param name="referenceType">��������</param>
+        /// <returns>����</returns>
+        public static IReference Acquire(Type referenceType)
+        {
+            InternalCheckReferenceType(referenceType);
+            return GetReferenceCollection(referenceType).Acquire();
+        }
+
+        /// <summary>
+        /// �����óػ�ȡ����
+        /// </summary>
+        /// <typeparam name="T">��������</typeparam>
+        /// <returns>����</returns>
+        public static T Acquire<T>() where T : class, IReference, new()
+        {
+            return GetReferenceCollection(typeof(T)).Acquire<T>();
+        }
+
+        /// <summary>
+        /// �����ù黹���ó�
+        /// </summary>
+        /// <param name="reference">����</param>
+        public static void Release(IReference reference)
+        {
+            if (reference == null)
+            {
+                throw new GameException("Reference is invalid.");
+            }
+
+            Type referenceType = reference.GetType();
+            InternalCheckReferenceType(referenceType);
+            GetReferenceCollection(referenceType).Release(reference);
+        }
+
+        /// <summary>
+        /// �����ó���׷��ָ������������
+        /// </summary>
+        /// <typeparam name="T">��������</typeparam>
+        /// <param name="count">׷������</param>
+        public static void Add<T>(int count) where T : class, IReference, new()
+        {
+            GetReferenceCollection(typeof(T)).Add<T>(count);
+        }
+
+        /// <summary>
+        /// �����ó���׷��ָ������������
+        /// </summary>
+        /// <param name="referenceType">��������</param>
+        /// <param name="count">׷������</param>
+        public static void Add(Type referenceType, int count)
+        {
+            InternalCheckReferenceType(referenceType);
+            GetReferenceCollection(referenceType).Add(count);
+        }
+
+        /// <summary>
+        /// �����ó����Ƴ�ָ������������
+        /// </summary>
+        /// <typeparam name="T">��������</typeparam>
+        /// <param name="count">�Ƴ�����</param>
+        public static void Remove<T>(int count) where T : class, IReference
+        {
+            GetReferenceCollection(typeof(T)).Remove(count);
+        }
+
+        /// <summary>
+        /// �����ó����Ƴ�ָ������������
+        /// </summary>
+        /// <param name="referenceType">��������</param>
+        /// <param name="count">�Ƴ�����</param>
+        public static void Remove(Type referenceType, int count)
+        {
+            InternalCheckReferenceType(referenceType);
+            GetReferenceCollection(referenceType).Remove(count);
+        }
+
+        /// <summary>
+        /// �����ó����Ƴ����е�����
+        /// </summary>
+        /// <typeparam name="T">��������</typeparam>
+        public static void RemoveAll<T>() where T : class, IReference
+        {
+            GetReferenceCollection(typeof(T)).RemoveAll();
+        }
+
+        /// <summary>
+        /// �����ó����Ƴ����е����á�
+        /// </summary>
+        /// <param name="referenceType">�������͡�</param>
+        public static void RemoveAll(Type referenceType)
+        {
+            InternalCheckReferenceType(referenceType);
+            GetReferenceCollection(referenceType).RemoveAll();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Convention/[Runtime]/Convention.ReferencePool.cs.meta b/Convention/[Runtime]/Convention.ReferencePool.cs.meta
new file mode 100644
index 0000000..1be568d
--- /dev/null
+++ b/Convention/[Runtime]/Convention.ReferencePool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 84ff342f46113f140afa7a506fb879d4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Convention/[Runtime]/Convention.TaskPool.cs b/Convention/[Runtime]/Convention.TaskPool.cs
new file mode 100644
index 0000000..7e26092
--- /dev/null
+++ b/Convention/[Runtime]/Convention.TaskPool.cs
@@ -0,0 +1,803 @@
+using Convention.Collections;
+using Convention.Collections.Generic;
+using Convention.ReferenceManagement;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Convention.TaskManagement
+{
+    /// <summary>
+    /// �������
+    /// </summary>
+    public abstract class TaskBase: IReference
+    {
+        /// <summary>
+        /// ����Ĭ�����ȼ���
+        /// </summary>
+        public const int DefaultPriority = 0;
+
+        private int m_SerialId;
+        private string m_Tag;
+        private int m_Priority;
+        private object m_UserData;
+
+        private bool m_Done;
+
+        /// <summary>
+        /// ��ʼ������������ʵ��
+        /// </summary>
+        public TaskBase()
+        {
+            m_SerialId = 0;
+            m_Tag = null;
+            m_Priority = DefaultPriority;
+            m_Done = false;
+            m_UserData = null;
+        }
+
+        /// <summary>
+        /// ��ȡ��������б��
+        /// </summary>
+        public int SerialId
+        {
+            get
+            {
+                return m_SerialId;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ����ı�ǩ
+        /// </summary>
+        public string Tag
+        {
+            get
+            {
+                return m_Tag;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ��������ȼ�
+        /// </summary>
+        public int Priority
+        {
+            get
+            {
+                return m_Priority;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ������û��Զ�������
+        /// </summary>
+        public object UserData
+        {
+            get
+            {
+                return m_UserData;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ�����������Ƿ����
+        /// </summary>
+        public bool Done
+        {
+            get
+            {
+                return m_Done;
+            }
+            set
+            {
+                m_Done = value;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ��������
+        /// </summary>
+        public virtual string Description
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// ��ʼ���������
+        /// </summary>
+        /// <param name="serialId">���������</param>
+        /// <param name="tag">����ı�ǩ</param>
+        /// <param name="priority">��������ȼ�</param>
+        /// <param name="userData">������û��Զ�������</param>
+        internal void Initialize(int serialId, string tag, int priority, object userData)
+        {
+            m_SerialId = serialId;
+            m_Tag = tag;
+            m_Priority = priority;
+            m_UserData = userData;
+            m_Done = false;
+        }
+
+        /// <summary>
+        /// �����������
+        /// </summary>
+        public virtual void Clear()
+        {
+            m_SerialId = 0;
+            m_Tag = null;
+            m_Priority = DefaultPriority;
+            m_UserData = null;
+            m_Done = false;
+        }
+    }
+
+    /// <summary>
+    /// ��ʼ���������״̬
+    /// </summary>
+    public enum StartTaskStatus : byte
+    {
+        /// <summary>
+        /// �������̴�����ɴ�����
+        /// </summary>
+        Done = 0,
+
+        /// <summary>
+        /// ���Լ�������������
+        /// </summary>
+        CanResume,
+
+        /// <summary>
+        /// ���ܼ���������������ȴ���������ִ�����
+        /// </summary>
+        HasToWait,
+
+        /// <summary>
+        /// ���ܼ������������񣬳���δ֪����
+        /// </summary>
+        UnknownError
+    }
+
+    /// <summary>
+    /// ��������ӿ�
+    /// </summary>
+    /// <typeparam name="T">��������</typeparam>
+    public interface ITaskAgent<T> where T : TaskBase
+    {
+        /// <summary>
+        /// ��ȡ����
+        /// </summary>
+        T Task
+        {
+            get;
+        }
+
+        /// <summary>
+        /// ��ʼ���������
+        /// </summary>
+        void Initialize();
+
+        /// <summary>
+        /// ���������ѯ
+        /// </summary>
+        /// <param name="elapseSeconds">�߼�����ʱ�䣬����Ϊ��λ</param>
+        /// <param name="realElapseSeconds">��ʵ����ʱ�䣬����Ϊ��λ</param>
+        void Update(float elapseSeconds, float realElapseSeconds);
+
+        /// <summary>
+        /// �رղ������������
+        /// </summary>
+        void Shutdown();
+
+        /// <summary>
+        /// ��ʼ��������
+        /// </summary>
+        /// <param name="task">Ҫ����������</param>
+        /// <returns>��ʼ���������״̬</returns>
+        StartTaskStatus Start(T task);
+
+        /// <summary>
+        /// ֹͣ���ڴ��������������������
+        /// </summary>
+        void Reset();
+    }
+
+    /// <summary>
+    /// ����״̬
+    /// </summary>
+    public enum TaskStatus : byte
+    {
+        /// <summary>
+        /// δ��ʼ
+        /// </summary>
+        Todo = 0,
+
+        /// <summary>
+        /// ִ����
+        /// </summary>
+        Doing,
+
+        /// <summary>
+        /// ���
+        /// </summary>
+        Done
+    }
+
+    /// <summary>
+    /// ������Ϣ
+    /// </summary>
+    [StructLayout(LayoutKind.Auto)]
+    public readonly struct TaskInfo
+    {
+        private readonly bool m_IsValid;
+        private readonly int m_SerialId;
+        private readonly string m_Tag;
+        private readonly int m_Priority;
+        private readonly object m_UserData;
+        private readonly TaskStatus m_Status;
+        private readonly string m_Description;
+
+        /// <summary>
+        /// ��ʼ��������Ϣ����ʵ����
+        /// </summary>
+        /// <param name="serialId">���������</param>
+        /// <param name="tag">����ı�ǩ</param>
+        /// <param name="priority">��������ȼ�</param>
+        /// <param name="userData">������û��Զ�������</param>
+        /// <param name="status">����״̬</param>
+        /// <param name="description">��������</param>
+        public TaskInfo(int serialId, string tag, int priority, object userData, TaskStatus status, string description)
+        {
+            m_IsValid = true;
+            m_SerialId = serialId;
+            m_Tag = tag;
+            m_Priority = priority;
+            m_UserData = userData;
+            m_Status = status;
+            m_Description = description;
+        }
+
+        /// <summary>
+        /// ��ȡ������Ϣ�Ƿ���Ч
+        /// </summary>
+        public bool IsValid
+        {
+            get
+            {
+                return m_IsValid;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ��������б��
+        /// </summary>
+        public int SerialId
+        {
+            get
+            {
+                if (!m_IsValid)
+                {
+                    throw new InvalidOperationException("Data is invalid.");
+                }
+
+                return m_SerialId;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ����ı�ǩ
+        /// </summary>
+        public string Tag
+        {
+            get
+            {
+                if (!m_IsValid)
+                {
+                    throw new InvalidOperationException("Data is invalid.");
+                }
+
+                return m_Tag;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ��������ȼ�
+        /// </summary>
+        public int Priority
+        {
+            get
+            {
+                if (!m_IsValid)
+                {
+                    throw new InvalidOperationException("Data is invalid.");
+                }
+
+                return m_Priority;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ������û��Զ�������
+        /// </summary>
+        public object UserData
+        {
+            get
+            {
+                if (!m_IsValid)
+                {
+                    throw new InvalidOperationException("Data is invalid.");
+                }
+
+                return m_UserData;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ����״̬
+        /// </summary>
+        public TaskStatus Status
+        {
+            get
+            {
+                if (!m_IsValid)
+                {
+                    throw new InvalidOperationException("Data is invalid.");
+                }
+
+                return m_Status;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ��������
+        /// </summary>
+        public string Description
+        {
+            get
+            {
+                if (!m_IsValid)
+                {
+                    throw new InvalidOperationException("Data is invalid.");
+                }
+
+                return m_Description;
+            }
+        }
+    }
+
+    /// <summary>
+    /// �����
+    /// </summary>
+    /// <typeparam name="T">��������</typeparam>
+    public class TaskPool<T> where T : TaskBase
+    {
+        private readonly Stack<ITaskAgent<T>> m_FreeAgents;
+        private readonly LinkedCacheList<ITaskAgent<T>> m_WorkingAgents;
+        private readonly LinkedCacheList<T> m_WaitingTasks;
+        private bool m_Paused;
+
+        /// <summary>
+        /// ��ʼ������ص���ʵ����
+        /// </summary>
+        public TaskPool()
+        {
+            m_FreeAgents = new Stack<ITaskAgent<T>>();
+            m_WorkingAgents = new LinkedCacheList<ITaskAgent<T>>();
+            m_WaitingTasks = new LinkedCacheList<T>();
+            m_Paused = false;
+        }
+
+        /// <summary>
+        /// ��ȡ������������Ƿ���ͣ��
+        /// </summary>
+        public bool Paused
+        {
+            get
+            {
+                return m_Paused;
+            }
+            set
+            {
+                m_Paused = value;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ���������������
+        /// </summary>
+        public int TotalAgentCount
+        {
+            get
+            {
+                return FreeAgentCount + WorkingAgentCount;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ�����������������
+        /// </summary>
+        public int FreeAgentCount
+        {
+            get
+            {
+                return m_FreeAgents.Count;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ�������������������
+        /// </summary>
+        public int WorkingAgentCount
+        {
+            get
+            {
+                return m_WorkingAgents.Count;
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ�ȴ�����������
+        /// </summary>
+        public int WaitingTaskCount
+        {
+            get
+            {
+                return m_WaitingTasks.Count;
+            }
+        }
+
+        /// <summary>
+        /// �������ѯ��
+        /// </summary>
+        /// <param name="elapseSeconds">�߼�����ʱ�䣬����Ϊ��λ��</param>
+        /// <param name="realElapseSeconds">��ʵ����ʱ�䣬����Ϊ��λ��</param>
+        public void Update(float elapseSeconds, float realElapseSeconds)
+        {
+            if (m_Paused)
+            {
+                return;
+            }
+
+            ProcessRunningTasks(elapseSeconds, realElapseSeconds);
+            ProcessWaitingTasks(elapseSeconds, realElapseSeconds);
+        }
+
+        /// <summary>
+        /// �رղ���������ء�
+        /// </summary>
+        public void Shutdown()
+        {
+            RemoveAllTasks();
+
+            while (FreeAgentCount > 0)
+            {
+                m_FreeAgents.Pop().Shutdown();
+            }
+        }
+
+        /// <summary>
+        /// �������������
+        /// </summary>
+        /// <param name="agent">Ҫ���ӵ����������</param>
+        public void AddAgent(ITaskAgent<T> agent)
+        {
+            if (agent == null)
+            {
+                throw new InvalidOperationException("Task agent is invalid.");
+            }
+
+            agent.Initialize();
+            m_FreeAgents.Push(agent);
+        }
+
+        /// <summary>
+        /// ������������б�Ż�ȡ�������Ϣ��
+        /// </summary>
+        /// <param name="serialId">Ҫ��ȡ��Ϣ����������б�š�</param>
+        /// <returns>�������Ϣ��</returns>
+        public TaskInfo GetTaskInfo(int serialId)
+        {
+            foreach (ITaskAgent<T> workingAgent in m_WorkingAgents)
+            {
+                T workingTask = workingAgent.Task;
+                if (workingTask.SerialId == serialId)
+                {
+                    return new TaskInfo(workingTask.SerialId, workingTask.Tag, workingTask.Priority, workingTask.UserData, workingTask.Done ? TaskStatus.Done : TaskStatus.Doing, workingTask.Description);
+                }
+            }
+
+            foreach (T waitingTask in m_WaitingTasks)
+            {
+                if (waitingTask.SerialId == serialId)
+                {
+                    return new TaskInfo(waitingTask.SerialId, waitingTask.Tag, waitingTask.Priority, waitingTask.UserData, TaskStatus.Todo, waitingTask.Description);
+                }
+            }
+
+            return default(TaskInfo);
+        }
+
+        /// <summary>
+        /// ��������ı�ǩ��ȡ�������Ϣ��
+        /// </summary>
+        /// <param name="tag">Ҫ��ȡ��Ϣ������ı�ǩ��</param>
+        /// <returns>�������Ϣ��</returns>
+        public TaskInfo[] GetTaskInfos(string tag)
+        {
+            List<TaskInfo> results = new List<TaskInfo>();
+            GetTaskInfos(tag, results);
+            return results.ToArray();
+        }
+
+        /// <summary>
+        /// ��������ı�ǩ��ȡ�������Ϣ��
+        /// </summary>
+        /// <param name="tag">Ҫ��ȡ��Ϣ������ı�ǩ��</param>
+        /// <param name="results">�������Ϣ��</param>
+        public void GetTaskInfos(string tag, List<TaskInfo> results)
+        {
+            if (results == null)
+            {
+                throw new InvalidOperationException("Results is invalid.");
+            }
+
+            results.Clear();
+            foreach (ITaskAgent<T> workingAgent in m_WorkingAgents)
+            {
+                T workingTask = workingAgent.Task;
+                if (workingTask.Tag == tag)
+                {
+                    results.Add(new TaskInfo(workingTask.SerialId, workingTask.Tag, workingTask.Priority, workingTask.UserData, workingTask.Done ? TaskStatus.Done : TaskStatus.Doing, workingTask.Description));
+                }
+            }
+
+            foreach (T waitingTask in m_WaitingTasks)
+            {
+                if (waitingTask.Tag == tag)
+                {
+                    results.Add(new TaskInfo(waitingTask.SerialId, waitingTask.Tag, waitingTask.Priority, waitingTask.UserData, TaskStatus.Todo, waitingTask.Description));
+                }
+            }
+        }
+
+        /// <summary>
+        /// ��ȡ�����������Ϣ��
+        /// </summary>
+        /// <returns>�����������Ϣ��</returns>
+        public TaskInfo[] GetAllTaskInfos()
+        {
+            int index = 0;
+            TaskInfo[] results = new TaskInfo[m_WorkingAgents.Count + m_WaitingTasks.Count];
+            foreach (ITaskAgent<T> workingAgent in m_WorkingAgents)
+            {
+                T workingTask = workingAgent.Task;
+                results[index++] = new TaskInfo(workingTask.SerialId, workingTask.Tag, workingTask.Priority, workingTask.UserData, workingTask.Done ? TaskStatus.Done : TaskStatus.Doing, workingTask.Description);
+            }
+
+            foreach (T waitingTask in m_WaitingTasks)
+            {
+                results[index++] = new TaskInfo(waitingTask.SerialId, waitingTask.Tag, waitingTask.Priority, waitingTask.UserData, TaskStatus.Todo, waitingTask.Description);
+            }
+
+            return results;
+        }
+
+        /// <summary>
+        /// ��ȡ�����������Ϣ��
+        /// </summary>
+        /// <param name="results">�����������Ϣ��</param>
+        public void GetAllTaskInfos(List<TaskInfo> results)
+        {
+            if (results == null)
+            {
+                throw new InvalidOperationException("Results is invalid.");
+            }
+
+            results.Clear();
+            foreach (ITaskAgent<T> workingAgent in m_WorkingAgents)
+            {
+                T workingTask = workingAgent.Task;
+                results.Add(new TaskInfo(workingTask.SerialId, workingTask.Tag, workingTask.Priority, workingTask.UserData, workingTask.Done ? TaskStatus.Done : TaskStatus.Doing, workingTask.Description));
+            }
+
+            foreach (T waitingTask in m_WaitingTasks)
+            {
+                results.Add(new TaskInfo(waitingTask.SerialId, waitingTask.Tag, waitingTask.Priority, waitingTask.UserData, TaskStatus.Todo, waitingTask.Description));
+            }
+        }
+
+        /// <summary>
+        /// ��������
+        /// </summary>
+        /// <param name="task">Ҫ���ӵ�����</param>
+        public void AddTask(T task)
+        {
+            LinkedListNode<T> current = m_WaitingTasks.Last;
+            while (current != null)
+            {
+                if (task.Priority <= current.Value.Priority)
+                {
+                    break;
+                }
+
+                current = current.Previous;
+            }
+
+            if (current != null)
+            {
+                m_WaitingTasks.AddAfter(current, task);
+            }
+            else
+            {
+                m_WaitingTasks.AddFirst(task);
+            }
+        }
+
+        /// <summary>
+        /// ������������б���Ƴ�����
+        /// </summary>
+        /// <param name="serialId">Ҫ�Ƴ���������б�š�</param>
+        /// <returns>�Ƿ��Ƴ�����ɹ���</returns>
+        public bool RemoveTask(int serialId)
+        {
+            foreach (T task in m_WaitingTasks)
+            {
+                if (task.SerialId == serialId)
+                {
+                    m_WaitingTasks.Remove(task);
+                    ReferencePool.Release(task);
+                    return true;
+                }
+            }
+
+            LinkedListNode<ITaskAgent<T>> currentWorkingAgent = m_WorkingAgents.First;
+            while (currentWorkingAgent != null)
+            {
+                LinkedListNode<ITaskAgent<T>> next = currentWorkingAgent.Next;
+                ITaskAgent<T> workingAgent = currentWorkingAgent.Value;
+                T task = workingAgent.Task;
+                if (task.SerialId == serialId)
+                {
+                    workingAgent.Reset();
+                    m_FreeAgents.Push(workingAgent);
+                    m_WorkingAgents.Remove(currentWorkingAgent);
+                    ReferencePool.Release(task);
+                    return true;
+                }
+
+                currentWorkingAgent = next;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// ��������ı�ǩ�Ƴ�����
+        /// </summary>
+        /// <param name="tag">Ҫ�Ƴ�����ı�ǩ��</param>
+        /// <returns>�Ƴ������������</returns>
+        public int RemoveTasks(string tag)
+        {
+            int count = 0;
+
+            LinkedListNode<T> currentWaitingTask = m_WaitingTasks.First;
+            while (currentWaitingTask != null)
+            {
+                LinkedListNode<T> next = currentWaitingTask.Next;
+                T task = currentWaitingTask.Value;
+                if (task.Tag == tag)
+                {
+                    m_WaitingTasks.Remove(currentWaitingTask);
+                    ReferencePool.Release(task);
+                    count++;
+                }
+
+                currentWaitingTask = next;
+            }
+
+            LinkedListNode<ITaskAgent<T>> currentWorkingAgent = m_WorkingAgents.First;
+            while (currentWorkingAgent != null)
+            {
+                LinkedListNode<ITaskAgent<T>> next = currentWorkingAgent.Next;
+                ITaskAgent<T> workingAgent = currentWorkingAgent.Value;
+                T task = workingAgent.Task;
+                if (task.Tag == tag)
+                {
+                    workingAgent.Reset();
+                    m_FreeAgents.Push(workingAgent);
+                    m_WorkingAgents.Remove(currentWorkingAgent);
+                    ReferencePool.Release(task);
+                    count++;
+                }
+
+                currentWorkingAgent = next;
+            }
+
+            return count;
+        }
+
+        /// <summary>
+        /// �Ƴ���������
+        /// </summary>
+        /// <returns>�Ƴ������������</returns>
+        public int RemoveAllTasks()
+        {
+            int count = m_WaitingTasks.Count + m_WorkingAgents.Count;
+
+            foreach (T task in m_WaitingTasks)
+            {
+                ReferencePool.Release(task);
+            }
+
+            m_WaitingTasks.Clear();
+
+            foreach (ITaskAgent<T> workingAgent in m_WorkingAgents)
+            {
+                T task = workingAgent.Task;
+                workingAgent.Reset();
+                m_FreeAgents.Push(workingAgent);
+                ReferencePool.Release(task);
+            }
+
+            m_WorkingAgents.Clear();
+
+            return count;
+        }
+
+        private void ProcessRunningTasks(float elapseSeconds, float realElapseSeconds)
+        {
+            LinkedListNode<ITaskAgent<T>> current = m_WorkingAgents.First;
+            while (current != null)
+            {
+                T task = current.Value.Task;
+                if (!task.Done)
+                {
+                    current.Value.Update(elapseSeconds, realElapseSeconds);
+                    current = current.Next;
+                    continue;
+                }
+
+                LinkedListNode<ITaskAgent<T>> next = current.Next;
+                current.Value.Reset();
+                m_FreeAgents.Push(current.Value);
+                m_WorkingAgents.Remove(current);
+                ReferencePool.Release(task);
+                current = next;
+            }
+        }
+
+        private void ProcessWaitingTasks(float elapseSeconds, float realElapseSeconds)
+        {
+            LinkedListNode<T> current = m_WaitingTasks.First;
+            while (current != null && FreeAgentCount > 0)
+            {
+                ITaskAgent<T> agent = m_FreeAgents.Pop();
+                LinkedListNode<ITaskAgent<T>> agentNode = m_WorkingAgents.AddLast(agent);
+                T task = current.Value;
+                LinkedListNode<T> next = current.Next;
+                StartTaskStatus status = agent.Start(task);
+                if (status == StartTaskStatus.Done || status == StartTaskStatus.HasToWait || status == StartTaskStatus.UnknownError)
+                {
+                    agent.Reset();
+                    m_FreeAgents.Push(agent);
+                    m_WorkingAgents.Remove(agentNode);
+                }
+
+                if (status == StartTaskStatus.Done || status == StartTaskStatus.CanResume || status == StartTaskStatus.UnknownError)
+                {
+                    m_WaitingTasks.Remove(current);
+                }
+
+                if (status == StartTaskStatus.Done || status == StartTaskStatus.UnknownError)
+                {
+                    ReferencePool.Release(task);
+                }
+
+                current = next;
+            }
+        }
+    }
+}
diff --git a/Convention/[Runtime]/Convention.TaskPool.cs.meta b/Convention/[Runtime]/Convention.TaskPool.cs.meta
new file mode 100644
index 0000000..2121da9
--- /dev/null
+++ b/Convention/[Runtime]/Convention.TaskPool.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4f8c7df8532754c46b224b0cd4d0e171
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Convention/[Runtime]/File.cs b/Convention/[Runtime]/File.cs
index 159d108..8c7a76c 100644
--- a/Convention/[Runtime]/File.cs
+++ b/Convention/[Runtime]/File.cs
@@ -36,7 +36,7 @@ namespace Convention
     }
 
     [Serializable]
-    public sealed class ToolFile
+    public class ToolFile
     {
         public static string[] TextFileExtensions = new string[] { "txt", "ini", "manifest" };
         public static string[] AudioFileExtension = new string[] { "ogg", "mp2", "mp3", "mod", "wav", "it" };
@@ -59,7 +59,7 @@ namespace Convention
 
         private string OriginPath;
         private FileSystemInfo OriginInfo;
-        public ToolFile(string path) 
+        public ToolFile(string path)
         {
             OriginPath = Environment.ExpandEnvironmentVariables(path).Replace('\\', '/');
             Refresh();
@@ -219,16 +219,16 @@ namespace Convention
         {
             if (IsFile() == false)
                 throw new InvalidOperationException("Target is not a file");
-            
+
             var lines = File.ReadAllLines(OriginPath);
             var result = new List<string[]>();
-            
+
             foreach (var line in lines)
             {
                 var fields = line.Split(',');
                 result.Add(fields);
             }
-            
+
             return result;
         }
 
@@ -286,7 +286,7 @@ namespace Convention
             callback(result.assetBundle);
             yield return null;
         }
-        public IEnumerator LoadAsAssetBundle([In]Action<float> progress, [In] Action<AssetBundle> callback)
+        public IEnumerator LoadAsAssetBundle([In] Action<float> progress, [In] Action<AssetBundle> callback)
         {
             AssetBundleCreateRequest result = AssetBundle.LoadFromFileAsync(OriginPath);
             while (result.isDone == false)
@@ -314,7 +314,7 @@ namespace Convention
         }
         public void SaveAsJson<T>(T data, string key = "data")
         {
-            ES3.Save(key, data,OriginPath);
+            ES3.Save(key, data, OriginPath);
         }
         public void SaveAsText(string data)
         {
@@ -323,7 +323,7 @@ namespace Convention
             sw.Write(data);
             sw.Flush();
         }
-        public static void SaveDataAsBinary(string path,  byte[] outdata, FileStream Stream = null)
+        public static void SaveDataAsBinary(string path, byte[] outdata, FileStream Stream = null)
         {
             if (Stream != null && Stream.CanWrite)
             {
@@ -347,7 +347,7 @@ namespace Convention
         {
             if (IsFile() == false)
                 throw new InvalidOperationException("Target is not a file");
-            
+
             var lines = csvData.Select(row => string.Join(",", row));
             File.WriteAllLines(OriginPath, lines);
         }
@@ -466,7 +466,7 @@ namespace Convention
             {
                 return new ToolFile(left.IsDir() ? left.GetFullPath() : $"{left.GetFullPath().Replace('\\', '/')}/");
             }
-            string first = left.GetFullPath().Replace('\\','/');
+            string first = left.GetFullPath().Replace('\\', '/');
             string second = rightPath.Replace('\\', '/');
             if (first == "./")
                 return new ToolFile(second);
@@ -518,7 +518,7 @@ namespace Convention
         }
         public ToolFile Rename(string newPath)
         {
-            if(IsDir())
+            if (IsDir())
             {
                 var dir = OriginInfo as DirectoryInfo;
                 dir.MoveTo(newPath);
@@ -536,7 +536,7 @@ namespace Convention
             Rename(path);
             return this;
         }
-        public ToolFile Copy(string path,out ToolFile copyTo)
+        public ToolFile Copy(string path, out ToolFile copyTo)
         {
             if (IsDir())
             {
@@ -555,19 +555,19 @@ namespace Convention
         {
             if (targetPath == null)
                 return new ToolFile(OriginPath);
-            
+
             if (!Exists())
                 throw new FileNotFoundException("File not found");
-            
+
             var targetFile = new ToolFile(targetPath);
             if (targetFile.IsDir())
                 targetFile = targetFile | GetFilename();
-            
+
             if (IsDir())
                 CopyDirectory(OriginPath, targetFile.GetFullPath());
             else
                 File.Copy(OriginPath, targetFile.GetFullPath());
-            
+
             return targetFile;
         }
 
@@ -649,7 +649,7 @@ namespace Convention
         {
             if (!IsDir())
                 throw new InvalidOperationException("Target is not a directory");
-            
+
             var entries = Directory.GetFileSystemEntries(OriginPath);
             if (ignore_folder)
             {
@@ -661,7 +661,7 @@ namespace Convention
         {
             if (!IsDir())
                 throw new InvalidOperationException("Target is not a directory");
-            
+
             foreach (var file in DirToolFileIter())
             {
                 file.Remove();
@@ -673,13 +673,13 @@ namespace Convention
         {
             if (!IsDir())
                 throw new InvalidOperationException("Cannot make file inside a file, because this object target is not a directory");
-            
+
             var result = this | data.GetFilename();
             if (is_delete_source)
                 data.Move(result.GetFullPath());
             else
                 data.Copy(result.GetFullPath());
-            
+
             return this;
         }
 
@@ -947,7 +947,7 @@ namespace Convention
         public ToolFile SaveHash(string algorithm = "MD5", string outputPath = null)
         {
             string hash = CalculateHash(algorithm);
-            
+
             if (outputPath == null)
             {
                 outputPath = GetFullPath() + "." + algorithm.ToLower();
@@ -955,7 +955,7 @@ namespace Convention
 
             var hashFile = new ToolFile(outputPath);
             hashFile.SaveAsText(hash);
-            
+
             return hashFile;
         }
 
@@ -963,8 +963,8 @@ namespace Convention
 
         #region File Monitoring
 
-        public void StartMonitoring(Action<string, string> callback, bool recursive = false, 
-            List<string> ignorePatterns = null, bool ignoreDirectories = false, 
+        public void StartMonitoring(Action<string, string> callback, bool recursive = false,
+            List<string> ignorePatterns = null, bool ignoreDirectories = false,
             bool caseSensitive = true, bool isLog = true)
         {
             if (!IsDir())
@@ -988,7 +988,7 @@ namespace Convention
 
         #region Backup
 
-        public ToolFile CreateBackup(string backupDir = null, int maxBackups = 5, 
+        public ToolFile CreateBackup(string backupDir = null, int maxBackups = 5,
             string backupFormat = "zip", bool includeMetadata = true)
         {
             if (!Exists())
@@ -1101,7 +1101,7 @@ namespace Convention
                 throw new FileNotFoundException($"File not found: {GetFullPath()}");
 
             var permissions = new Dictionary<string, bool>();
-            
+
             try
             {
                 var fileInfo = new FileInfo(OriginPath);
@@ -1123,7 +1123,7 @@ namespace Convention
             return permissions;
         }
 
-        public ToolFile SetPermissions(bool? read = null, bool? write = null, 
+        public ToolFile SetPermissions(bool? read = null, bool? write = null,
             bool? execute = null, bool? hidden = null, bool recursive = false)
         {
             if (!Exists())
@@ -1233,15 +1233,15 @@ namespace Convention
         }
         public static string[] SelectMultipleFiles(string filter = "所有文件|*.*", string title = "选择文件")
         {
-            return PluginExtenion.SelectMultipleFiles(filter,title);
+            return PluginExtenion.SelectMultipleFiles(filter, title);
         }
         public static string SelectFile(string filter = "所有文件|*.*", string title = "选择文件")
         {
-            return PluginExtenion.SelectFile(filter,title);
+            return PluginExtenion.SelectFile(filter, title);
         }
         public static string SaveFile(string filter = "所有文件|*.*", string title = "保存文件")
         {
-            return PluginExtenion.SaveFile(filter,title);
+            return PluginExtenion.SaveFile(filter, title);
         }
         public static string SelectFolder(string description = "请选择文件夹")
         {
@@ -1264,4 +1264,23 @@ namespace Convention
 
         #endregion
     }
+
+    [Serializable]
+    public class MustExistFile : ToolFile
+    {
+        public MustExistFile(string path) : base(path)
+        {
+            MustExistsPath();
+        }
+    }
+
+    [Serializable]
+    public class DependentFile : ToolFile
+    {
+        public DependentFile(string path) : base(path)
+        {
+            if (Exists() == false)
+                throw new FileNotFoundException($"Dependent file not found: {path}");
+        }
+    }
 }