NBC修改

Assets/Scripts/NBC/Runtime/Core/App.cs

@@ -0,0 +1,82 @@
+using System;
+using UnityEngine;
+
+namespace NBC
+{
+    public class App : MonoBehaviour
+    {
+        public static App Inst { get; private set; }
+
+        private static Scene _scene;
+        public static Scene Main => _scene;
+        private static event Action OnInitialized;
+
+        public static event Action OnUpdate;
+        public static event Action OnLateUpdate;
+        public static event Action OnFixedUpdate;
+        public static event Action OnApplicationQuitAction;
+        public static event Action OnApplicationPauseAction;
+
+        /// <summary>
+        /// Scene下的事件系统组件
+        /// </summary>
+        public static UIComponent UI { get; internal set; }
+
+        public static void Init(Action callback = null)
+        {
+            if (Inst != null) return;
+            new GameObject("App").AddComponent<App>();
+            OnInitialized += callback;
+        }
+
+        private void Awake()
+        {
+            Inst = this;
+            DontDestroyOnLoad(gameObject);
+        }
+
+        private void Start()
+        {
+            StartAsync().Coroutine();
+        }
+
+        private void Update()
+        {
+            OnUpdate?.Invoke();
+        }
+
+        private void LateUpdate()
+        {
+            OnLateUpdate?.Invoke();
+        }
+
+        private void FixedUpdate()
+        {
+            OnFixedUpdate?.Invoke();
+        }
+
+        private void OnApplicationQuit()
+        {
+            OnApplicationQuitAction?.Invoke();
+        }
+
+        private void OnApplicationPause(bool pauseStatus)
+        {
+            OnApplicationPauseAction?.Invoke();
+        }
+
+        private void OnDestroy()
+        {
+            _scene?.Dispose();
+        }
+
+        private async FTask StartAsync()
+        {
+            // 初始化框架
+            await NBC.Platform.Unity.Entry.Initialize(GetType().Assembly);
+            _scene = await Scene.Create(SceneRuntimeMode.MainThread);
+            UI = _scene.AddComponent<UIComponent>();
+            OnInitialized?.Invoke();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/App.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 28c45f379c66403cbe3cc294b3f6e657
+timeCreated: 1751440516

Assets/Scripts/NBC/Runtime/Core/Assembly.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b5b24e6eec64b4702b871053139f8add
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Assembly/AssemblyInfo.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using NBC.DataStructure.Collection;
+
+// ReSharper disable CollectionNeverQueried.Global
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+
+namespace NBC.Assembly
+{
+    /// <summary>
+    /// AssemblyInfo提供有关程序集和类型的信息
+    /// </summary>
+    public sealed class AssemblyInfo
+    {
+        /// <summary>
+        /// 唯一标识
+        /// </summary>
+        public readonly long AssemblyIdentity;
+        /// <summary>
+        /// 获取或设置与此程序集相关联的 <see cref="Assembly"/> 实例。
+        /// </summary>
+        public System.Reflection.Assembly Assembly { get; private set; }
+        /// <summary>
+        /// 程序集类型集合，获取一个列表，包含从程序集加载的所有类型。
+        /// </summary>
+        public readonly List<Type> AssemblyTypeList = new List<Type>();
+        /// <summary>
+        /// 程序集类型分组集合，获取一个分组列表，将接口类型映射到实现这些接口的类型。
+        /// </summary>
+        public readonly OneToManyList<Type, Type> AssemblyTypeGroupList = new OneToManyList<Type, Type>();
+
+        /// <summary>
+        /// 初始化 <see cref="AssemblyInfo"/> 类的新实例。
+        /// </summary>
+        /// <param name="assemblyIdentity"></param>
+        public AssemblyInfo(long assemblyIdentity)
+        {
+            AssemblyIdentity = assemblyIdentity;
+        }
+
+        /// <summary>
+        /// 从指定的程序集加载类型信息并进行分类。
+        /// </summary>
+        /// <param name="assembly">要加载信息的程序集。</param>
+        public void Load(System.Reflection.Assembly assembly)
+        {
+            Assembly = assembly;
+            var assemblyTypes = assembly.GetTypes().ToList();
+
+            foreach (var type in assemblyTypes)
+            {
+                if (type.IsAbstract || type.IsInterface)
+                {
+                    continue;
+                }
+
+                var interfaces = type.GetInterfaces();
+
+                foreach (var interfaceType in interfaces)
+                {
+                    AssemblyTypeGroupList.Add(interfaceType, type);
+                }
+            }
+
+            AssemblyTypeList.AddRange(assemblyTypes);
+        }
+
+        /// <summary>
+        /// 重新加载程序集的类型信息。
+        /// </summary>
+        /// <param name="assembly"></param>
+        public void ReLoad(System.Reflection.Assembly assembly)
+        {
+            Unload();
+            Load(assembly);
+        }
+
+        /// <summary>
+        /// 卸载程序集的类型信息。
+        /// </summary>
+        public void Unload()
+        {
+            AssemblyTypeList.Clear();
+            AssemblyTypeGroupList.Clear();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Assembly/AssemblyInfo.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6588e9470957646dfa79849126de341c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Assembly/AssemblySystem.cs

@@ -0,0 +1,286 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Text;
+using NBC.Async;
+using NBC.Helper;
+
+#pragma warning disable CS8604 // Possible null reference argument.
+#pragma warning disable CS8602 // Dereference of a possibly null reference.
+#pragma warning disable CS8603
+#pragma warning disable CS8618
+namespace NBC.Assembly
+{
+    /// <summary>
+    /// 管理程序集加载和卸载的帮助类。
+    /// </summary>
+    public static class AssemblySystem
+    {
+#if FANTASY_WEBGL
+        private static readonly List<IAssembly> AssemblySystems = new List<IAssembly>();
+        private static readonly Dictionary<long, AssemblyInfo> AssemblyList = new Dictionary<long, AssemblyInfo>();
+#else
+        private static readonly ConcurrentQueue<IAssembly> AssemblySystems = new ConcurrentQueue<IAssembly>();
+        private static readonly ConcurrentDictionary<long, AssemblyInfo> AssemblyList = new ConcurrentDictionary<long, AssemblyInfo>();
+#endif
+        /// <summary>
+        /// 初始化 AssemblySystem。（仅限内部）
+        /// </summary>
+        /// <param name="assemblies"></param>
+        internal static async FTask InnerInitialize(params System.Reflection.Assembly[] assemblies)
+        {
+            await LoadAssembly(typeof(AssemblySystem).Assembly);
+            foreach (var assembly in assemblies)
+            {
+                await LoadAssembly(assembly);
+            }
+        }
+
+        /// <summary>
+        /// 加载指定的程序集，并触发相应的事件。
+        /// </summary>
+        /// <param name="assembly">要加载的程序集。</param>
+        /// <param name="isCurrentDomain">如果当前Domain中已经存在同名的Assembly,使用Domain中的程序集。</param>
+        public static async FTask LoadAssembly(System.Reflection.Assembly assembly, bool isCurrentDomain = true)
+        {
+            if (isCurrentDomain)
+            {
+                var currentDomainAssemblies = System.AppDomain.CurrentDomain.GetAssemblies();
+                var currentAssembly = currentDomainAssemblies.FirstOrDefault(d => d.GetName().Name == assembly.GetName().Name);
+                if (currentAssembly != null)
+                {
+                    assembly = currentAssembly;
+                }
+            }
+            
+            var assemblyIdentity = AssemblyIdentity(assembly);
+            
+            if (AssemblyList.TryGetValue(assemblyIdentity, out var assemblyInfo))
+            {
+                assemblyInfo.ReLoad(assembly);
+                foreach (var assemblySystem in AssemblySystems)
+                {
+                    await assemblySystem.ReLoad(assemblyIdentity);
+                }
+            }
+            else
+            {
+                assemblyInfo = new AssemblyInfo(assemblyIdentity);
+                assemblyInfo.Load(assembly);
+                AssemblyList.TryAdd(assemblyIdentity, assemblyInfo);
+                foreach (var assemblySystem in AssemblySystems)
+                {
+                    await assemblySystem.Load(assemblyIdentity);
+                }
+            }
+        }
+
+        /// <summary>
+        /// 卸载程序集
+        /// </summary>
+        /// <param name="assembly"></param>
+        public static async FTask UnLoadAssembly(System.Reflection.Assembly assembly)
+        {
+            var assemblyIdentity = AssemblyIdentity(assembly);
+            
+            if (!AssemblyList.Remove(assemblyIdentity, out var assemblyInfo))
+            {
+                return;
+            }
+            
+            assemblyInfo.Unload();
+            foreach (var assemblySystem in AssemblySystems)
+            {
+                await assemblySystem.OnUnLoad(assemblyIdentity);
+            }
+        }
+        
+        /// <summary>
+        /// 将AssemblySystem接口的object注册到程序集管理中心
+        /// </summary>
+        /// <param name="obj"></param>
+        public static async FTask Register(object obj)
+        {
+            if (obj is not IAssembly assemblySystem)
+            {
+                return;
+            }
+#if FANTASY_WEBGL 
+            AssemblySystems.Add(assemblySystem);
+#else
+            AssemblySystems.Enqueue(assemblySystem);
+#endif
+            foreach (var (assemblyIdentity, _) in AssemblyList)
+            {
+                await assemblySystem.Load(assemblyIdentity);
+            }
+        }
+
+        /// <summary>
+        /// 程序集管理中心卸载注册的Load、ReLoad、UnLoad的接口
+        /// </summary>
+        /// <param name="obj"></param>
+        public static void UnRegister(object obj)
+        {
+            if (obj is not IAssembly assemblySystem)
+            {
+                return;
+            }
+#if FANTASY_WEBGL
+            AssemblySystems.Remove(assemblySystem);
+#else
+            var count = AssemblySystems.Count;
+
+            for (var i = 0; i < count; i++)
+            {
+                if (!AssemblySystems.TryDequeue(out var removeAssemblySystem))
+                {
+                    continue;
+                }
+                
+                if (removeAssemblySystem == assemblySystem)
+                {
+                    break;
+                }
+                
+                AssemblySystems.Enqueue(removeAssemblySystem);
+            }
+#endif
+        }
+
+        /// <summary>
+        /// 获取所有已加载程序集中的所有类型。
+        /// </summary>
+        /// <returns>所有已加载程序集中的类型。</returns>
+        public static IEnumerable<Type> ForEach()
+        {
+            foreach (var (_, assemblyInfo) in AssemblyList)
+            {
+                foreach (var type in assemblyInfo.AssemblyTypeList)
+                {
+                    yield return type;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 获取指定程序集中的所有类型。
+        /// </summary>
+        /// <param name="assemblyIdentity">程序集唯一标识。</param>
+        /// <returns>指定程序集中的类型。</returns>
+        public static IEnumerable<Type> ForEach(long assemblyIdentity)
+        {
+            if (!AssemblyList.TryGetValue(assemblyIdentity, out var assemblyInfo))
+            {
+                yield break;
+            }
+
+            foreach (var type in assemblyInfo.AssemblyTypeList)
+            {
+                yield return type;
+            }
+        }
+
+        /// <summary>
+        /// 获取所有已加载程序集中实现指定类型的所有类型。
+        /// </summary>
+        /// <param name="findType">要查找的基类或接口类型。</param>
+        /// <returns>所有已加载程序集中实现指定类型的类型。</returns>
+        public static IEnumerable<Type> ForEach(Type findType)
+        {
+            foreach (var (_, assemblyInfo) in AssemblyList)
+            {
+                if (!assemblyInfo.AssemblyTypeGroupList.TryGetValue(findType, out var assemblyLoad))
+                {
+                    continue;
+                }
+                
+                foreach (var type in assemblyLoad)
+                {
+                    yield return type;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 获取指定程序集中实现指定类型的所有类型。
+        /// </summary>
+        /// <param name="assemblyIdentity">程序集唯一标识。</param>
+        /// <param name="findType">要查找的基类或接口类型。</param>
+        /// <returns>指定程序集中实现指定类型的类型。</returns>
+        public static IEnumerable<Type> ForEach(long assemblyIdentity, Type findType)
+        {
+            if (!AssemblyList.TryGetValue(assemblyIdentity, out var assemblyInfo))
+            {
+                yield break;
+            }
+
+            if (!assemblyInfo.AssemblyTypeGroupList.TryGetValue(findType, out var assemblyLoad))
+            {
+                yield break;
+            }
+            
+            foreach (var type in assemblyLoad)
+            {
+                yield return type;
+            }
+        }
+
+        /// <summary>
+        /// 获取指定程序集的实例。
+        /// </summary>
+        /// <param name="assemblyIdentity">程序集名称。</param>
+        /// <returns>指定程序集的实例，如果未加载则返回 null。</returns>
+        public static System.Reflection.Assembly GetAssembly(long assemblyIdentity)
+        {
+            return !AssemblyList.TryGetValue(assemblyIdentity, out var assemblyInfo) ? null : assemblyInfo.Assembly;
+        }
+
+        /// <summary>
+        /// 获取当前框架注册的Assembly
+        /// </summary>
+        /// <returns></returns>
+        public static IEnumerable<System.Reflection.Assembly> ForEachAssembly
+        {
+            get
+            {
+                foreach (var (_, assemblyInfo) in AssemblyList)
+                {
+                    yield return assemblyInfo.Assembly;
+                }
+            }
+        }
+        
+        /// <summary>
+        /// 根据Assembly的强命名计算唯一标识。
+        /// </summary>
+        /// <param name="assembly"></param>
+        /// <returns></returns>
+        private static long AssemblyIdentity(System.Reflection.Assembly assembly)
+        {
+            return HashCodeHelper.ComputeHash64(assembly.GetName().Name);
+        }
+
+        /// <summary>
+        /// 释放资源，卸载所有加载的程序集。
+        /// </summary>
+        public static void Dispose()
+        {
+            DisposeAsync().Coroutine();
+        }
+        
+        private static async FTask DisposeAsync()
+        {
+            foreach (var (_, assemblyInfo) in AssemblyList.ToArray())
+            {
+                await UnLoadAssembly(assemblyInfo.Assembly);
+            }
+            
+            AssemblyList.Clear();
+            AssemblySystems.Clear();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Assembly/AssemblySystem.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6f06892fa649d49c287bf07095569ae0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Assembly/IAssembly.cs

@@ -0,0 +1,27 @@
+using System;
+using NBC.Async;
+
+namespace NBC.Assembly
+{
+    /// <summary>
+    /// 实现这个接口、会再程序集首次加载、卸载、重载的时候调用
+    /// </summary>
+    public interface IAssembly : IDisposable
+    {
+        /// <summary>
+        /// 程序集加载时调用
+        /// </summary>
+        /// <param name="assemblyIdentity">程序集标识</param>
+        public FTask Load(long assemblyIdentity);
+        /// <summary>
+        /// 程序集重新加载的时候调用
+        /// </summary>
+        /// <param name="assemblyIdentity">程序集标识</param>
+        public FTask ReLoad(long assemblyIdentity);
+        /// <summary>
+        /// 卸载的时候调用
+        /// </summary>
+        /// <param name="assemblyIdentity">程序集标识</param>
+        public FTask OnUnLoad(long assemblyIdentity);
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Assembly/IAssembly.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f14fcbf29decc4d47b6c548a3d5f2a3f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Attributes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cf2ee6bcf7bf9f94eb3eab2a87540dcd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Attributes/Attributes.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace NBC
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    public class BaseAttribute : Attribute
+    {
+    }
+
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Field | AttributeTargets.Method)]
+    public class SortAttribute : Attribute
+    {
+        public int Sort;
+
+        public SortAttribute(int sort)
+        {
+            Sort = sort;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Attributes/Attributes.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 32bc35c38967479d81a79bd1354d38e8
+timeCreated: 1733995116

Assets/Scripts/NBC/Runtime/Core/DataStructure.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: afe876696fb5f4779abe3289a3bf4f9f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0b3d477f03f404310b5ad48f89d1f193
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/CircularBuffer.cs

@@ -0,0 +1,346 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+
+namespace NBC.DataStructure.Collection
+{
+    /// 环形缓存（自增式缓存，自动扩充、不会收缩缓存、所以不要用这个操作过大的IO流）
+    /// 1、环大小8192，溢出的会自动增加环的大小。
+    /// 2、每个块都是一个环形缓存，当溢出的时候会自动添加到下一个环中。
+    /// 3、当读取完成后用过的环会放在缓存中，不会销毁掉。
+    /// <summary>
+    /// 自增式缓存类，继承自 Stream 和 IDisposable 接口。
+    /// 环形缓存具有自动扩充的特性，但不会收缩，适用于操作不过大的 IO 流。
+    /// </summary>
+    public sealed class CircularBuffer : Stream, IDisposable
+    {
+        private byte[] _lastBuffer;
+        /// <summary>
+        /// 环形缓存块的默认大小
+        /// </summary>
+        public const int ChunkSize = 8192;
+        private readonly Queue<byte[]> _bufferCache = new Queue<byte[]>();
+        private readonly Queue<byte[]> _bufferQueue = new Queue<byte[]>();
+        /// <summary>
+        /// 获取或设置环形缓存的第一个索引位置
+        /// </summary>
+        public int FirstIndex { get; set; }
+        /// <summary>
+        /// 获取或设置环形缓存的最后一个索引位置
+        /// </summary>
+        public int LastIndex { get; set; }
+        /// <summary>
+        /// 获取环形缓存的总长度
+        /// </summary>
+        public override long Length
+        {
+            get
+            {
+                if (_bufferQueue.Count == 0)
+                {
+                    return 0;
+                }
+
+                return (_bufferQueue.Count - 1) * ChunkSize + LastIndex - FirstIndex;
+            }
+        }
+
+        /// <summary>
+        /// 获取环形缓存的第一个块
+        /// </summary>
+        public byte[] First
+        {
+            get
+            {
+                if (_bufferQueue.Count == 0)
+                {
+                    AddLast();
+                }
+
+                return _bufferQueue.Peek();
+            }
+        }
+
+        /// <summary>
+        /// 获取环形缓存的最后一个块
+        /// </summary>
+        public byte[] Last
+        {
+            get
+            {
+                if (_bufferQueue.Count == 0)
+                {
+                    AddLast();
+                }
+
+                return _lastBuffer;
+            }
+        }
+        /// <summary>
+        /// 向环形缓存中添加一个新的块
+        /// </summary>
+        public void AddLast()
+        {
+            var buffer = _bufferCache.Count > 0 ? _bufferCache.Dequeue() : new byte[ChunkSize];
+            _bufferQueue.Enqueue(buffer);
+            _lastBuffer = buffer;
+        }
+        /// <summary>
+        /// 从环形缓存中移除第一个块
+        /// </summary>
+        public void RemoveFirst()
+        {
+            _bufferCache.Enqueue(_bufferQueue.Dequeue());
+        }
+
+        /// <summary>
+        /// 从流中读取指定数量的数据到缓存。
+        /// </summary>
+        /// <param name="stream">源数据流。</param>
+        /// <param name="count">要读取的字节数。</param>
+        public void Read(Stream stream, int count)
+        {
+            if (count > Length)
+            {
+                throw new Exception($"bufferList length < count, {Length} {count}");
+            }
+
+            var copyCount = 0;
+            while (copyCount < count)
+            {
+                var n = count - copyCount;
+                if (ChunkSize - FirstIndex > n)
+                {
+                    stream.Write(First, FirstIndex, n);
+                    FirstIndex += n;
+                    copyCount += n;
+                }
+                else
+                {
+                    stream.Write(First, FirstIndex, ChunkSize - FirstIndex);
+                    copyCount += ChunkSize - FirstIndex;
+                    FirstIndex = 0;
+                    RemoveFirst();
+                }
+            }
+        }
+
+        /// <summary>
+        /// 从缓存中读取指定数量的数据到内存。
+        /// </summary>
+        /// <param name="memory">目标内存。</param>
+        /// <param name="count">要读取的字节数。</param>
+        public void Read(Memory<byte> memory, int count)
+        {
+            if (count > Length)
+            {
+                throw new Exception($"bufferList length < count, {Length} {count}");
+            }
+
+            var copyCount = 0;
+            while (copyCount < count)
+            {
+                var n = count - copyCount;
+                var asMemory = First.AsMemory();
+                
+                if (ChunkSize - FirstIndex > n)
+                {
+                    var slice = asMemory.Slice(FirstIndex, n);
+                    slice.CopyTo(memory.Slice(copyCount, n));
+                    FirstIndex += n;
+                    copyCount += n;
+                }
+                else
+                {
+                    var length = ChunkSize - FirstIndex;
+                    var slice = asMemory.Slice(FirstIndex, length);
+                    slice.CopyTo(memory.Slice(copyCount, length));
+                    copyCount += ChunkSize - FirstIndex;
+                    FirstIndex = 0;
+                    RemoveFirst();
+                }
+            }
+        }
+
+        /// <summary>
+        /// 从自定义流中读取数据到指定的缓冲区。
+        /// </summary>
+        /// <param name="buffer">目标缓冲区，用于存储读取的数据。</param>
+        /// <param name="offset">目标缓冲区中的起始偏移量。</param>
+        /// <param name="count">要读取的字节数。</param>
+        /// <returns>实际读取的字节数。</returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (buffer.Length < offset + count)
+            {
+                throw new Exception($"buffer length < count, buffer length: {buffer.Length} {offset} {count}");
+            }
+
+            var length = Length;
+            if (length < count)
+            {
+                count = (int) length;
+            }
+
+            var copyCount = 0;
+
+            // 循环直到成功读取所需的字节数
+            while (copyCount < count)
+            {
+                var copyLength = count - copyCount;
+
+                if (ChunkSize - FirstIndex > copyLength)
+                {
+                    // 将数据从当前块的缓冲区复制到目标缓冲区
+                    Array.Copy(First, FirstIndex, buffer, copyCount + offset, copyLength);
+
+                    FirstIndex += copyLength;
+                    copyCount += copyLength;
+                    continue;
+                }
+
+                // 复制当前块中剩余的数据，并切换到下一个块
+                Array.Copy(First, FirstIndex, buffer, copyCount + offset, ChunkSize - FirstIndex);
+                copyCount += ChunkSize - FirstIndex;
+                FirstIndex = 0;
+
+                RemoveFirst();
+            }
+
+            return count;
+        }
+
+        /// <summary>
+        /// 将数据从给定的字节数组写入流中。
+        /// </summary>
+        /// <param name="buffer">包含要写入的数据的字节数组。</param>
+        public void Write(byte[] buffer)
+        {
+            Write(buffer, 0, buffer.Length);
+        }
+
+        /// <summary>
+        /// 将数据从给定的流写入流中。
+        /// </summary>
+        /// <param name="stream">包含要写入的数据的流。</param>
+        public void Write(Stream stream)
+        {
+            var copyCount = 0;
+            var count = (int) (stream.Length - stream.Position);
+            
+            while (copyCount < count)
+            {
+                if (LastIndex == ChunkSize)
+                {
+                    AddLast();
+                    LastIndex = 0;
+                }
+
+                var n = count - copyCount;
+                
+                if (ChunkSize - LastIndex > n)
+                {
+                    _ = stream.Read(Last, LastIndex, n);
+                    LastIndex += count - copyCount;
+                    copyCount += n;
+                }
+                else
+                {
+                    _ = stream.Read(Last, LastIndex, ChunkSize - LastIndex);
+                    copyCount += ChunkSize - LastIndex;
+                    LastIndex = ChunkSize;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 将数据从给定的字节数组写入流中。
+        /// </summary>
+        /// <param name="buffer">包含要写入的数据的字节数组。</param>
+        /// <param name="offset">开始写入的缓冲区中的索引。</param>
+        /// <param name="count">要写入的字节数。</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            var copyCount = 0;
+
+            while (copyCount < count)
+            {
+                if (ChunkSize == LastIndex)
+                {
+                    AddLast();
+                    LastIndex = 0;
+                }
+
+                var byteLength = count - copyCount;
+
+                if (ChunkSize - LastIndex > byteLength)
+                {
+                    Array.Copy(buffer, copyCount + offset, Last, LastIndex, byteLength);
+                    LastIndex += byteLength;
+                    copyCount += byteLength;
+                }
+                else
+                {
+                    Array.Copy(buffer, copyCount + offset, Last, LastIndex, ChunkSize - LastIndex);
+                    copyCount += ChunkSize - LastIndex;
+                    LastIndex = ChunkSize;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 获取一个值，指示流是否支持读取操作。
+        /// </summary>
+        public override bool CanRead { get; } = true;
+        /// <summary>
+        /// 获取一个值，指示流是否支持寻找操作。
+        /// </summary>
+        public override bool CanSeek { get; } = false;
+        /// <summary>
+        /// 获取一个值，指示流是否支持写入操作。
+        /// </summary>
+        public override bool CanWrite { get; } = true;
+        /// <summary>
+        /// 获取或设置流中的位置。
+        /// </summary>
+        public override long Position { get; set; }
+
+        /// <summary>
+        /// 刷新流（在此实现中引发未实现异常）。
+        /// </summary>
+        public override void Flush()
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// 在流中寻找特定位置（在此实现中引发未实现异常）。
+        /// </summary>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// 设置流的长度（在此实现中引发未实现异常）。
+        /// </summary>
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException();
+        }
+
+        /// <summary>
+        /// 释放 CustomStream 使用的所有资源。
+        /// </summary>
+        public new void Dispose()
+        {
+            _bufferQueue.Clear();
+            _lastBuffer = null;
+            FirstIndex = 0;
+            LastIndex = 0;
+            base.Dispose();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/CircularBuffer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 38264758f23d1448a975efc4f4b7da63
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/ConcurrentOneToManyListPool.cs

@@ -0,0 +1,197 @@
+#if !FANTASY_WEBGL
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using NBC.Pool;
+
+#pragma warning disable CS8603 // Possible null reference return.
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 并发的一对多列表池，用于维护具有相同键的多个值的关联关系，实现了 <see cref="IDisposable"/> 接口。
+    /// </summary>
+    /// <typeparam name="TKey">关键字的类型，不能为空。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class ConcurrentOneToManyListPool<TKey, TValue> : ConcurrentOneToManyList<TKey, TValue>, IDisposable, IPool where TKey : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个 <see cref="ConcurrentOneToManyListPool{TKey, TValue}"/> 的实例。
+        /// </summary>
+        /// <returns>创建的实例。</returns>
+        public static ConcurrentOneToManyListPool<TKey, TValue> Create()
+        {
+            var a = MultiThreadPool.Rent<ConcurrentOneToManyListPool<TKey, TValue>>();
+            a._isDispose = false;
+            a._isPool = true;
+            return a;
+        }
+
+        /// <summary>
+        /// 释放实例占用的资源。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            // 清空实例的数据
+            Clear();
+            // 将实例返回到池中以便重用
+            MultiThreadPool.Return(this);
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 并发的一对多列表，用于维护具有相同键的多个值的关联关系。
+    /// </summary>
+    /// <typeparam name="TKey">关键字的类型，不能为空。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class ConcurrentOneToManyList<TKey, TValue> : ConcurrentDictionary<TKey, List<TValue>> where TKey : notnull
+    {
+        private readonly Queue<List<TValue>> _queue = new Queue<List<TValue>>();
+        private readonly int _recyclingLimit = 120;
+
+        /// <summary>
+        /// 初始化 <see cref="ConcurrentOneToManyList{TKey, TValue}"/> 类的新实例。
+        /// </summary>
+        public ConcurrentOneToManyList()
+        {
+        }
+
+        /// <summary>
+        /// 设置最大缓存数量
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public ConcurrentOneToManyList(int recyclingLimit)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        /// <summary>
+        /// 判断指定键的列表是否包含指定值。
+        /// </summary>
+        /// <param name="key">要搜索的键。</param>
+        /// <param name="value">要搜索的值。</param>
+        /// <returns>如果列表包含值，则为 true；否则为 false。</returns>
+        public bool Contains(TKey key, TValue value)
+        {
+            TryGetValue(key, out var list);
+
+            return list != null && list.Contains(value);
+        }
+
+        /// <summary>
+        /// 向指定键的列表中添加一个值。
+        /// </summary>
+        /// <param name="key">要添加值的键。</param>
+        /// <param name="value">要添加的值。</param>
+        public void Add(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                list = Fetch();
+                list.Add(value);
+                base[key] = list;
+                return;
+            }
+
+            list.Add(value);
+        }
+
+        /// <summary>
+        /// 获取指定键的列表中的第一个值。
+        /// </summary>
+        /// <param name="key">要获取第一个值的键。</param>
+        /// <returns>指定键的列表中的第一个值，如果不存在则为默认值。</returns>
+        public TValue First(TKey key)
+        {
+            return !TryGetValue(key, out var list) ? default : list.FirstOrDefault();
+        }
+
+        /// <summary>
+        /// 从指定键的列表中移除一个值。
+        /// </summary>
+        /// <param name="key">要移除值的键。</param>
+        /// <param name="value">要移除的值。</param>
+        public void RemoveValue(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list)) return;
+
+            list.Remove(value);
+
+            if (list.Count == 0) RemoveKey(key);
+        }
+
+        /// <summary>
+        /// 从字典中移除指定键以及其关联的列表。
+        /// </summary>
+        /// <param name="key">要移除的键。</param>
+        public void RemoveKey(TKey key)
+        {
+            if (!TryRemove(key, out var list)) return;
+
+            Recycle(list);
+        }
+
+        /// <summary>
+        /// 从队列中获取一个列表，如果队列为空则创建一个新的列表。
+        /// </summary>
+        /// <returns>获取的列表。</returns>
+        private List<TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new List<TValue>() : _queue.Dequeue();
+        }
+
+        /// <summary>
+        /// 将一个列表回收到队列中。
+        /// </summary>
+        /// <param name="list">要回收的列表。</param>
+        private void Recycle(List<TValue> list)
+        {
+            list.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit) return;
+
+            _queue.Enqueue(list);
+        }
+
+        /// <summary>
+        /// 清空当前类的数据，包括从基类继承的数据以及自定义的数据队列。
+        /// </summary>
+        protected new void Clear()
+        {
+            base.Clear();
+            _queue.Clear();
+        }
+    }
+}
+#endif

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/ConcurrentOneToManyListPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 21b2d3135b133441aa08c5eb1768a103
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/ConcurrentOneToManyQueuePool.cs

@@ -0,0 +1,194 @@
+#if !FANTASY_WEBGL
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using NBC.Pool;
+
+#pragma warning disable CS8603
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 表示一个并发的一对多队列池，用于维护具有相同键的多个值的关联关系，实现了 <see cref="IDisposable"/> 接口。
+    /// </summary>
+    /// <typeparam name="TKey">关键字的类型，不能为空。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class ConcurrentOneToManyQueuePool<TKey, TValue> : ConcurrentOneToManyQueue<TKey, TValue>, IDisposable, IPool where TKey : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建并返回一个 <see cref="ConcurrentOneToManyQueuePool{TKey, TValue}"/> 的实例。
+        /// </summary>
+        /// <returns>创建的实例。</returns>
+        public static ConcurrentOneToManyQueuePool<TKey, TValue> Create()
+        {
+            var a = MultiThreadPool.Rent<ConcurrentOneToManyQueuePool<TKey, TValue>>();
+            a._isDispose = false;
+            a._isPool = true;
+            return a;
+        }
+
+        /// <summary>
+        /// 释放当前实例所占用的资源，并将实例返回到对象池中，以便重用。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+            // 将实例返回到对象池中，以便重用
+            MultiThreadPool.Return(this);
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 表示一个并发的一对多队列，用于维护具有相同键的多个值的关联关系。
+    /// </summary>
+    /// <typeparam name="TKey">关键字的类型，不能为空。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class ConcurrentOneToManyQueue<TKey, TValue> : ConcurrentDictionary<TKey, Queue<TValue>> where TKey : notnull
+    {
+        private readonly Queue<Queue<TValue>> _queue = new Queue<Queue<TValue>>();
+        private readonly int _recyclingLimit;
+
+        /// <summary>
+        /// 设置最大缓存数量
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public ConcurrentOneToManyQueue(int recyclingLimit = 0)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        /// <summary>
+        /// 判断指定键的队列是否包含指定值。
+        /// </summary>
+        /// <param name="key">要搜索的键。</param>
+        /// <param name="value">要搜索的值。</param>
+        /// <returns>如果队列包含值，则为 true；否则为 false。</returns>
+        public bool Contains(TKey key, TValue value)
+        {
+            TryGetValue(key, out var list);
+
+            return list != null && list.Contains(value);
+        }
+
+        /// <summary>
+        /// 向指定键的队列中添加一个值。
+        /// </summary>
+        /// <param name="key">要添加值的键。</param>
+        /// <param name="value">要添加的值。</param>
+        public void Enqueue(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                list = Fetch();
+                list.Enqueue(value);
+                TryAdd(key, list);
+                return;
+            }
+
+            list.Enqueue(value);
+        }
+
+        /// <summary>
+        /// 从指定键的队列中出队并返回一个值。
+        /// </summary>
+        /// <param name="key">要出队的键。</param>
+        /// <returns>出队的值，如果队列为空则为默认值。</returns>
+        public TValue Dequeue(TKey key)
+        {
+            if (!TryGetValue(key, out var list) || list.Count == 0) return default;
+
+            var value = list.Dequeue();
+
+            if (list.Count == 0) RemoveKey(key);
+
+            return value;
+        }
+
+        /// <summary>
+        /// 尝试从指定键的队列中出队一个值。
+        /// </summary>
+        /// <param name="key">要出队的键。</param>
+        /// <param name="value">出队的值，如果队列为空则为默认值。</param>
+        /// <returns>如果成功出队，则为 true；否则为 false。</returns>
+        public bool TryDequeue(TKey key, out TValue value)
+        {
+            value = Dequeue(key);
+
+            return value != null;
+        }
+
+        /// <summary>
+        /// 从字典中移除指定键以及其关联的队列。
+        /// </summary>
+        /// <param name="key">要移除的键。</param>
+        public void RemoveKey(TKey key)
+        {
+            if (!TryGetValue(key, out var list)) return;
+
+            TryRemove(key, out _);
+            Recycle(list);
+        }
+
+        /// <summary>
+        /// 从队列中获取一个新的队列，如果队列为空则创建一个新的队列。
+        /// </summary>
+        /// <returns>获取的队列。</returns>
+        private Queue<TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new Queue<TValue>() : _queue.Dequeue();
+        }
+
+        /// <summary>
+        /// 将一个队列回收到队列池中。
+        /// </summary>
+        /// <param name="list">要回收的队列。</param>
+        private void Recycle(Queue<TValue> list)
+        {
+            list.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit) return;
+
+            _queue.Enqueue(list);
+        }
+
+        /// <summary>
+        /// 清空当前类的数据，包括从基类继承的键值对字典中的数据以及自定义的队列池。
+        /// </summary>
+        protected new void Clear()
+        {
+            base.Clear();
+            _queue.Clear();
+        }
+    }
+}
+#endif

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/ConcurrentOneToManyQueuePool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 50a0f004d8b7b4075a4ce01376e49375
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/HashSetPool.cs

@@ -0,0 +1,134 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 可释放的哈希集合对象池。
+    /// </summary>
+    /// <typeparam name="T">哈希集合中元素的类型。</typeparam>
+    public sealed class HashSetPool<T> : HashSet<T>, IDisposable, IPool
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 释放实例所占用的资源，并将实例返回到对象池中，以便重用。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<HashSetPool<T>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 创建一个 <see cref="HashSetPool{T}"/> 哈希集合池的实例。
+        /// </summary>
+        /// <returns>创建的实例。</returns>
+        public static HashSetPool<T> Create()
+        {
+#if FANTASY_WEBGL
+            var list = Pool<HashSetPool<T>>.Rent();
+            list._isDispose = false;
+            list._isPool = true;
+            return list;
+#else
+            var list = MultiThreadPool.Rent<HashSetPool<T>>();
+            list._isDispose = false;
+            list._isPool = true;
+            return list;
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 基本哈希集合对象池，他自持有实际的哈希集合。
+    /// </summary>
+    /// <typeparam name="T">哈希集合中元素的类型。</typeparam>
+    public sealed class HashSetBasePool<T> : IDisposable, IPool
+    {
+        private bool _isPool;
+        
+        /// <summary>
+        /// 存储实际的哈希集合
+        /// </summary>
+        public HashSet<T> Set = new HashSet<T>();
+
+        /// <summary>
+        /// 创建一个 <see cref="HashSetBasePool{T}"/> 基本哈希集合对象池的实例。
+        /// </summary>
+        /// <returns>创建的实例。</returns>
+        public static HashSetBasePool<T> Create()
+        {
+#if FANTASY_WEBGL
+            var hashSetBasePool = Pool<HashSetBasePool<T>>.Rent();
+            hashSetBasePool._isPool = true;
+            return hashSetBasePool;
+#else
+            var hashSetBasePool = MultiThreadPool.Rent<HashSetBasePool<T>>();
+            hashSetBasePool._isPool = true;
+            return hashSetBasePool;
+#endif
+        }
+
+        /// <summary>
+        /// 释放实例所占用的资源，并将实例返回到对象池中，以便重用。
+        /// </summary>
+        public void Dispose()
+        {
+            Set.Clear();
+#if FANTASY_WEBGL
+            Pool<HashSetBasePool<T>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/HashSetPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c49468bddc6524c419ace92b9ad68a5d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/ListPool.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+// ReSharper disable ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 可释放的列表（List）对象池。
+    /// </summary>
+    /// <typeparam name="T">列表中元素的类型。</typeparam>
+    public sealed class ListPool<T> : List<T>, IDisposable, IPool
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 释放实例所占用的资源，并将实例返回到对象池中，以便重用。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<ListPool<T>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 使用指定的元素创建一个 <see cref="ListPool{T}"/> 列表（List）对象池的实例。
+        /// </summary>
+        /// <param name="args">要添加到列表的元素。</param>
+        /// <returns>创建的实例。</returns>
+        public static ListPool<T> Create(params T[] args)
+        {
+#if FANTASY_WEBGL
+            var list = Pool<ListPool<T>>.Rent();
+#else
+            var list = MultiThreadPool.Rent<ListPool<T>>();
+#endif
+            list._isDispose = false;
+            list._isPool = true;
+
+            if (args != null)
+            {
+                list.AddRange(args);
+            }
+
+            return list;
+        }
+
+        /// <summary>
+        /// 使用指定的列表创建一个 <see cref="ListPool{T}"/> 列表（List）对象池的实例。
+        /// </summary>
+        /// <param name="args">要添加到列表的元素列表。</param>
+        /// <returns>创建的实例。</returns>
+        public static ListPool<T> Create(List<T> args)
+        {
+#if FANTASY_WEBGL
+            var list = Pool<ListPool<T>>.Rent();
+#else
+            var list = MultiThreadPool.Rent<ListPool<T>>();
+#endif
+            list._isDispose = false;
+            list._isPool = true;
+
+            if (args != null)
+            {
+                list.AddRange(args);
+            }
+
+            return list;
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/ListPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f629886e3686046c6b00225679a7dbf5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/OneToManyHashSetPool.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 一对多哈希集合（OneToManyHashSet）对象池。
+    /// </summary>
+    /// <typeparam name="TKey">键的类型。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class OneToManyHashSetPool<TKey, TValue> : OneToManyHashSet<TKey, TValue>, IDisposable, IPool where TKey : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个 <see cref="OneToManyHashSetPool{TKey, TValue}"/> 一对多哈希集合（OneToManyHashSet）对象池的实例。
+        /// </summary>
+        /// <returns>创建的实例。</returns>
+        public static OneToManyHashSetPool<TKey, TValue> Create()
+        {
+#if FANTASY_WEBGL
+            var a = Pool<OneToManyHashSetPool<TKey, TValue>>.Rent();
+#else
+            var a = MultiThreadPool.Rent<OneToManyHashSetPool<TKey, TValue>>();
+#endif
+            a._isDispose = false;
+            a._isPool = true;
+            return a;
+        }
+
+        /// <summary>
+        /// 释放实例所占用的资源，并将实例返回到对象池中，以便重用。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<OneToManyHashSetPool<TKey, TValue>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 一对多哈希集合（OneToManyHashSet），用于创建和管理键对应多个值的集合。
+    /// </summary>
+    /// <typeparam name="TKey">键的类型。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class OneToManyHashSet<TKey, TValue> : Dictionary<TKey, HashSet<TValue>> where TKey : notnull
+    {
+        /// 用于回收和重用的空闲值集合队列。
+        private readonly Queue<HashSet<TValue>> _queue = new Queue<HashSet<TValue>>();
+        /// 设置最大回收限制，用于控制值集合的最大数量。
+        private readonly int _recyclingLimit = 120;
+        /// 一个空的、不包含任何元素的哈希集合，用于在查找失败时返回。
+        private static HashSet<TValue> _empty = new HashSet<TValue>();
+
+        /// <summary>
+        /// 初始化 <see cref="OneToManyHashSet{TKey, TValue}"/> 类的新实例。
+        /// </summary>
+        public OneToManyHashSet() { }
+
+        /// <summary>
+        /// 设置最大缓存数量
+        /// </summary>
+        /// <param name="recyclingLimit">
+        ///     1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        ///     2:设置成0不控制数量，全部缓存
+        /// </param>
+        public OneToManyHashSet(int recyclingLimit)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        /// <summary>
+        /// 判断指定的键值对是否存在于集合中。
+        /// </summary>
+        /// <param name="key">键。</param>
+        /// <param name="value">值。</param>
+        /// <returns>如果存在则为 true，否则为 false。</returns>
+        public bool Contains(TKey key, TValue value)
+        {
+            TryGetValue(key, out var list);
+
+            return list != null && list.Contains(value);
+        }
+
+        /// <summary>
+        /// 添加指定的键值对到集合中。
+        /// </summary>
+        /// <param name="key">键。</param>
+        /// <param name="value">值。</param>
+        public void Add(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                list = Fetch();
+                list.Add(value);
+                Add(key, list);
+
+                return;
+            }
+
+            list.Add(value);
+        }
+
+        /// <summary>
+        /// 从集合中移除指定键对应的值。
+        /// </summary>
+        /// <param name="key">键。</param>
+        /// <param name="value">要移除的值。</param>
+        public void RemoveValue(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list)) return;
+
+            list.Remove(value);
+
+            if (list.Count == 0) RemoveKey(key);
+        }
+
+        /// <summary>
+        /// 从集合中移除指定键及其对应的值集合。
+        /// </summary>
+        /// <param name="key">键。</param>
+        public void RemoveKey(TKey key)
+        {
+            if (!TryGetValue(key, out var list)) return;
+
+            Remove(key);
+            Recycle(list);
+        }
+
+        /// <summary>
+        /// 获取指定键对应的值集合，如果不存在则返回一个空的哈希集合。
+        /// </summary>
+        /// <param name="key">键。</param>
+        /// <returns>对应的值集合或空的哈希集合。</returns>
+        public HashSet<TValue> GetValue(TKey key)
+        {
+            if (TryGetValue(key, out HashSet<TValue> value))
+            {
+                return value;
+            }
+
+            return _empty;
+        }
+
+        /// <summary>
+        /// 从队列中获取一个空闲的值集合，或者创建一个新的。
+        /// </summary>
+        /// <returns>值集合。</returns>
+        private HashSet<TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new HashSet<TValue>() : _queue.Dequeue();
+        }
+
+        /// <summary>
+        /// 回收值集合到队列中，以便重复利用。
+        /// </summary>
+        /// <param name="list">要回收的值集合。</param>
+        private void Recycle(HashSet<TValue> list)
+        {
+            list.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit) return;
+
+            _queue.Enqueue(list);
+        }
+
+        /// <summary>
+        /// 清空集合中的数据并和队列。
+        /// </summary>
+        protected new void Clear()
+        {
+            base.Clear();
+            _queue.Clear();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/OneToManyHashSetPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4e0cac58c09d6429faba279d03ef2317
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/OneToManyListPool.cs

@@ -0,0 +1,253 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using NBC.Pool;
+
+#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.
+#pragma warning disable CS8603 // Possible null reference return.
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 可回收的、一对多关系的列表池。
+    /// </summary>
+    /// <typeparam name="TKey">键的类型。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class OneToManyListPool<TKey, TValue> : OneToManyList<TKey, TValue>, IDisposable, IPool where TKey : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个 <see cref="OneToManyListPool{TKey, TValue}"/> 一对多关系的列表池的实例。
+        /// </summary>
+        /// <returns>创建的实例。</returns>
+        public static OneToManyListPool<TKey, TValue> Create()
+        {
+#if FANTASY_WEBGL || FANTASY_EXPORTER
+            var list = Pool<OneToManyListPool<TKey, TValue>>.Rent();
+#else
+            var list = MultiThreadPool.Rent<OneToManyListPool<TKey, TValue>>();
+#endif
+            list._isDispose = false;
+            list._isPool = true;
+            return list;
+        }
+
+        /// <summary>
+        /// 释放当前对象所占用的资源，并将对象回收到对象池中。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL || FANTASY_EXPORTER
+            Pool<OneToManyListPool<TKey, TValue>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 一对多关系的列表字典。
+    /// </summary>
+    /// <typeparam name="TKey">键的类型。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class OneToManyList<TKey, TValue> : Dictionary<TKey, List<TValue>> where TKey : notnull
+    {
+        private readonly int _recyclingLimit = 120;
+        private static readonly List<TValue> Empty = new List<TValue>();
+        private readonly Queue<List<TValue>> _queue = new Queue<List<TValue>>();
+
+        /// <summary>
+        /// 初始化一个新的 <see cref="OneToManyList{TKey, TValue}"/> 实例。
+        /// </summary>
+        public OneToManyList() { }
+
+        /// <summary>
+        /// 对整个字典的所有 List 进行排序
+        /// </summary>
+        public void SortAll()
+        {
+            foreach (var key in Keys.ToList()) // 使用 ToList() 避免修改集合异常
+            {
+                this[key] = this[key].OrderByDescending(GetSortValue).ToList();
+            }
+        }
+
+        // 获取对象的排序值（SortAttribute 的值，默认 0）
+        private int GetSortValue(TValue obj)
+        {
+            if (obj == null) return 0;
+        
+            var sortAttr = obj.GetType().GetCustomAttribute<SortAttribute>();
+            return sortAttr?.Sort ?? 0;
+        }
+        
+        /// <summary>
+        /// 设置最大缓存数量
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public OneToManyList(int recyclingLimit)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        /// <summary>
+        /// 判断给定的键和值是否存在于列表中。
+        /// </summary>
+        /// <param name="key">要搜索的键。</param>
+        /// <param name="value">要搜索的值。</param>
+        /// <returns>如果存在则为 <see langword="true"/>，否则为 <see langword="false"/>。</returns>
+        public bool Contains(TKey key, TValue value)
+        {
+            TryGetValue(key, out var list);
+
+            return list != null && list.Contains(value);
+        }
+
+        /// <summary>
+        /// 向列表中添加指定键和值。
+        /// </summary>
+        /// <param name="key">要添加值的键。</param>
+        /// <param name="value">要添加的值。</param>
+        public void Add(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                list = Fetch();
+                list.Add(value);
+                Add(key, list);
+
+                return;
+            }
+
+            list.Add(value);
+        }
+
+        /// <summary>
+        /// 获取指定键对应的列表中的第一个值。
+        /// </summary>
+        /// <param name="key">要获取值的键。</param>
+        /// <returns>键对应的列表中的第一个值。</returns>
+        public TValue First(TKey key)
+        {
+            return !TryGetValue(key, out var list) ? default : list.FirstOrDefault();
+        }
+
+        /// <summary>
+        /// 从列表中移除指定键和值。
+        /// </summary>
+        /// <param name="key">要移除值的键。</param>
+        /// <param name="value">要移除的值。</param>
+        /// <returns>如果成功移除则为 <see langword="true"/>，否则为 <see langword="false"/>。</returns>
+        public bool RemoveValue(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                return true;
+            }
+
+            var isRemove = list.Remove(value);
+
+            if (list.Count == 0)
+            {
+                isRemove = RemoveByKey(key);
+            }
+
+            return isRemove;
+        }
+
+        /// <summary>
+        /// 从列表中移除指定键及其关联的所有值。
+        /// </summary>
+        /// <param name="key">要移除的键。</param>
+        /// <returns>如果成功移除则为 <see langword="true"/>，否则为 <see langword="false"/>。</returns>
+        public bool RemoveByKey(TKey key)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                return false;
+            }
+
+            Remove(key);
+            Recycle(list);
+            return true;
+        }
+
+        /// <summary>
+        /// 获取指定键关联的所有值的列表。
+        /// </summary>
+        /// <param name="key">要获取值的键。</param>
+        /// <returns>键关联的所有值的列表。</returns>
+        public List<TValue> GetValues(TKey key)
+        {
+            if (TryGetValue(key, out List<TValue> list))
+            {
+                return list;
+            }
+
+            return Empty;
+        }
+
+        /// <summary>
+        /// 清除字典中的所有键值对，并回收相关的值集合。
+        /// </summary>
+        public new void Clear()
+        {
+            foreach (var keyValuePair in this) Recycle(keyValuePair.Value);
+
+            base.Clear();
+        }
+
+        /// <summary>
+        /// 从空闲值集合队列中获取一个值集合，如果队列为空则创建一个新的值集合。
+        /// </summary>
+        /// <returns>从队列中获取的值集合。</returns>
+        private List<TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new List<TValue>() : _queue.Dequeue();
+        }
+
+        /// <summary>
+        /// 回收一个不再使用的值集合到空闲值集合队列中。
+        /// </summary>
+        /// <param name="list">要回收的值集合。</param>
+        private void Recycle(List<TValue> list)
+        {
+            list.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit) return;
+
+            _queue.Enqueue(list);
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/OneToManyListPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2c48383c842aa40b683f03b79f845932
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/OneToManyQueuePool.cs

@@ -0,0 +1,204 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+#pragma warning disable CS8603
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 支持一对多关系的队列池，用于存储具有相同键的值的队列集合。
+    /// </summary>
+    /// <typeparam name="TKey">键的类型。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class OneToManyQueuePool<TKey, TValue> : OneToManyQueue<TKey, TValue>, IDisposable, IPool where TKey : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个 <see cref="OneToManyQueuePool{TKey, TValue}"/> 一对多关系的队列池的实例。
+        /// </summary>
+        /// <returns>创建的实例。</returns>
+        public static OneToManyQueuePool<TKey, TValue> Create()
+        {
+#if FANTASY_WEBGL
+            var a = Pool<OneToManyQueuePool<TKey, TValue>>.Rent();
+#else
+            var a = MultiThreadPool.Rent<OneToManyQueuePool<TKey, TValue>>();
+#endif
+            a._isDispose = false;
+            a._isPool = true;
+            return a;
+        }
+
+        /// <summary>
+        /// 释放当前实例所占用的资源，并将实例回收到对象池中。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<OneToManyQueuePool<TKey, TValue>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 支持一对多关系的队列，用于存储具有相同键的值的队列集合。
+    /// </summary>
+    /// <typeparam name="TKey">键的类型。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class OneToManyQueue<TKey, TValue> : Dictionary<TKey, Queue<TValue>> where TKey : notnull
+    {
+        private readonly Queue<Queue<TValue>> _queue = new Queue<Queue<TValue>>();
+        private readonly int _recyclingLimit;
+
+        /// <summary>
+        /// 创建一个 <see cref="OneToManyQueue{TKey, TValue}"/> 一对多关系的队列的实例。设置最大缓存数量
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public OneToManyQueue(int recyclingLimit = 0)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        /// <summary>
+        /// 判断指定键的值队列是否包含指定的值。
+        /// </summary>
+        /// <param name="key">要查找的键。</param>
+        /// <param name="value">要查找的值。</param>
+        /// <returns>如果存在，则为 <c>true</c>；否则为 <c>false</c>。</returns>
+        public bool Contains(TKey key, TValue value)
+        {
+            TryGetValue(key, out var list);
+
+            return list != null && list.Contains(value);
+        }
+
+        /// <summary>
+        /// 将指定的值添加到指定键的值队列中。
+        /// </summary>
+        /// <param name="key">要添加值的键。</param>
+        /// <param name="value">要添加的值。</param>
+        public void Enqueue(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                list = Fetch();
+                list.Enqueue(value);
+                Add(key, list);
+                return;
+            }
+
+            list.Enqueue(value);
+        }
+
+        /// <summary>
+        /// 从指定键的值队列中出队一个值。
+        /// </summary>
+        /// <param name="key">要出队的键。</param>
+        /// <returns>出队的值。</returns>
+        public TValue Dequeue(TKey key)
+        {
+            if (!TryGetValue(key, out var list) || list.Count == 0)
+            {
+                return default;
+            }
+
+            var value = list.Dequeue();
+
+            if (list.Count == 0)
+            {
+                RemoveKey(key);
+            }
+
+            return value;
+        }
+
+        /// <summary>
+        /// 尝试从指定键的值队列中出队一个值。
+        /// </summary>
+        /// <param name="key">要出队的键。</param>
+        /// <param name="value">出队的值。</param>
+        /// <returns>如果成功出队，则为 <c>true</c>；否则为 <c>false</c>。</returns>
+        public bool TryDequeue(TKey key, out TValue value)
+        {
+            value = Dequeue(key);
+
+            return value != null;
+        }
+
+        /// <summary>
+        /// 从字典中移除指定键及其对应的值队列。
+        /// </summary>
+        /// <param name="key">要移除的键。</param>
+        public void RemoveKey(TKey key)
+        {
+            if (!TryGetValue(key, out var list)) return;
+
+            Remove(key);
+            Recycle(list);
+        }
+
+        /// <summary>
+        /// 从队列池中获取一个值队列。如果队列池为空，则创建一个新的值队列。
+        /// </summary>
+        /// <returns>获取的值队列。</returns>
+        private Queue<TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new Queue<TValue>() : _queue.Dequeue();
+        }
+
+        /// <summary>
+        /// 回收一个不再使用的值队列到队列池中，以便重用。
+        /// </summary>
+        /// <param name="list">要回收的值队列。</param>
+        private void Recycle(Queue<TValue> list)
+        {
+            list.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit) return;
+
+            _queue.Enqueue(list);
+        }
+
+        /// <summary>
+        /// 清空当前实例的数据，同时回收所有值队列。
+        /// </summary>
+        protected new void Clear()
+        {
+            base.Clear();
+            _queue.Clear();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/OneToManyQueuePool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8b6455b3359394987af4c0a4855189e9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/ReuseList.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 可重用的列表，继承自 <see cref="List{T}"/> 类。该类支持通过对象池重用列表实例，以减少对象分配和释放的开销。
+    /// </summary>
+    /// <typeparam name="T">列表中元素的类型。</typeparam>
+    public sealed class ReuseList<T> : List<T>, IDisposable, IPool
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个 <see cref="ReuseList{T}"/> 可重用的列表的实例。
+        /// </summary>
+        /// <returns>创建的实例。</returns>
+        public static ReuseList<T> Create()
+        {
+#if FANTASY_WEBGL
+            var list = Pool<ReuseList<T>>.Rent();
+#else
+            var list = MultiThreadPool.Rent<ReuseList<T>>();
+#endif
+            list._isDispose = false;
+            list._isPool = true;
+            return list;
+        }
+
+        /// <summary>
+        /// 释放该实例所占用的资源，并将实例返回到对象池中，以便重用。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<ReuseList<T>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/ReuseList.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9826877496b99479892a7359519298d5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/SortedConcurrentOneToManyListPool.cs

@@ -0,0 +1,226 @@
+#if !FANTASY_WEBGL
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NBC.Pool;
+
+#pragma warning disable CS8603
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 基于排序字典和并发集合实现的一对多映射列表的对象池包装类，继承自 <see cref="SortedConcurrentOneToManyList{TKey, TValue}"/> 类，
+    /// 同时实现了 <see cref="IDisposable"/> 接口，以支持对象的重用和释放。
+    /// </summary>
+    /// <typeparam name="TKey">键的类型。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class SortedConcurrentOneToManyListPool<TKey, TValue> : SortedConcurrentOneToManyList<TKey, TValue>, IDisposable, IPool where TKey : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个新的 <see cref="SortedConcurrentOneToManyListPool{TKey, TValue}"/> 实例，使用默认的参数设置。
+        /// </summary>
+        /// <returns>新创建的 <see cref="SortedConcurrentOneToManyListPool{TKey, TValue}"/> 实例。</returns>
+        public static SortedConcurrentOneToManyListPool<TKey, TValue> Create()
+        {
+            var a = MultiThreadPool.Rent<SortedConcurrentOneToManyListPool<TKey, TValue>>();
+            a._isDispose = false;
+            a._isPool = true;
+            return a;
+        }
+
+        /// <summary>
+        /// 释放当前对象池实例，将其返回到对象池以供重用。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+            MultiThreadPool.Return(this);
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 基于排序字典和并发集合实现的一多对映射列表类，继承自 <see cref="SortedDictionary{TKey, TValue}"/> 类，
+    /// 用于在多个值与一个键关联的情况下进行管理和存储。该类支持并发操作，适用于多线程环境。
+    /// </summary>
+    /// <typeparam name="TKey">键的类型。</typeparam>
+    /// <typeparam name="TValue">值的类型。</typeparam>
+    public class SortedConcurrentOneToManyList<TKey, TValue> : SortedDictionary<TKey, List<TValue>> where TKey : notnull
+    {
+        /// 用于同步操作的锁对象，它确保在多线程环境下对数据的安全访问。
+        private readonly object _lockObject = new object();
+        /// 用于存储缓存的队列。
+        private readonly Queue<List<TValue>> _queue = new Queue<List<TValue>>();
+        /// 控制缓存回收的限制。当缓存的数量超过此限制时，旧的缓存将会被回收。
+        private readonly int _recyclingLimit;
+
+        /// <summary>
+        /// 初始化一个新的 <see cref="SortedConcurrentOneToManyList{TKey, TValue}"/> 类的实例，使用默认的参数设置。
+        /// </summary>
+        public SortedConcurrentOneToManyList()
+        {
+        }
+
+        /// <summary>
+        /// 初始化一个新的 <see cref="SortedConcurrentOneToManyList{TKey, TValue}"/> 类的实例，指定最大缓存数量。
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public SortedConcurrentOneToManyList(int recyclingLimit = 0)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        /// <summary>
+        /// 检查指定的键和值是否存在于映射列表中。
+        /// </summary>
+        /// <param name="key">要检查的键。</param>
+        /// <param name="value">要检查的值。</param>
+        /// <returns>如果存在，则为 true；否则为 false。</returns>
+        public bool Contains(TKey key, TValue value)
+        {
+            lock (_lockObject)
+            {
+                TryGetValue(key, out var list);
+
+                return list != null && list.Contains(value);
+            }
+        }
+
+        /// <summary>
+        /// 将指定的值添加到与指定键关联的列表中。
+        /// </summary>
+        /// <param name="key">要关联值的键。</param>
+        /// <param name="value">要添加到列表的值。</param>
+        public void Add(TKey key, TValue value)
+        {
+            lock (_lockObject)
+            {
+                if (!TryGetValue(key, out var list))
+                {
+                    list = Fetch();
+                    list.Add(value);
+                    base[key] = list;
+                    return;
+                }
+
+                list.Add(value);
+            }
+        }
+
+        /// <summary>
+        /// 获取与指定键关联的列表中的第一个值。
+        /// 如果列表不存在或为空，则返回默认值。
+        /// </summary>
+        /// <param name="key">要获取第一个值的键。</param>
+        /// <returns>第一个值，或默认值。</returns>
+        public TValue First(TKey key)
+        {
+            lock (_lockObject)
+            {
+                return !TryGetValue(key, out var list) ? default : list.FirstOrDefault();
+            }
+        }
+
+        /// <summary>
+        /// 从与指定键关联的列表中移除指定的值。
+        /// 如果列表不存在或值不存在于列表中，则不执行任何操作。
+        /// </summary>
+        /// <param name="key">要移除值的键。</param>
+        /// <param name="value">要移除的值。</param>
+        public void RemoveValue(TKey key, TValue value)
+        {
+            lock (_lockObject)
+            {
+                if (!TryGetValue(key, out var list)) return;
+
+                list.Remove(value);
+
+                if (list.Count == 0) RemoveKey(key);
+            }
+        }
+
+        /// <summary>
+        /// 从映射列表中移除指定的键及其关联的列表。
+        /// 如果键不存在于映射列表中，则不执行任何操作。
+        /// </summary>
+        /// <param name="key">要移除的键。</param>
+        public void RemoveKey(TKey key)
+        {
+            lock (_lockObject)
+            {
+                if (!TryGetValue(key, out var list)) return;
+
+                Remove(key);
+
+                Recycle(list);
+            }
+        }
+
+        /// <summary>
+        /// 从缓存中获取一个可重用的列表。如果缓存中不存在列表，则创建一个新的列表并返回。
+        /// </summary>
+        /// <returns>可重用的列表。</returns>
+        private List<TValue> Fetch()
+        {
+            lock (_lockObject)
+            {
+                return _queue.Count <= 0 ? new List<TValue>() : _queue.Dequeue();
+            }
+        }
+
+        /// <summary>
+        /// 将不再使用的列表回收到缓存中，以便重复利用。如果缓存数量超过限制，则丢弃列表而不进行回收。
+        /// </summary>
+        /// <param name="list">要回收的列表。</param>
+        private void Recycle(List<TValue> list)
+        {
+            lock (_lockObject)
+            {
+                list.Clear();
+
+                if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit) return;
+
+                _queue.Enqueue(list);
+            }
+        }
+
+        /// <summary>
+        /// 清空映射列表以及队列。
+        /// </summary>
+        protected new void Clear()
+        {
+            base.Clear();
+            _queue.Clear();
+        }
+    }
+}
+#endif

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/SortedConcurrentOneToManyListPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fef1d9dea81914fcf9fc9f5b1e5989d5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/SortedOneToManyHashSetPool.cs

@@ -0,0 +1,192 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 基于排序字典实现的一对多关系的映射哈希集合的对象池包装类，将唯一键映射到多个值的哈希集合。
+    /// 同时实现了 <see cref="IDisposable"/> 接口，以支持对象的重用和释放。
+    /// </summary>
+    /// <typeparam name="TKey">字典中键的类型。</typeparam>
+    /// <typeparam name="TValue">哈希集合中值的类型。</typeparam>
+    public class SortedOneToManyHashSetPool<TKey, TValue> : SortedOneToManyHashSet<TKey, TValue>, IDisposable, IPool where TKey : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个 <see cref="SortedOneToManyHashSetPool{TKey, TValue}"/> 实例。
+        /// </summary>
+        /// <returns>新创建的实例。</returns>
+        public static SortedOneToManyHashSetPool<TKey, TValue> Create()
+        {
+#if FANTASY_WEBGL
+            var a = Pool<SortedOneToManyHashSetPool<TKey, TValue>>.Rent();
+#else
+            var a = MultiThreadPool.Rent<SortedOneToManyHashSetPool<TKey, TValue>>();
+#endif
+            a._isDispose = false;
+            a._isPool = true;
+            return a;
+        }
+
+        /// <summary>
+        /// 释放当前对象池实例，将其返回到对象池以供重用。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<SortedOneToManyHashSetPool<TKey, TValue>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 基于排序字典实现的一对多关系的映射哈希集合类，将唯一键映射到多个值的哈希集合。
+    /// 用于在多个值与一个键关联的情况下进行管理和存储。
+    /// </summary>
+    /// <typeparam name="TKey">字典中键的类型。</typeparam>
+    /// <typeparam name="TValue">集合中值的类型。</typeparam>
+    public class SortedOneToManyHashSet<TKey, TValue> : SortedDictionary<TKey, HashSet<TValue>> where TKey : notnull
+    {
+        private readonly Queue<HashSet<TValue>> _queue = new Queue<HashSet<TValue>>();
+        private readonly int _recyclingLimit = 120;
+
+        /// <summary>
+        /// 创建一个新的 <see cref="SortedOneToManyHashSet{TKey, TValue}"/> 实例。
+        /// </summary>
+        public SortedOneToManyHashSet() { }
+
+        /// <summary>
+        /// 创建一个新的 <see cref="SortedOneToManyHashSet{TKey, TValue}"/> 实例，设置最大缓存数量
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public SortedOneToManyHashSet(int recyclingLimit)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        /// <summary>
+        /// 判断哈希集合中是否包含指定的键值对。
+        /// </summary>
+        /// <param name="key">要查找的键。</param>
+        /// <param name="value">要查找的值。</param>
+        /// <returns>如果键值对存在，则为 true；否则为 false。</returns>
+        public bool Contains(TKey key, TValue value)
+        {
+            TryGetValue(key, out var list);
+
+            return list != null && list.Contains(value);
+        }
+
+        /// <summary>
+        /// 将指定值添加到给定键关联的哈希集合中。
+        /// </summary>
+        /// <param name="key">要添加值的键。</param>
+        /// <param name="value">要添加的值。</param>
+        public void Add(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                list = Fetch();
+                list.Add(value);
+                Add(key, list);
+
+                return;
+            }
+
+            list.Add(value);
+        }
+
+        /// <summary>
+        /// 从指定键关联的哈希集合中移除特定值。
+        /// 如果哈希集合不存在或值不存在于集合中，则不执行任何操作。
+        /// </summary>
+        /// <param name="key">要移除值的键。</param>
+        /// <param name="value">要移除的值。</param>
+        public void RemoveValue(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list)) return;
+
+            list.Remove(value);
+
+            if (list.Count == 0) RemoveKey(key);
+        }
+
+        /// <summary>
+        /// 从字典中移除指定键以及关联的哈希集合，并将集合进行回收。
+        /// 如果键不存在于映射列表中，则不执行任何操作。
+        /// </summary>
+        /// <param name="key">要移除的键。</param>
+        public void RemoveKey(TKey key)
+        {
+            if (!TryGetValue(key, out var list)) return;
+
+            Remove(key);
+
+            Recycle(list);
+        }
+
+        /// <summary>
+        /// 获取一个空的或回收的哈希集合。
+        /// </summary>
+        /// <returns>获取的哈希集合实例。</returns>
+        private HashSet<TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new HashSet<TValue>() : _queue.Dequeue();
+        }
+
+        /// <summary>
+        /// 回收一个哈希集合，将其清空并放入回收队列中。
+        /// </summary>
+        /// <param name="list">要回收的哈希集合。</param>
+        private void Recycle(HashSet<TValue> list)
+        {
+            list.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit) return;
+
+            _queue.Enqueue(list);
+        }
+
+        /// <summary>
+        /// 重写 Clear 方法，清空字典并清空回收队列。
+        /// </summary>
+        protected new void Clear()
+        {
+            base.Clear();
+            _queue.Clear();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/SortedOneToManyHashSetPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4fe9032846c3f4a11be30459a9e12d7a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/SortedOneToManyListPool.cs

@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NBC.Pool;
+
+#pragma warning disable CS8603
+
+namespace NBC.DataStructure.Collection
+{
+    /// <summary>
+    /// 基于排序字典实现的一对多映射列表的对象池包装类，继承自 <see cref="SortedOneToManyList{TKey, TValue}"/> 类，
+    /// 同时实现了 <see cref="IDisposable"/> 接口，以支持对象的重用和释放。
+    /// </summary>
+    /// <typeparam name="TKey">字典中键的类型。</typeparam>
+    /// <typeparam name="TValue">列表中值的类型。</typeparam>
+    public class SortedOneToManyListPool<TKey, TValue> : SortedOneToManyList<TKey, TValue>, IDisposable, IPool where TKey : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个 <see cref="SortedOneToManyListPool{TKey, TValue}"/> 实例。
+        /// </summary>
+        /// <returns>新创建的实例。</returns>
+        public static SortedOneToManyListPool<TKey, TValue> Create()
+        {
+#if FANTASY_WEBGL
+            var a = Pool<SortedOneToManyListPool<TKey, TValue>>.Rent();
+#else
+            var a = MultiThreadPool.Rent<SortedOneToManyListPool<TKey, TValue>>();
+#endif
+            a._isDispose = false;
+            a._isPool = true;
+            return a;
+        }
+
+        /// <summary>
+        /// 释放当前对象池实例，将其返回到对象池以供重用。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<SortedOneToManyListPool<TKey, TValue>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 基于排序字典实现的一对多关系的映射列表类，将唯一键映射到包含多个值的列表。
+    /// 用于在多个值与一个键关联的情况下进行管理和存储。
+    /// </summary>
+    /// <typeparam name="TKey">字典中键的类型。</typeparam>
+    /// <typeparam name="TValue">列表中值的类型。</typeparam>
+    public class SortedOneToManyList<TKey, TValue> : SortedDictionary<TKey, List<TValue>> where TKey : notnull
+    {
+        private readonly Queue<List<TValue>> _queue = new Queue<List<TValue>>();
+        private readonly int _recyclingLimit;
+
+        /// <summary>
+        /// 创建一个新的 <see cref="SortedOneToManyList{TKey, TValue}"/> 实例。
+        /// </summary>
+        public SortedOneToManyList()
+        {
+        }
+
+        /// <summary>
+        /// 创建一个新的 <see cref="SortedOneToManyList{TKey, TValue}"/> 实例，设置最大缓存数量
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public SortedOneToManyList(int recyclingLimit = 0)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        /// <summary>
+        /// 判断列表中是否包含指定的键值对。
+        /// </summary>
+        /// <param name="key">要查找的键。</param>
+        /// <param name="value">要查找的值。</param>
+        /// <returns>如果键值对存在，则为 true；否则为 false。</returns>
+        public bool Contains(TKey key, TValue value)
+        {
+            TryGetValue(key, out var list);
+
+            return list != null && list.Contains(value);
+        }
+
+        /// <summary>
+        /// 将指定值添加到给定键关联的列表中。
+        /// </summary>
+        /// <param name="key">要添加值的键。</param>
+        /// <param name="value">要添加的值。</param>
+        public void Add(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                list = Fetch();
+                list.Add(value);
+                base[key] = list;
+                return;
+            }
+
+            list.Add(value);
+        }
+
+        /// <summary>
+        /// 获取指定键关联的列表中的第一个值。
+        /// </summary>
+        /// <param name="key">要查找值的键。</param>
+        /// <returns>指定键关联的列表中的第一个值，如果列表为空则返回默认值。</returns>
+        public TValue First(TKey key)
+        {
+            return !TryGetValue(key, out var list) ? default : list.FirstOrDefault();
+        }
+
+        /// <summary>
+        /// 从指定键关联的列表中移除特定值。
+        /// </summary>
+        /// <param name="key">要移除值的键。</param>
+        /// <param name="value">要移除的值。</param>
+
+        public void RemoveValue(TKey key, TValue value)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                return;
+            }
+
+            list.Remove(value);
+
+            if (list.Count == 0)
+            {
+                RemoveKey(key);
+            }
+        }
+
+        /// <summary>
+        /// 从字典中移除指定键以及关联的列表，并将列表进行回收。
+        /// </summary>
+        /// <param name="key">要移除的键。</param>
+
+        public void RemoveKey(TKey key)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                return;
+            }
+
+            Remove(key);
+            Recycle(list);
+        }
+
+        /// <summary>
+        /// 获取一个空的或回收的列表。
+        /// </summary>
+        /// <returns>获取的列表实例。</returns>
+        private List<TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new List<TValue>() : _queue.Dequeue();
+        }
+
+        /// <summary>
+        /// 回收一个列表，将其清空并放入回收队列中。如果缓存数量超过限制，则丢弃列表而不进行回收
+        /// </summary>
+        /// <param name="list">要回收的列表。</param>
+        private void Recycle(List<TValue> list)
+        {
+            list.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit)
+            {
+                return;
+            }
+
+            _queue.Enqueue(list);
+        }
+
+        /// <summary>
+        /// 重写 Clear 方法，清空字典并清空回收队列。
+        /// </summary>
+        protected new void Clear()
+        {
+            base.Clear();
+            _queue.Clear();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Collection/SortedOneToManyListPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8e0621d52f951402daa68b108d7129f4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4a444c902ff594bbaa3a3fb394e7f53a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/DictionaryExtensions.cs

@@ -0,0 +1,31 @@
+using System.Collections.Generic;
+#pragma warning disable CS8601 // Possible null reference assignment.
+
+namespace NBC.DataStructure.Dictionary
+{
+    /// <summary>
+    /// 提供对字典的扩展方法。
+    /// </summary>
+    public static class DictionaryExtensions
+    {
+        /// <summary>
+        /// 尝试从字典中移除指定键，并返回相应的值。
+        /// </summary>
+        /// <typeparam name="T">字典中键的类型。</typeparam>
+        /// <typeparam name="TV">字典中值的类型。</typeparam>
+        /// <param name="self">要操作的字典实例。</param>
+        /// <param name="key">要移除的键。</param>
+        /// <param name="value">从字典中移除的值（如果成功移除）。</param>
+        /// <returns>如果成功移除键值对，则为 true；否则为 false。</returns>
+        public static bool TryRemove<T, TV>(this IDictionary<T, TV> self, T key, out TV value)
+        {
+            if (!self.TryGetValue(key, out value))
+            {
+                return false;
+            }
+
+            self.Remove(key);
+            return true;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/DictionaryExtensions.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6975fd47ec81d474cbd1ba996d01e864
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/DictionaryPool.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+namespace NBC.DataStructure.Dictionary
+{
+    /// <summary>
+    /// 提供一个可以使用对象池管理的字典类。
+    /// </summary>
+    /// <typeparam name="TM">字典中键的类型。</typeparam>
+    /// <typeparam name="TN">字典中值的类型。</typeparam>
+    public sealed class DictionaryPool<TM, TN> : Dictionary<TM, TN>, IDisposable, IPool where TM : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 释放实例占用的资源。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<DictionaryPool<TM, TN>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 创建一个新的 <see cref="DictionaryPool{TM, TN}"/> 实例。
+        /// </summary>
+        /// <returns>新创建的实例。</returns>
+        public static DictionaryPool<TM, TN> Create()
+        {
+#if FANTASY_WEBGL
+            var dictionary = Pool<DictionaryPool<TM, TN>>.Rent();
+#else
+            var dictionary = MultiThreadPool.Rent<DictionaryPool<TM, TN>>();
+#endif
+            dictionary._isDispose = false;
+            dictionary._isPool = true;
+            return dictionary;
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/DictionaryPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 421f6528d2cff461dab994c2f358f24d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/DoubleMapDictionaryPool.cs

@@ -0,0 +1,289 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+#pragma warning disable CS8601 // Possible null reference assignment.
+#pragma warning disable CS8604 // Possible null reference argument.
+#pragma warning disable CS8603 // Possible null reference return.
+
+namespace NBC.DataStructure.Dictionary
+{
+    /// <summary>
+    /// 提供一个双向映射字典对象池类，用于双向键值对映射。
+    /// </summary>
+    /// <typeparam name="TKey">字典中键的类型。</typeparam>
+    /// <typeparam name="TValue">字典中值的类型。</typeparam>
+    public class DoubleMapDictionaryPool<TKey, TValue> : DoubleMapDictionary<TKey, TValue>, IDisposable, IPool where TKey : notnull where TValue : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个新的 <see cref="DoubleMapDictionaryPool{TKey, TValue}"/> 实例。
+        /// </summary>
+        /// <returns>新创建的实例。</returns>
+        public static DoubleMapDictionaryPool<TKey, TValue> Create()
+        {
+#if FANTASY_WEBGL
+            var a = Pool<DoubleMapDictionaryPool<TKey, TValue>>.Rent();
+#else
+            var a = MultiThreadPool.Rent<DoubleMapDictionaryPool<TKey, TValue>>();
+#endif
+            a._isDispose = false;
+            a._isPool = true;
+            return a;
+        }
+
+        /// <summary>
+        /// 释放实例占用的资源。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<DoubleMapDictionaryPool<TKey, TValue>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 可以实现双向映射的字典类，用于将键和值进行双向映射。
+    /// </summary>
+    /// <typeparam name="TK">键的类型，不能为 null。</typeparam>
+    /// <typeparam name="TV">值的类型，不能为 null。</typeparam>
+    public class DoubleMapDictionary<TK, TV> where TK : notnull where TV : notnull
+    {
+        private readonly Dictionary<TK, TV> _kv = new Dictionary<TK, TV>();
+        private readonly Dictionary<TV, TK> _vk = new Dictionary<TV, TK>();
+
+        /// <summary>
+        /// 创建一个新的空的 <see cref="DoubleMapDictionary{TK, TV}"/> 实例。
+        /// </summary>
+        public DoubleMapDictionary() { }
+
+        /// <summary>
+        /// 创建一个新的具有指定初始容量的 <see cref="DoubleMapDictionary{TK, TV}"/> 实例。
+        /// </summary>
+        /// <param name="capacity">初始容量。</param>
+        public DoubleMapDictionary(int capacity)
+        {
+            _kv = new Dictionary<TK, TV>(capacity);
+            _vk = new Dictionary<TV, TK>(capacity);
+        }
+
+        /// <summary>
+        /// 获取包含字典中所有键的列表。
+        /// </summary>
+        public List<TK> Keys => new List<TK>(_kv.Keys);
+
+        /// <summary>
+        /// 获取包含字典中所有值的列表。
+        /// </summary>
+        public List<TV> Values => new List<TV>(_vk.Keys);
+
+        /// <summary>
+        /// 对字典中的每个键值对执行指定的操作。
+        /// </summary>
+        /// <param name="action">要执行的操作。</param>
+        public void ForEach(Action<TK, TV> action)
+        {
+            if (action == null)
+            {
+                return;
+            }
+
+            var keys = _kv.Keys;
+            foreach (var key in keys)
+            {
+                action(key, _kv[key]);
+            }
+        }
+
+        /// <summary>
+        /// 将指定的键值对添加到字典中。
+        /// </summary>
+        /// <param name="key">要添加的键。</param>
+        /// <param name="value">要添加的值。</param>
+        public void Add(TK key, TV value)
+        {
+            if (key == null || value == null || _kv.ContainsKey(key) || _vk.ContainsKey(value))
+            {
+                return;
+            }
+
+            _kv.Add(key, value);
+            _vk.Add(value, key);
+        }
+
+        /// <summary>
+        /// 根据指定的键获取相应的值。
+        /// </summary>
+        /// <param name="key">要查找值的键。</param>
+        /// <returns>与指定键关联的值，如果找不到键，则返回默认值。</returns>
+        public TV GetValueByKey(TK key)
+        {
+            if (key != null && _kv.ContainsKey(key))
+            {
+                return _kv[key];
+            }
+
+            return default;
+        }
+
+        /// <summary>
+        /// 尝试根据指定的键获取相应的值。
+        /// </summary>
+        /// <param name="key">要查找值的键。</param>
+        /// <param name="value">如果找到，则为与指定键关联的值；否则为值的默认值。</param>
+        /// <returns>如果找到键，则为 true；否则为 false。</returns>
+        public bool TryGetValueByKey(TK key, out TV value)
+        {
+            var result = key != null && _kv.ContainsKey(key);
+
+            value = result ? _kv[key] : default;
+
+            return result;
+        }
+
+        /// <summary>
+        /// 根据指定的值获取相应的键。
+        /// </summary>
+        /// <param name="value">要查找键的值。</param>
+        /// <returns>与指定值关联的键，如果找不到值，则返回默认键。</returns>
+        public TK GetKeyByValue(TV value)
+        {
+            if (value != null && _vk.ContainsKey(value))
+            {
+                return _vk[value];
+            }
+
+            return default;
+        }
+
+        /// <summary>
+        /// 尝试根据指定的值获取相应的键。
+        /// </summary>
+        /// <param name="value">要查找键的值。</param>
+        /// <param name="key">如果找到，则为与指定值关联的键；否则为键的默认值。</param>
+        /// <returns>如果找到值，则为 true；否则为 false。</returns>
+        public bool TryGetKeyByValue(TV value, out TK key)
+        {
+            var result = value != null && _vk.ContainsKey(value);
+
+            key = result ? _vk[value] : default;
+
+            return result;
+        }
+
+        /// <summary>
+        /// 根据指定的键移除键值对。
+        /// </summary>
+        /// <param name="key">要移除的键。</param>
+        public void RemoveByKey(TK key)
+        {
+            if (key == null)
+            {
+                return;
+            }
+
+            if (!_kv.TryGetValue(key, out var value))
+            {
+                return;
+            }
+
+            _kv.Remove(key);
+            _vk.Remove(value);
+        }
+
+        /// <summary>
+        /// 根据指定的值移除键值对。
+        /// </summary>
+        /// <param name="value">要移除的值。</param>
+        public void RemoveByValue(TV value)
+        {
+            if (value == null)
+            {
+                return;
+            }
+
+            if (!_vk.TryGetValue(value, out var key))
+            {
+                return;
+            }
+
+            _kv.Remove(key);
+            _vk.Remove(value);
+        }
+
+        /// <summary>
+        /// 清空字典中的所有键值对。
+        /// </summary>
+        public void Clear()
+        {
+            _kv.Clear();
+            _vk.Clear();
+        }
+
+        /// <summary>
+        /// 判断字典是否包含指定的键。
+        /// </summary>
+        /// <param name="key">要检查的键。</param>
+        /// <returns>如果字典包含指定的键，则为 true；否则为 false。</returns>
+        public bool ContainsKey(TK key)
+        {
+            return key != null && _kv.ContainsKey(key);
+        }
+
+        /// <summary>
+        /// 判断字典是否包含指定的值。
+        /// </summary>
+        /// <param name="value">要检查的值。</param>
+        /// <returns>如果字典包含指定的值，则为 true；否则为 false。</returns>
+        public bool ContainsValue(TV value)
+        {
+            return value != null && _vk.ContainsKey(value);
+        }
+
+        /// <summary>
+        /// 判断字典是否包含指定的键值对。
+        /// </summary>
+        /// <param name="key">要检查的键。</param>
+        /// <param name="value">要检查的值。</param>
+        /// <returns>如果字典包含指定的键值对，则为 true；否则为 false。</returns>
+        public bool Contains(TK key, TV value)
+        {
+            if (key == null || value == null)
+            {
+                return false;
+            }
+
+            return _kv.ContainsKey(key) && _vk.ContainsKey(value);
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/DoubleMapDictionaryPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a23375ac49ac64827a5d2e6ae476bbab
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/EntityDictionary.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+namespace NBC.DataStructure.Dictionary
+{
+    /// <summary>
+    /// 提供一个带资源释放功能的实体字典类，支持使用对象池管理。
+    /// </summary>
+    /// <typeparam name="TM">字典中键的类型。</typeparam>
+    /// <typeparam name="TN">字典中值的类型，必须实现 IDisposable 接口。</typeparam>
+    public sealed class EntityDictionary<TM, TN> : Dictionary<TM, TN>, IDisposable, IPool where TN : IDisposable where TM : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个新的 <see cref="EntityDictionary{TM, TN}"/> 实例。
+        /// </summary>
+        /// <returns>新创建的实例。</returns>
+        public static EntityDictionary<TM, TN> Create()
+        {
+#if FANTASY_WEBGL
+            var entityDictionary = Pool<EntityDictionary<TM, TN>>.Rent();
+#else
+            var entityDictionary = MultiThreadPool.Rent<EntityDictionary<TM, TN>>();
+#endif
+            entityDictionary._isDispose = false;
+            entityDictionary._isPool = true;
+            return entityDictionary;
+        }
+
+        /// <summary>
+        /// 清空字典中的所有键值对，并释放值的资源。
+        /// </summary>
+        public new void Clear()
+        {
+            foreach (var keyValuePair in this)
+            {
+                keyValuePair.Value.Dispose();
+            }
+
+            base.Clear();
+        }
+
+        /// <summary>
+        /// 清空字典中的所有键值对，但不释放值的资源。
+        /// </summary>
+        public void ClearNotDispose()
+        {
+            base.Clear();
+        }
+
+        /// <summary>
+        /// 释放实例占用的资源。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<EntityDictionary<TM, TN>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/EntityDictionary.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 30708df4a385e4aee83551b3371240fe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/OneToManyDictionaryPool.cs

@@ -0,0 +1,247 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NBC.Pool;
+
+#pragma warning disable CS8603
+#pragma warning disable CS8601
+
+namespace NBC.DataStructure.Dictionary
+{
+    /// <summary>
+    /// 一对多映射关系的字典对象池。
+    /// </summary>
+    /// <typeparam name="TKey">外部字典中的键类型。</typeparam>
+    /// <typeparam name="TValueKey">内部字典中的键类型。</typeparam>
+    /// <typeparam name="TValue">内部字典中的值类型。</typeparam>
+    public class OneToManyDictionaryPool<TKey, TValueKey, TValue> : OneToManyDictionary<TKey, TValueKey, TValue>, IDisposable, IPool where TKey : notnull where TValueKey : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个 <see cref="OneToManyDictionaryPool{TKey, TValueKey, TValue}"/> 的实例。
+        /// </summary>
+        /// <returns>新创建的 OneToManyDictionaryPool 实例。</returns>
+        public static OneToManyDictionaryPool<TKey, TValueKey, TValue> Create()
+        {
+#if FANTASY_WEBGL
+            var a = Pool<OneToManyDictionaryPool<TKey, TValueKey, TValue>>.Rent();
+#else
+            var a = MultiThreadPool.Rent<OneToManyDictionaryPool<TKey, TValueKey, TValue>>();
+#endif
+            a._isDispose = false;
+            a._isPool = true;
+            return a;
+        }
+
+        /// <summary>
+        /// 释放当前实例及其资源。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<OneToManyDictionaryPool<TKey, TValueKey, TValue>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 一对多映射关系的字典。每个键都对应一个内部字典，该内部字典将键值映射到相应的值。
+    /// </summary>
+    /// <typeparam name="TKey">外部字典中的键类型。</typeparam>
+    /// <typeparam name="TValueKey">内部字典中的键类型。</typeparam>
+    /// <typeparam name="TValue">内部字典中的值类型。</typeparam>
+    public class OneToManyDictionary<TKey, TValueKey, TValue> : Dictionary<TKey, Dictionary<TValueKey, TValue>>
+        where TKey : notnull where TValueKey : notnull
+    {
+        private readonly Queue<Dictionary<TValueKey, TValue>> _queue = new Queue<Dictionary<TValueKey, TValue>>();
+        private readonly int _recyclingLimit = 120;
+
+        /// <summary>
+        /// 创建一个新的 <see cref="OneToManyDictionary{TKey, TValueKey, TValue}"/> 实例。
+        /// </summary>
+        public OneToManyDictionary() { }
+
+        /// <summary>
+        /// 创建一个新的 <see cref="OneToManyDictionary{TKey, TValueKey, TValue}"/> 实例，并指定最大缓存数量。
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public OneToManyDictionary(int recyclingLimit = 0)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        /// <summary>
+        /// 检查是否包含指定的键值对。
+        /// </summary>
+        /// <param name="key">外部字典中的键。</param>
+        /// <param name="valueKey">内部字典中的键。</param>
+        /// <returns>如果包含指定的键值对，则为 true；否则为 false。</returns>
+        public bool Contains(TKey key, TValueKey valueKey)
+        {
+            TryGetValue(key, out var dic);
+
+            return dic != null && dic.ContainsKey(valueKey);
+        }
+
+        /// <summary>
+        /// 尝试获取指定键值对的值。
+        /// </summary>
+        /// <param name="key">外部字典中的键。</param>
+        /// <param name="valueKey">内部字典中的键。</param>
+        /// <param name="value">获取的值，如果操作成功，则为值；否则为默认值。</param>
+        /// <returns>如果操作成功，则为 true；否则为 false。</returns>
+        public bool TryGetValue(TKey key, TValueKey valueKey, out TValue value)
+        {
+            value = default;
+            return TryGetValue(key, out var dic) && dic.TryGetValue(valueKey, out value);
+        }
+
+        /// <summary>
+        /// 获取指定键的第一个值。
+        /// </summary>
+        /// <param name="key">要获取第一个值的键。</param>
+        public TValue First(TKey key)
+        {
+            return !TryGetValue(key, out var dic) ? default : dic.First().Value;
+        }
+
+        /// <summary>
+        /// 向字典中添加指定的键值对。
+        /// </summary>
+        /// <param name="key">要添加键值对的键。</param>
+        /// <param name="valueKey">要添加键值对的内部字典键。</param>
+        /// <param name="value">要添加的值。</param>
+        public void Add(TKey key, TValueKey valueKey, TValue value)
+        {
+            if (!TryGetValue(key, out var dic))
+            {
+                dic = Fetch();
+                dic[valueKey] = value;
+                // dic.Add(valueKey, value);
+                Add(key, dic);
+
+                return;
+            }
+
+            dic[valueKey] = value;
+            // dic.Add(valueKey, value);
+        }
+
+        /// <summary>
+        /// 从字典中移除指定的键值对。
+        /// </summary>
+        /// <param name="key">要移除键值对的键。</param>
+        /// <param name="valueKey">要移除键值对的内部字典键。</param>
+        /// <returns>如果成功移除键值对，则为 true；否则为 false。</returns>
+        public bool Remove(TKey key, TValueKey valueKey)
+        {
+            if (!TryGetValue(key, out var dic)) return false;
+
+            var result = dic.Remove(valueKey);
+
+            if (dic.Count == 0) RemoveKey(key);
+
+            return result;
+        }
+
+        /// <summary>
+        /// 从字典中移除指定的键值对。
+        /// </summary>
+        /// <param name="key">要移除键值对的键。</param>
+        /// <param name="valueKey">要移除键值对的内部字典键。</param>
+        /// <param name="value">如果成功移除键值对，则为移除的值；否则为默认值。</param>
+        /// <returns>如果成功移除键值对，则为 true；否则为 false。</returns>
+        public bool Remove(TKey key, TValueKey valueKey, out TValue value)
+        {
+            if (!TryGetValue(key, out var dic))
+            {
+                value = default;
+                return false;
+            }
+
+            var result = dic.TryGetValue(valueKey, out value);
+
+            if (result) dic.Remove(valueKey);
+
+            if (dic.Count == 0) RemoveKey(key);
+
+            return result;
+        }
+
+        /// <summary>
+        /// 移除字典中的指定键及其相关的所有键值对。
+        /// </summary>
+        /// <param name="key">要移除的键。</param>
+        public void RemoveKey(TKey key)
+        {
+            if (!TryGetValue(key, out var dic)) return;
+
+            Remove(key);
+            Recycle(dic);
+        }
+
+        /// <summary>
+        /// 从对象池中获取一个内部字典实例，如果池中没有，则创建一个新实例。
+        /// </summary>
+        /// <returns>获取的内部字典实例。</returns>
+        private Dictionary<TValueKey, TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new Dictionary<TValueKey, TValue>() : _queue.Dequeue();
+        }
+
+        /// <summary>
+        /// 将不再使用的内部字典实例放回对象池中，以便后续重用。
+        /// </summary>
+        /// <param name="dic">要放回对象池的内部字典实例。</param>
+        private void Recycle(Dictionary<TValueKey, TValue> dic)
+        {
+            dic.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit) return;
+
+            _queue.Enqueue(dic);
+        }
+
+        /// <summary>
+        /// 清空字典中的所有键值对，并将不再使用的内部字典实例放回对象池中。
+        /// </summary>
+        public new void Clear()
+        {
+            foreach (var keyValuePair in this) Recycle(keyValuePair.Value);
+
+            base.Clear();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/OneToManyDictionaryPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4cd83a6bbc1914aa4bf1f94f1cba1c47
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/OneToManySortedDictionaryPool.cs

@@ -0,0 +1,250 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+#pragma warning disable CS8601
+
+namespace NBC.DataStructure.Dictionary
+{
+    /// <summary>
+    /// 一对多映射关系的排序字典对象池。
+    /// </summary>
+    /// <typeparam name="TKey">外部字典中的键类型。</typeparam>
+    /// <typeparam name="TSortedKey">内部字典中的排序键类型。</typeparam>
+    /// <typeparam name="TValue">内部字典中的值类型。</typeparam>
+    public class OneToManySortedDictionaryPool<TKey, TSortedKey, TValue> : OneToManySortedDictionary<TKey, TSortedKey, TValue>, IDisposable, IPool where TKey : notnull where TSortedKey : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个 <see cref="OneToManySortedDictionaryPool{TKey, TSortedKey, TValue}"/> 的实例。
+        /// </summary>
+        /// <returns>新创建的 OneToManySortedDictionaryPool 实例。</returns>
+        public static OneToManySortedDictionaryPool<TKey, TSortedKey, TValue> Create()
+        {
+#if FANTASY_WEBGL
+            var a = Pool<OneToManySortedDictionaryPool<TKey, TSortedKey, TValue>>.Rent();
+#else
+            var a = MultiThreadPool.Rent<OneToManySortedDictionaryPool<TKey, TSortedKey, TValue>>();
+#endif
+            a._isDispose = false;
+            a._isPool = true;
+            return a;
+        }
+
+        /// <summary>
+        /// 释放当前实例及其资源。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<OneToManySortedDictionaryPool<TKey, TSortedKey, TValue>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+
+    /// <summary>
+    /// 一对多映射关系的排序字典。每个外部键映射到一个内部排序字典，该内部排序字典将排序键映射到相应的值。
+    /// </summary>
+    /// <typeparam name="TKey">外部字典中的键类型。</typeparam>
+    /// <typeparam name="TSortedKey">内部字典中的排序键类型。</typeparam>
+    /// <typeparam name="TValue">内部字典中的值类型。</typeparam>
+    public class
+        OneToManySortedDictionary<TKey, TSortedKey, TValue> : Dictionary<TKey, SortedDictionary<TSortedKey, TValue>>
+        where TSortedKey : notnull where TKey : notnull
+    {
+        /// 缓存队列的回收限制
+        private readonly int _recyclingLimit = 120;
+        /// 缓存队列，用于存储已回收的内部排序字典
+        private readonly Queue<SortedDictionary<TSortedKey, TValue>> _queue = new Queue<SortedDictionary<TSortedKey, TValue>>();
+
+        /// <summary>
+        /// 创建一个新的 <see cref="OneToManySortedDictionary{TKey, TSortedKey, TValue}"/> 实例。
+        /// </summary>
+        protected OneToManySortedDictionary() { }
+
+        /// <summary>
+        /// 创建一个新的 <see cref="OneToManySortedDictionary{TKey, TSortedKey, TValue}"/> 实例。设置最大缓存数量
+        /// </summary>
+        /// <param name="recyclingLimit">
+        /// 1:防止数据量过大、所以超过recyclingLimit的数据还是走GC.
+        /// 2:设置成0不控制数量，全部缓存
+        /// </param>
+        public OneToManySortedDictionary(int recyclingLimit)
+        {
+            _recyclingLimit = recyclingLimit;
+        }
+
+        /// <summary>
+        /// 检查字典是否包含指定的外部键。
+        /// </summary>
+        /// <param name="key">要检查的外部键。</param>
+        /// <returns>如果字典包含指定的外部键，则为 true；否则为 false。</returns>
+        public bool Contains(TKey key)
+        {
+            return this.ContainsKey(key);
+        }
+
+        /// <summary>
+        /// 检查字典是否包含指定的外部键和排序键。
+        /// </summary>
+        /// <param name="key">要检查的外部键。</param>
+        /// <param name="sortedKey">要检查的排序键。</param>
+        /// <returns>如果字典包含指定的外部键和排序键，则为 true；否则为 false。</returns>
+        public bool Contains(TKey key, TSortedKey sortedKey)
+        {
+            return TryGetValue(key, out var dic) && dic.ContainsKey(sortedKey);
+        }
+
+        /// <summary>
+        /// 尝试从字典中获取指定外部键对应的内部排序字典。
+        /// </summary>
+        /// <param name="key">要获取内部排序字典的外部键。</param>
+        /// <param name="dic">获取到的内部排序字典，如果找不到则为 null。</param>
+        /// <returns>如果找到内部排序字典，则为 true；否则为 false。</returns>
+        public new bool TryGetValue(TKey key, out SortedDictionary<TSortedKey, TValue> dic)
+        {
+            return base.TryGetValue(key, out dic);
+        }
+
+        /// <summary>
+        /// 尝试从字典中获取指定外部键和排序键对应的值。
+        /// </summary>
+        /// <param name="key">要获取值的外部键。</param>
+        /// <param name="sortedKey">要获取值的排序键。</param>
+        /// <param name="value">获取到的值，如果找不到则为 default。</param>
+        /// <returns>如果找到值，则为 true；否则为 false。</returns>
+        public bool TryGetValueBySortedKey(TKey key, TSortedKey sortedKey, out TValue value)
+        {
+            if (base.TryGetValue(key, out var dic))
+            {
+                return dic.TryGetValue(sortedKey, out value);
+            }
+
+            value = default;
+            return false;
+        }
+
+        /// <summary>
+        /// 向字典中添加一个值，关联到指定的外部键和排序键。
+        /// </summary>
+        /// <param name="key">要关联值的外部键。</param>
+        /// <param name="sortedKey">要关联值的排序键。</param>
+        /// <param name="value">要添加的值。</param>
+        public void Add(TKey key, TSortedKey sortedKey, TValue value)
+        {
+            if (!TryGetValue(key, out var dic))
+            {
+                dic = Fetch();
+                dic.Add(sortedKey, value);
+                Add(key, dic);
+
+                return;
+            }
+
+            dic.Add(sortedKey, value);
+        }
+
+        /// <summary>
+        /// 从字典中移除指定外部键和排序键关联的值。
+        /// </summary>
+        /// <param name="key">要移除值的外部键。</param>
+        /// <param name="sortedKey">要移除值的排序键。</param>
+        /// <returns>如果成功移除值，则为 true；否则为 false。</returns>
+        public bool RemoveSortedKey(TKey key, TSortedKey sortedKey)
+        {
+            if (!TryGetValue(key, out var dic))
+            {
+                return false;
+            }
+
+            var isRemove = dic.Remove(sortedKey);
+
+            if (dic.Count == 0)
+            {
+                isRemove = RemoveKey(key);
+            }
+
+            return isRemove;
+        }
+
+        /// <summary>
+        /// 从字典中移除指定外部键及其关联的所有值。
+        /// </summary>
+        /// <param name="key">要移除的外部键。</param>
+        /// <returns>如果成功移除外部键及其关联的所有值，则为 true；否则为 false。</returns>
+        public bool RemoveKey(TKey key)
+        {
+            if (!TryGetValue(key, out var list))
+            {
+                return false;
+            }
+
+            Remove(key);
+            Recycle(list);
+            return true;
+        }
+
+        /// <summary>
+        /// 从缓存队列中获取一个内部排序字典。
+        /// </summary>
+        /// <returns>一个内部排序字典。</returns>
+        private SortedDictionary<TSortedKey, TValue> Fetch()
+        {
+            return _queue.Count <= 0 ? new SortedDictionary<TSortedKey, TValue>() : _queue.Dequeue();
+        }
+
+        /// <summary>
+        /// 回收一个内部排序字典到缓存队列。
+        /// </summary>
+        /// <param name="dic">要回收的内部排序字典。</param>
+        private void Recycle(SortedDictionary<TSortedKey, TValue> dic)
+        {
+            dic.Clear();
+
+            if (_recyclingLimit != 0 && _queue.Count > _recyclingLimit)
+            {
+                return;
+            }
+
+            _queue.Enqueue(dic);
+        }
+
+        /// <summary>
+        /// 清空字典以及内部排序字典缓存队列，释放所有资源。
+        /// </summary>
+        protected new void Clear()
+        {
+            base.Clear();
+            _queue.Clear();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/OneToManySortedDictionaryPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ece24c9ac70d549ea953523c0e5f7337
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/ReuseDictionary.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+namespace NBC.DataStructure.Dictionary
+{
+    /// <summary>
+    /// 提供一个可以重用的字典类，支持使用对象池管理。
+    /// </summary>
+    /// <typeparam name="TM">字典中键的类型。</typeparam>
+    /// <typeparam name="TN">字典中值的类型。</typeparam>
+    public sealed class ReuseDictionary<TM, TN> : Dictionary<TM, TN>, IDisposable, IPool where TM : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 创建一个新的 <see cref="ReuseDictionary{TM, TN}"/> 实例。
+        /// </summary>
+        /// <returns>新创建的实例。</returns>
+        public static ReuseDictionary<TM, TN> Create()
+        {
+#if FANTASY_WEBGL
+            var entityDictionary = Pool<ReuseDictionary<TM, TN>>.Rent();
+#else
+            var entityDictionary = MultiThreadPool.Rent<ReuseDictionary<TM, TN>>();
+#endif
+            entityDictionary._isDispose = false;
+            entityDictionary._isPool = true;
+            return entityDictionary;
+        }
+
+        /// <summary>
+        /// 释放实例占用的资源。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<ReuseDictionary<TM, TN>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/ReuseDictionary.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 882f28b6907a3465dbf9df04603f74b5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/SortedDictionaryPool.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+namespace NBC.DataStructure.Dictionary
+{
+    /// <summary>
+    /// 提供一个可以使用对象池管理的排序字典类。
+    /// </summary>
+    /// <typeparam name="TM"></typeparam>
+    /// <typeparam name="TN"></typeparam>
+    public sealed class SortedDictionaryPool<TM, TN> : SortedDictionary<TM, TN>, IDisposable, IPool where TM : notnull
+    {
+        private bool _isPool;
+        private bool _isDispose;
+
+        /// <summary>
+        /// 释放实例占用的资源。
+        /// </summary>
+        public void Dispose()
+        {
+            if (_isDispose)
+            {
+                return;
+            }
+
+            _isDispose = true;
+            Clear();
+#if FANTASY_WEBGL
+            Pool<SortedDictionaryPool<TM, TN>>.Return(this);
+#else
+            MultiThreadPool.Return(this);
+#endif
+        }
+
+        /// <summary>
+        /// 创建一个新的 <see cref="SortedDictionaryPool{TM, TN}"/> 实例。
+        /// </summary>
+        /// <returns>新创建的实例。</returns>
+        public static SortedDictionaryPool<TM, TN> Create()
+        {
+#if FANTASY_WEBGL
+            var dictionary = Pool<SortedDictionaryPool<TM, TN>>.Rent();
+#else
+            var dictionary = MultiThreadPool.Rent<SortedDictionaryPool<TM, TN>>();
+#endif
+            dictionary._isDispose = false;
+            dictionary._isPool = true;
+            return dictionary;
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/Dictionary/SortedDictionaryPool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 060121583adb64f03973db7e623b91de
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/NativeCollections.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6e0c05d3a90bc4c5d88144a87507f06d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/PriorityQueue.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2af7e2648850348b591adabb5ba44532
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/PriorityQueue/PriorityQueueGenerics.cs

@@ -0,0 +1,121 @@
+// ReSharper disable SwapViaDeconstruction
+// ReSharper disable UseIndexFromEndExpression
+// ReSharper disable ConvertToPrimaryConstructor
+using System;
+using System.Collections.Generic;
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+
+#pragma warning disable CS8601 // Possible null reference assignment.
+namespace NBC.DataStructure.PriorityQueue
+{
+    /// <summary>
+    /// 优先队列
+    /// </summary>
+    /// <typeparam name="TElement">节点数据</typeparam>
+    /// <typeparam name="TPriority">排序的类型、</typeparam>
+    public sealed class PriorityQueue<TElement, TPriority> where TPriority : IComparable<TPriority>
+    {
+        private readonly List<PriorityQueueItem<TElement, TPriority>> _heap;
+        
+        public PriorityQueue(int initialCapacity = 16)
+        {
+            _heap = new List<PriorityQueueItem<TElement, TPriority>>(initialCapacity);
+        }
+        
+        public int Count => _heap.Count;
+
+        public void Enqueue(TElement element, TPriority priority)
+        {
+            _heap.Add(new PriorityQueueItem<TElement, TPriority>(element, priority));
+            HeapifyUp(_heap.Count - 1);
+        }
+
+        public TElement Dequeue()
+        {
+            if (_heap.Count == 0)
+            {
+                throw new InvalidOperationException("The queue is empty.");
+            }
+            
+            var item = _heap[0]; 
+            _heap[0] = _heap[_heap.Count - 1];
+            _heap.RemoveAt(_heap.Count - 1);
+            HeapifyDown(0);
+            return item.Element;
+        }
+
+        public bool TryDequeue(out TElement element)
+        {
+            if (_heap.Count == 0)
+            {
+                element = default(TElement);
+                return false;
+            }
+
+            element = Dequeue();
+            return true;
+        }
+
+        public TElement Peek()
+        {
+            if (_heap.Count == 0)
+            {
+                throw new InvalidOperationException("The queue is empty.");
+            }
+            return _heap[0].Element;
+        }
+
+        // ReSharper disable once IdentifierTypo
+        private void HeapifyUp(int index)
+        {
+            while (index > 0)
+            {
+                var parentIndex = (index - 1) / 2;
+                if (_heap[index].Priority.CompareTo(_heap[parentIndex].Priority) >= 0)
+                {
+                    break;
+                }
+                Swap(index, parentIndex);
+                index = parentIndex;
+            }
+        }
+
+        // ReSharper disable once IdentifierTypo
+        private void HeapifyDown(int index)
+        {
+            var lastIndex = _heap.Count - 1;
+            while (true)
+            {
+                var smallestIndex = index;
+                var leftChildIndex = 2 * index + 1;
+                var rightChildIndex = 2 * index + 2;
+                
+                if (leftChildIndex <= lastIndex && _heap[leftChildIndex].Priority.CompareTo(_heap[smallestIndex].Priority) < 0)
+                {
+                    smallestIndex = leftChildIndex;
+                }
+                
+                if (rightChildIndex <= lastIndex && _heap[rightChildIndex].Priority.CompareTo(_heap[smallestIndex].Priority) < 0)
+                {
+                    smallestIndex = rightChildIndex;
+                }
+                
+                if (smallestIndex == index)
+                {
+                    break;
+                }
+                
+                Swap(index, smallestIndex);
+                index = smallestIndex;
+            }
+        }
+        
+        private void Swap(int index1, int index2)
+        {
+            var temp = _heap[index1];
+            _heap[index1] = _heap[index2];
+            _heap[index2] = temp;
+        }
+    }
+}
+

Assets/Scripts/NBC/Runtime/Core/DataStructure/PriorityQueue/PriorityQueueGenerics.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d0fb73a1acb1843ad86127be8503ed92
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/PriorityQueue/PriorityQueueItem.cs

@@ -0,0 +1,30 @@
+// ReSharper disable ConvertToPrimaryConstructor
+// ReSharper disable SwapViaDeconstruction
+// ReSharper disable InconsistentNaming
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+namespace NBC.DataStructure.PriorityQueue
+{
+    public struct PriorityQueueItemUint<T>
+    {
+        public T Element { get; set; }
+        public uint Priority { get; set; }
+
+        public PriorityQueueItemUint(T element, uint priority)
+        {
+            Element = element;
+            Priority = priority;
+        }
+    }
+    
+    public struct PriorityQueueItem<T, T1>
+    {
+        public T Element { get; }
+        public T1 Priority { get; }
+
+        public PriorityQueueItem(T element, T1 priority)
+        {
+            Element = element;
+            Priority = priority;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/PriorityQueue/PriorityQueueItem.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 79c4ab0531d874383b52d8b7082cf3a8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/PriorityQueue/PriorityQueueSimple.cs

@@ -0,0 +1,116 @@
+// ReSharper disable SwapViaDeconstruction
+// ReSharper disable UseIndexFromEndExpression
+// ReSharper disable ConvertToPrimaryConstructor
+using System;
+using System.Collections.Generic;
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+#pragma warning disable CS8601 // Possible null reference assignment.
+namespace NBC.DataStructure.PriorityQueue
+{
+    public sealed class PriorityQueue<T> where T : IComparable<T>
+    {
+        private readonly List<T> _heap;
+        
+        public PriorityQueue(int initialCapacity = 16)
+        {
+            _heap = new List<T>(initialCapacity);
+        }
+        
+        public int Count => _heap.Count;
+
+        public void Enqueue(T item)
+        {
+            _heap.Add(item);
+            HeapifyUp(_heap.Count - 1);
+        }
+
+        public T Dequeue()
+        {
+            if (_heap.Count == 0)
+            {
+                throw new InvalidOperationException("The queue is empty.");
+            }
+            
+            var item = _heap[0];
+            var heapCount = _heap.Count - 1;
+            _heap[0] = _heap[heapCount];
+            _heap.RemoveAt(heapCount);
+            HeapifyDown(0);
+            return item;
+        }
+
+        public bool TryDequeue(out T item)
+        {
+            if (_heap.Count == 0)
+            {
+                item = default(T);
+                return false;
+            }
+
+            item = Dequeue();
+            return true;
+        }
+
+        public T Peek()
+        {
+            if (_heap.Count == 0)
+            {
+                throw new InvalidOperationException("The queue is empty.");
+            }
+            return _heap[0];
+        }
+
+        // ReSharper disable once IdentifierTypo
+        private void HeapifyUp(int index)
+        {
+            while (index > 0)
+            {
+                var parentIndex = (index - 1) / 2;
+                if (_heap[index].CompareTo(_heap[parentIndex]) >= 0)
+                {
+                    break;
+                }
+                Swap(index, parentIndex);
+                index = parentIndex;
+            }
+        }
+
+        // ReSharper disable once IdentifierTypo
+        private void HeapifyDown(int index)
+        {
+            var lastIndex = _heap.Count - 1;
+            while (true)
+            {
+                var smallestIndex = index;
+                var leftChildIndex = 2 * index + 1;
+                var rightChildIndex = 2 * index + 2;
+                
+                if (leftChildIndex <= lastIndex && _heap[leftChildIndex].CompareTo(_heap[smallestIndex]) < 0)
+                {
+                    smallestIndex = leftChildIndex;
+                }
+                
+                if (rightChildIndex <= lastIndex && _heap[rightChildIndex].CompareTo(_heap[smallestIndex]) < 0)
+                {
+                    smallestIndex = rightChildIndex;
+                }
+                
+                if (smallestIndex == index)
+                {
+                    break;
+                }
+                
+                Swap(index, smallestIndex);
+                index = smallestIndex;
+            }
+        }
+        
+        private void Swap(int index1, int index2)
+        {
+            var temp = _heap[index1];
+            _heap[index1] = _heap[index2];
+            _heap[index2] = temp;
+        }
+    }
+}
+

Assets/Scripts/NBC/Runtime/Core/DataStructure/PriorityQueue/PriorityQueueSimple.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6c604a0410d104d68a5d1718a570e5c0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/SkipTable.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 68c20f8b3fb7f461f9b2f22aa39b4c2e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/SkipTable/SkipTable.cs

@@ -0,0 +1,190 @@
+
+#pragma warning disable CS8602 // Dereference of a possibly null reference.
+#pragma warning disable CS8601 // Possible null reference assignment.
+#pragma warning disable CS8604 // Possible null reference argument.
+#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.
+namespace NBC.DataStructure.SkipTable
+{
+    /// <summary>
+    /// 跳表数据结构（升序版）
+    /// </summary>
+    /// <typeparam name="TValue">跳表中存储的值的类型。</typeparam>
+    public class SkipTable<TValue> : SkipTableBase<TValue>
+    {
+        /// <summary>
+        /// 创建一个新的跳表实例。
+        /// </summary>
+        /// <param name="maxLayer">跳表的最大层数。</param>
+        public SkipTable(int maxLayer = 8) : base(maxLayer) { }
+
+        /// <summary>
+        /// 向跳表中添加一个新节点。
+        /// </summary>
+        /// <param name="sortKey">节点的主排序键。</param>
+        /// <param name="viceKey">节点的副排序键。</param>
+        /// <param name="key">节点的唯一键。</param>
+        /// <param name="value">要添加的值。</param>
+        public override void Add(long sortKey, long viceKey, long key, TValue value)
+        {
+            var rLevel = 1;
+
+            while (rLevel <= MaxLayer && Random.Next(3) == 0)
+            {
+                ++rLevel;
+            }
+
+            SkipTableNode<TValue> cur = TopHeader, last = null;
+
+            for (var layer = MaxLayer; layer >= 1; --layer)
+            {
+                // 节点有next节点，且 （next主键 < 插入主键） 或 （next主键 == 插入主键 且 next副键 < 插入副键） 
+                while (cur.Right != null && ((cur.Right.SortKey < sortKey) ||
+                                             (cur.Right.SortKey == sortKey && cur.Right.ViceKey < viceKey)))
+                {
+                    cur = cur.Right;
+                }
+
+                if (layer <= rLevel)
+                {
+                    var currentRight = cur.Right;
+
+                    // 在当前层插入新节点
+                    cur.Right = new SkipTableNode<TValue>(sortKey, viceKey, key, value, layer == 1 ? cur.Index + 1 : 0, cur, cur.Right, null);
+
+                    if (currentRight != null)
+                    {
+                        currentRight.Left = cur.Right;
+                    }
+
+                    if (last != null)
+                    {
+                        last.Down = cur.Right;
+                    }
+
+                    if (layer == 1)
+                    {
+                        // 更新索引信息
+                        cur.Right.Index = cur.Index + 1;
+                        Node.Add(key, cur.Right);
+
+                        SkipTableNode<TValue> v = cur.Right.Right;
+
+                        while (v != null)
+                        {
+                            v.Index++;
+                            v = v.Right;
+                        }
+                    }
+
+                    last = cur.Right;
+                }
+
+                cur = cur.Down;
+            }
+        }
+
+        /// <summary>
+        /// 从跳表中移除一个节点。
+        /// </summary>
+        /// <param name="sortKey">节点的主排序键。</param>
+        /// <param name="viceKey">节点的副排序键。</param>
+        /// <param name="key">节点的唯一键。</param>
+        /// <param name="value">被移除的节点的值。</param>
+        /// <returns>如果成功移除节点，则为 true；否则为 false。</returns>
+        public override bool Remove(long sortKey, long viceKey, long key, out TValue value)
+        {
+            value = default;
+            var seen = false;
+            var cur = TopHeader;
+
+            for (var layer = MaxLayer; layer >= 1; --layer)
+            {
+                // 先按照主键查找 再 按副键查找
+                while (cur.Right != null && cur.Right.SortKey < sortKey && cur.Right.Key != key) cur = cur.Right;
+                while (cur.Right != null && (cur.Right.SortKey == sortKey && cur.Right.ViceKey <= viceKey) &&
+                       cur.Right.Key != key) cur = cur.Right;
+
+                var isFind = false;
+                var currentCur = cur;
+                SkipTableNode<TValue> removeCur = null;
+                // 如果当前不是要删除的节点、但主键和副键都一样、需要特殊处理下。
+                if (cur.Right != null && cur.Right.Key == key)
+                {
+                    isFind = true;
+                    removeCur = cur.Right;
+                    currentCur = cur;
+                }
+                else
+                {
+                    // 先向左查找下
+                    var currentNode = cur.Left;
+                    while (currentNode != null && currentNode.SortKey == sortKey && currentNode.ViceKey == viceKey)
+                    {
+                        if (currentNode.Key == key)
+                        {
+                            isFind = true;
+                            removeCur = currentNode;
+                            currentCur = currentNode.Left;
+                            break;
+                        }
+
+                        currentNode = currentNode.Left;
+                    }
+
+                    // 再向右查找下
+                    if (!isFind)
+                    {
+                        currentNode = cur.Right;
+                        while (currentNode != null && currentNode.SortKey == sortKey && currentNode.ViceKey == viceKey)
+                        {
+                            if (currentNode.Key == key)
+                            {
+                                isFind = true;
+                                removeCur = currentNode;
+                                currentCur = currentNode.Left;
+                                break;
+                            }
+
+                            currentNode = currentNode.Right;
+                        }
+                    }
+                }
+
+                if (isFind && currentCur != null)
+                {
+                    value = removeCur.Value;
+                    currentCur.Right = removeCur.Right;
+
+                    if (removeCur.Right != null)
+                    {
+                        removeCur.Right.Left = currentCur;
+                        removeCur.Right = null;
+                    }
+
+                    removeCur.Left = null;
+                    removeCur.Down = null;
+                    removeCur.Value = default;
+
+                    if (layer == 1)
+                    {
+                        var tempCur = currentCur.Right;
+                        while (tempCur != null)
+                        {
+                            tempCur.Index--;
+                            tempCur = tempCur.Right;
+                        }
+
+                        Node.Remove(removeCur.Key);
+                    }
+
+                    seen = true;
+                }
+
+                cur = cur.Down;
+            }
+
+            return seen;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/SkipTable/SkipTable.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 45fbcdc219ef843aaa31594eb4e76a5b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/SkipTable/SkipTableBase.cs

@@ -0,0 +1,282 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NBC.DataStructure.Collection;
+
+#pragma warning disable CS8601
+#pragma warning disable CS8603
+#pragma warning disable CS8625
+#pragma warning disable CS8604
+
+namespace NBC.DataStructure.SkipTable
+{
+    /// <summary>
+    /// 抽象的跳表基类，提供跳表的基本功能和操作。
+    /// </summary>
+    /// <typeparam name="TValue">跳表中存储的值的类型。</typeparam>
+    public abstract class SkipTableBase<TValue> : IEnumerable<SkipTableNode<TValue>>
+    {
+        /// <summary>
+        /// 跳表的最大层数
+        /// </summary>
+        public readonly int MaxLayer;
+        /// <summary>
+        /// 跳表的顶部头节点
+        /// </summary>
+        public readonly SkipTableNode<TValue> TopHeader;
+        /// <summary>
+        /// 跳表的底部头节点
+        /// </summary>
+        public SkipTableNode<TValue> BottomHeader;
+        /// <summary>
+        /// 跳表中节点的数量，使用了 Node 字典的计数
+        /// </summary>
+        public int Count => Node.Count;
+        /// <summary>
+        /// 用于生成随机数的随机数生成器
+        /// </summary>
+        protected readonly Random Random = new Random();
+        /// <summary>
+        /// 存储跳表节点的字典
+        /// </summary>
+        protected readonly Dictionary<long, SkipTableNode<TValue>> Node = new();
+        /// <summary>
+        /// 用于辅助反向查找的栈
+        /// </summary>
+        protected readonly Stack<SkipTableNode<TValue>> AntiFindStack = new Stack<SkipTableNode<TValue>>();
+
+        /// <summary>
+        /// 初始化一个新的跳表实例。
+        /// </summary>
+        /// <param name="maxLayer">跳表的最大层数，默认为 8。</param>
+        protected SkipTableBase(int maxLayer = 8)
+        {
+            MaxLayer = maxLayer;
+            var cur = TopHeader = new SkipTableNode<TValue>(long.MinValue, 0, 0, default, 0, null, null, null);
+
+            for (var layer = MaxLayer - 1; layer >= 1; --layer)
+            {
+                cur.Down = new SkipTableNode<TValue>(long.MinValue, 0, 0, default, 0, null, null, null);
+                cur = cur.Down;
+            }
+
+            BottomHeader = cur;
+        }
+
+        /// <summary>
+        /// 获取指定键的节点的值，若不存在则返回默认值。
+        /// </summary>
+        /// <param name="key">要查找的键。</param>
+        public TValue this[long key] => !TryGetValueByKey(key, out TValue value) ? default : value;
+
+        /// <summary>
+        /// 获取指定键的节点在跳表中的排名。
+        /// </summary>
+        /// <param name="key">要查找的键。</param>
+        /// <returns>节点的排名。</returns>
+        public int GetRanking(long key)
+        {
+            if (!Node.TryGetValue(key, out var node))
+            {
+                return 0;
+            }
+
+            return node.Index;
+        }
+
+        /// <summary>
+        /// 获取指定键的反向排名，即在比该键更大的节点中的排名。
+        /// </summary>
+        /// <param name="key">要查找的键。</param>
+        /// <returns>反向排名。</returns>
+        public int GetAntiRanking(long key)
+        {
+            var ranking = GetRanking(key);
+
+            if (ranking == 0)
+            {
+                return 0;
+            }
+
+            return Count + 1 - ranking;
+        }
+
+        /// <summary>
+        /// 尝试通过键获取节点的值。
+        /// </summary>
+        /// <param name="key">要查找的键。</param>
+        /// <param name="value">获取到的节点的值，如果键不存在则为默认值。</param>
+        /// <returns>是否成功获取节点的值。</returns>
+        public bool TryGetValueByKey(long key, out TValue value)
+        {
+            if (!Node.TryGetValue(key, out var node))
+            {
+                value = default;
+                return false;
+            }
+
+            value = node.Value;
+            return true;
+        }
+
+        /// <summary>
+        /// 尝试通过键获取节点。
+        /// </summary>
+        /// <param name="key">要查找的键。</param>
+        /// <param name="node">获取到的节点，如果键不存在则为 <c>null</c>。</param>
+        /// <returns>是否成功获取节点。</returns>
+        public bool TryGetNodeByKey(long key, out SkipTableNode<TValue> node)
+        {
+            if (Node.TryGetValue(key, out node))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// 在跳表中查找节点，返回从起始位置到结束位置的节点列表。
+        /// </summary>
+        /// <param name="start">起始位置的排名。</param>
+        /// <param name="end">结束位置的排名。</param>
+        /// <param name="list">用于存储节点列表的 <see cref="ListPool{T}"/> 实例。</param>
+        public void Find(int start, int end, ListPool<SkipTableNode<TValue>> list)
+        {
+            var cur = BottomHeader;
+            var count = end - start;
+
+            for (var i = 0; i < start; i++)
+            {
+                cur = cur.Right;
+            }
+
+            for (var i = 0; i <= count; i++)
+            {
+                if (cur == null)
+                {
+                    break;
+                }
+
+                list.Add(cur);
+                cur = cur.Right;
+            }
+        }
+
+        /// <summary>
+        /// 在跳表中进行反向查找节点，返回从结束位置到起始位置的节点列表。
+        /// </summary>
+        /// <param name="start">结束位置的排名。</param>
+        /// <param name="end">起始位置的排名。</param>
+        /// <param name="list">用于存储节点列表的 <see cref="ListPool{T}"/> 实例。</param>
+        public void AntiFind(int start, int end, ListPool<SkipTableNode<TValue>> list)
+        {
+            var cur = BottomHeader;
+            start = Count + 1 - start;
+            end = start - end;
+
+            for (var i = 0; i < start; i++)
+            {
+                cur = cur.Right;
+
+                if (cur == null)
+                {
+                    break;
+                }
+
+                if (i < end)
+                {
+                    continue;
+                }
+
+                AntiFindStack.Push(cur);
+            }
+
+            while (AntiFindStack.TryPop(out var node))
+            {
+                list.Add(node);
+            }
+        }
+
+        /// <summary>
+        /// 获取跳表中最后一个节点的值。
+        /// </summary>
+        /// <returns>最后一个节点的值。</returns>
+        public TValue GetLastValue()
+        {
+            var cur = TopHeader;
+
+            while (cur.Right != null || cur.Down != null)
+            {
+                while (cur.Right != null)
+                {
+                    cur = cur.Right;
+                }
+
+                if (cur.Down != null)
+                {
+                    cur = cur.Down;
+                }
+            }
+
+            return cur.Value;
+        }
+
+        /// <summary>
+        /// 移除跳表中指定键的节点。
+        /// </summary>
+        /// <param name="key">要移除的节点的键。</param>
+        /// <returns>移除是否成功。</returns>
+        public bool Remove(long key)
+        {
+            if (!Node.TryGetValue(key, out var node))
+            {
+                return false;
+            }
+
+            return Remove(node.SortKey, node.ViceKey, key, out _);
+        }
+
+        /// <summary>
+        /// 向跳表中添加节点。
+        /// </summary>
+        /// <param name="sortKey">节点的排序键。</param>
+        /// <param name="viceKey">节点的副键。</param>
+        /// <param name="key">节点的键。</param>
+        /// <param name="value">节点的值。</param>
+        public abstract void Add(long sortKey, long viceKey, long key, TValue value);
+
+        /// <summary>
+        /// 从跳表中移除指定键的节点。
+        /// </summary>
+        /// <param name="sortKey">节点的排序键。</param>
+        /// <param name="viceKey">节点的副键。</param>
+        /// <param name="key">节点的键。</param>
+        /// <param name="value">被移除的节点的值。</param>
+        /// <returns>移除是否成功。</returns>
+        public abstract bool Remove(long sortKey, long viceKey, long key, out TValue value);
+
+        /// <summary>
+        /// 返回一个枚举器，用于遍历跳表中的节点。
+        /// </summary>
+        /// <returns>一个可用于遍历跳表节点的枚举器。</returns>
+        public IEnumerator<SkipTableNode<TValue>> GetEnumerator()
+        {
+            var cur = BottomHeader.Right;
+            while (cur != null)
+            {
+                yield return cur;
+                cur = cur.Right;
+            }
+        }
+
+        /// <summary>
+        /// 返回一个非泛型枚举器，用于遍历跳表中的节点。
+        /// </summary>
+        /// <returns>一个非泛型枚举器，可用于遍历跳表节点。</returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/SkipTable/SkipTableBase.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3c70c703e84d842b9b488dd0798290d3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/SkipTable/SkipTableDesc.cs

@@ -0,0 +1,188 @@
+
+#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.
+#pragma warning disable CS8604 // Possible null reference argument.
+#pragma warning disable CS8602 // Dereference of a possibly null reference.
+#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+#pragma warning disable CS8601 // Possible null reference assignment.
+namespace NBC.DataStructure.SkipTable
+{
+    /// <summary>
+    /// 跳表降序版，用于存储降序排列的数据。
+    /// </summary>
+    /// <typeparam name="TValue">存储的值的类型。</typeparam>
+    public class SkipTableDesc<TValue> : SkipTableBase<TValue>
+    {
+        /// <summary>
+        /// 初始化跳表降序版的新实例。
+        /// </summary>
+        /// <param name="maxLayer">跳表的最大层数，默认为 8。</param>
+        public SkipTableDesc(int maxLayer = 8) : base(maxLayer) { }
+
+        /// <summary>
+        /// 向跳表中添加一个节点，根据降序规则进行插入。
+        /// </summary>
+        /// <param name="sortKey">排序主键。</param>
+        /// <param name="viceKey">副键。</param>
+        /// <param name="key">键。</param>
+        /// <param name="value">值。</param>
+        public override void Add(long sortKey, long viceKey, long key, TValue value)
+        {
+            var rLevel = 1;
+
+            while (rLevel <= MaxLayer && Random.Next(3) == 0)
+            {
+                ++rLevel;
+            }
+
+            SkipTableNode<TValue> cur = TopHeader, last = null;
+
+            for (var layer = MaxLayer; layer >= 1; --layer)
+            {
+                // 节点有next节点，且 （next主键 > 插入主键） 或 （next主键 == 插入主键 且 next副键 > 插入副键） 
+                while (cur.Right != null && ((cur.Right.SortKey > sortKey) ||
+                                             (cur.Right.SortKey == sortKey && cur.Right.ViceKey > viceKey)))
+                {
+                    cur = cur.Right;
+                }
+
+                if (layer <= rLevel)
+                {
+                    var currentRight = cur.Right;
+                    cur.Right = new SkipTableNode<TValue>(sortKey, viceKey, key, value,
+                        layer == 1 ? cur.Index + 1 : 0, cur, cur.Right, null);
+
+                    if (currentRight != null)
+                    {
+                        currentRight.Left = cur.Right;
+                    }
+
+                    if (last != null)
+                    {
+                        last.Down = cur.Right;
+                    }
+
+                    if (layer == 1)
+                    {
+                        cur.Right.Index = cur.Index + 1;
+                        Node.Add(key, cur.Right);
+
+                        SkipTableNode<TValue> v = cur.Right.Right;
+
+                        while (v != null)
+                        {
+                            v.Index++;
+                            v = v.Right;
+                        }
+                    }
+
+                    last = cur.Right;
+                }
+
+                cur = cur.Down;
+            }
+        }
+
+        /// <summary>
+        /// 从跳表中移除一个节点，根据降序规则进行移除。
+        /// </summary>
+        /// <param name="sortKey">排序主键。</param>
+        /// <param name="viceKey">副键。</param>
+        /// <param name="key">键。</param>
+        /// <param name="value">移除的节点值。</param>
+        /// <returns>如果成功移除节点，则返回 true，否则返回 false。</returns>
+        public override bool Remove(long sortKey, long viceKey, long key, out TValue value)
+        {
+            value = default;
+            var seen = false;
+            var cur = TopHeader;
+
+            for (var layer = MaxLayer; layer >= 1; --layer)
+            {
+                // 先按照主键查找 再 按副键查找
+                while (cur.Right != null && cur.Right.SortKey > sortKey && cur.Right.Key != key) cur = cur.Right;
+                while (cur.Right != null && (cur.Right.SortKey == sortKey && cur.Right.ViceKey >= viceKey) &&
+                       cur.Right.Key != key) cur = cur.Right;
+
+                var isFind = false;
+                var currentCur = cur;
+                SkipTableNode<TValue> removeCur = null;
+                // 如果当前不是要删除的节点、但主键和副键都一样、需要特殊处理下。
+                if (cur.Right != null && cur.Right.Key == key)
+                {
+                    isFind = true;
+                    removeCur = cur.Right;
+                    currentCur = cur;
+                }
+                else
+                {
+                    // 先向左查找下
+                    var currentNode = cur.Left;
+                    while (currentNode != null && currentNode.SortKey == sortKey && currentNode.ViceKey == viceKey)
+                    {
+                        if (currentNode.Key == key)
+                        {
+                            isFind = true;
+                            removeCur = currentNode;
+                            currentCur = currentNode.Left;
+                            break;
+                        }
+
+                        currentNode = currentNode.Left;
+                    }
+
+                    // 再向右查找下
+                    if (!isFind)
+                    {
+                        currentNode = cur.Right;
+                        while (currentNode != null && currentNode.SortKey == sortKey && currentNode.ViceKey == viceKey)
+                        {
+                            if (currentNode.Key == key)
+                            {
+                                isFind = true;
+                                removeCur = currentNode;
+                                currentCur = currentNode.Left;
+                                break;
+                            }
+
+                            currentNode = currentNode.Right;
+                        }
+                    }
+                }
+
+                if (isFind && currentCur != null)
+                {
+                    value = removeCur.Value;
+                    currentCur.Right = removeCur.Right;
+
+                    if (removeCur.Right != null)
+                    {
+                        removeCur.Right.Left = currentCur;
+                        removeCur.Right = null;
+                    }
+
+                    removeCur.Left = null;
+                    removeCur.Down = null;
+                    removeCur.Value = default;
+
+                    if (layer == 1)
+                    {
+                        var tempCur = currentCur.Right;
+                        while (tempCur != null)
+                        {
+                            tempCur.Index--;
+                            tempCur = tempCur.Right;
+                        }
+
+                        Node.Remove(removeCur.Key);
+                    }
+
+                    seen = true;
+                }
+
+                cur = cur.Down;
+            }
+
+            return seen;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/SkipTable/SkipTableDesc.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ae15364981a674c59a2e20d2b99f097b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/DataStructure/SkipTable/SkipTableNode.cs

@@ -0,0 +1,68 @@
+namespace NBC.DataStructure.SkipTable
+{
+    /// <summary>
+    /// 跳跃表节点。
+    /// </summary>
+    /// <typeparam name="TValue">节点的值的类型。</typeparam>
+    public class SkipTableNode<TValue>
+    {
+        /// <summary>
+        /// 节点在跳跃表中的索引。
+        /// </summary>
+        public int Index;
+        /// <summary>
+        /// 节点的主键。
+        /// </summary>
+        public long Key;
+        /// <summary>
+        /// 节点的排序键。
+        /// </summary>
+        public long SortKey;
+        /// <summary>
+        /// 节点的副键。
+        /// </summary>
+        public long ViceKey;
+        /// <summary>
+        /// 节点存储的值。
+        /// </summary>
+        public TValue Value;
+        /// <summary>
+        /// 指向左侧节点的引用。
+        /// </summary>
+        public SkipTableNode<TValue> Left;
+        /// <summary>
+        /// 指向右侧节点的引用。
+        /// </summary>
+        public SkipTableNode<TValue> Right;
+        /// <summary>
+        /// 指向下一层节点的引用。
+        /// </summary>
+        public SkipTableNode<TValue> Down;
+
+        /// <summary>
+        /// 初始化跳跃表节点的新实例。
+        /// </summary>
+        /// <param name="sortKey">节点的排序键。</param>
+        /// <param name="viceKey">节点的副键。</param>
+        /// <param name="key">节点的主键。</param>
+        /// <param name="value">节点存储的值。</param>
+        /// <param name="index">节点在跳跃表中的索引。</param>
+        /// <param name="l">指向左侧节点的引用。</param>
+        /// <param name="r">指向右侧节点的引用。</param>
+        /// <param name="d">指向下一层节点的引用。</param>
+        public SkipTableNode(long sortKey, long viceKey, long key, TValue value, int index,
+            SkipTableNode<TValue> l,
+            SkipTableNode<TValue> r,
+            SkipTableNode<TValue> d)
+        {
+            Left = l;
+            Right = r;
+            Down = d;
+            Value = value;
+            Key = key;
+            Index = index;
+            SortKey = sortKey;
+            ViceKey = viceKey;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/DataStructure/SkipTable/SkipTableNode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9384bd7a2a46f401ea6de3461b5aa36b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 27462e8175ff84272b8b14c7b2ffb00c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e39207f0f9770415093af2f27fd7e988
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/CoroutineLock.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: db6a6392f9f6e4a2fbedb6ba3df377e8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/CoroutineLock/CoroutineLock.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Collections.Generic;
+using NBC.Pool;
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+namespace NBC.Async
+{
+    /// <summary>
+    /// 协程锁专用的对象池
+    /// </summary>
+    public sealed class CoroutineLockPool : PoolCore<CoroutineLock>
+    {
+        /// <summary>
+        /// 协程锁专用的对象池的构造函数
+        /// </summary>
+        public CoroutineLockPool() : base(2000) { }
+    }
+    
+    /// <summary>
+    /// 协程锁
+    /// </summary>
+    public sealed class CoroutineLock : IPool, IDisposable
+    {
+        private Scene _scene;
+        private CoroutineLockComponent _coroutineLockComponent;
+        private readonly Dictionary<long, CoroutineLockQueue> _queue = new Dictionary<long, CoroutineLockQueue>();
+        /// <summary>
+        /// 表示是否是对象池中创建的
+        /// </summary>
+        private bool _isPool;
+        /// <summary>
+        /// 协程锁的类型
+        /// </summary>
+        public long CoroutineLockType { get; private set; }
+
+        internal void Initialize(CoroutineLockComponent coroutineLockComponent, ref long coroutineLockType)
+        {
+            _scene = coroutineLockComponent.Scene;
+            CoroutineLockType = coroutineLockType;
+            _coroutineLockComponent = coroutineLockComponent;
+        }
+        /// <summary>
+        /// 销毁协程锁，如果调用了该方法，所有使用当前协程锁等待的逻辑会按照顺序释放锁。
+        /// </summary>
+        public void Dispose()
+        {
+            foreach (var (_, coroutineLockQueue) in _queue)
+            {
+                while (TryCoroutineLockQueueDequeue(coroutineLockQueue)) { }
+            }
+            
+            _queue.Clear();
+            _scene = null;
+            CoroutineLockType = 0;
+            _coroutineLockComponent = null;
+        }
+        /// <summary>
+        /// 等待上一个任务完成
+        /// </summary>
+        /// <param name="coroutineLockQueueKey">需要等待的Id</param>
+        /// <param name="tag">用于查询协程锁的标记，可不传入，只有在超时的时候排查是哪个锁超时时使用</param>
+        /// <param name="timeOut">等待多久会超时，当到达设定的时候会把当前锁给按照超时处理</param>
+        /// <returns></returns>
+        public async FTask<WaitCoroutineLock> Wait(long coroutineLockQueueKey, string tag = null, int timeOut = 30000)
+        {
+            var waitCoroutineLock = _coroutineLockComponent.WaitCoroutineLockPool.Rent(this, ref coroutineLockQueueKey, tag, timeOut);
+            
+            if (!_queue.TryGetValue(coroutineLockQueueKey, out var queue))
+            {
+                queue = _coroutineLockComponent.CoroutineLockQueuePool.Rent();
+                _queue.Add(coroutineLockQueueKey, queue);
+                return waitCoroutineLock;
+            }
+            
+            queue.Enqueue(waitCoroutineLock);
+            return await waitCoroutineLock.Tcs;
+        }
+        /// <summary>
+        /// 按照先入先出的顺序，释放最早的一个协程锁
+        /// </summary>
+        /// <param name="coroutineLockQueueKey"></param>
+        public void Release(long coroutineLockQueueKey)
+        {
+            if (!_queue.TryGetValue(coroutineLockQueueKey, out var coroutineLockQueue))
+            {
+                return;
+            }
+            
+            if (!TryCoroutineLockQueueDequeue(coroutineLockQueue))
+            {
+                _queue.Remove(coroutineLockQueueKey);
+            }
+        }
+
+        private bool TryCoroutineLockQueueDequeue(CoroutineLockQueue coroutineLockQueue)
+        {
+            if (!coroutineLockQueue.TryDequeue(out var waitCoroutineLock))
+            {
+                _coroutineLockComponent.CoroutineLockQueuePool.Return(coroutineLockQueue);
+                return false;
+            }
+            
+            if (waitCoroutineLock.TimerId != 0)
+            {
+                _scene.TimerComponent.Net.Remove(waitCoroutineLock.TimerId);
+            }
+
+            try
+            {
+                // 放到下一帧执行,如果不这样会导致逻辑的顺序不正常。
+                _scene.ThreadSynchronizationContext.Post(waitCoroutineLock.SetResult);
+            }
+            catch (Exception e)
+            {
+                Log.Error($"Error in disposing CoroutineLock: {e}");
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/CoroutineLock/CoroutineLock.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e2fe8fb8f49ad4565b47c840fb690d1f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/CoroutineLock/CoroutineLockComponent.cs

@@ -0,0 +1,100 @@
+using System.Collections.Generic;
+using NBC.Entitas;
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+
+namespace NBC.Async
+{
+    /// <summary>
+    /// 协程锁组件
+    /// </summary>
+    public class CoroutineLockComponent : Entity
+    {
+        private long _lockId;
+        private CoroutineLockPool _coroutineLockPool;
+        internal WaitCoroutineLockPool WaitCoroutineLockPool { get; private set; }
+        internal CoroutineLockQueuePool CoroutineLockQueuePool { get; private set; }
+        private readonly Dictionary<long, CoroutineLock> _coroutineLocks = new Dictionary<long, CoroutineLock>();
+        internal CoroutineLockComponent Initialize()
+        {
+            _coroutineLockPool = new CoroutineLockPool();
+            CoroutineLockQueuePool = new CoroutineLockQueuePool();
+            WaitCoroutineLockPool = new WaitCoroutineLockPool(this);
+            return this;
+        }
+        
+        internal long LockId => ++_lockId;
+        
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+        public override void Dispose()
+#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
+        {
+            if (IsDisposed)
+            {
+                return;
+            }
+
+            _lockId = 0;
+            base.Dispose();
+        }
+
+        /// <summary>
+        /// 创建一个新的协程锁
+        /// 使用这个方法创建的协程锁，需要手动释放管理CoroutineLock。
+        /// 不会再CoroutineLockComponent理进行管理。
+        /// </summary>
+        /// <param name="coroutineLockType"></param>
+        /// <returns></returns>
+        public CoroutineLock Create(long coroutineLockType)
+        {
+            var coroutineLock = _coroutineLockPool.Rent();
+            coroutineLock.Initialize(this, ref coroutineLockType);
+            return coroutineLock;
+        }
+
+        /// <summary>
+        /// 请求一个协程锁。
+        /// 使用这个方法创建的协程锁，会自动释放CoroutineLockQueueType。
+        /// </summary>
+        /// <param name="coroutineLockType">锁类型</param>
+        /// <param name="coroutineLockQueueKey">锁队列Id</param>
+        /// <param name="tag">当某些锁超时，需要一个标记来方便排查问题，正常的情况下这个默认为null就可以。</param>
+        /// <param name="time">设置锁的超时时间，让超过设置的时间会触发超时，保证锁不会因为某一个锁一直不解锁导致卡住的问题。</param>
+        /// <returns>
+        /// 返回的WaitCoroutineLock通过Dispose来解除这个锁、建议用using来保住这个锁。
+        /// 也可以返回的WaitCoroutineLock通过CoroutineLockComponent.UnLock来解除这个锁。
+        /// </returns>
+        public FTask<WaitCoroutineLock> Wait(long coroutineLockType, long coroutineLockQueueKey, string tag = null, int time = 30000)
+        {
+            if (!_coroutineLocks.TryGetValue(coroutineLockType, out var coroutineLock))
+            {
+                coroutineLock = _coroutineLockPool.Rent();
+                coroutineLock.Initialize(this, ref coroutineLockType);
+                _coroutineLocks.Add(coroutineLockType, coroutineLock);
+            }
+
+            return coroutineLock.Wait(coroutineLockQueueKey, tag, time);
+        }
+
+        /// <summary>
+        /// 解除一个协程锁。
+        /// </summary>
+        /// <param name="coroutineLockType"></param>
+        /// <param name="coroutineLockQueueKey"></param>
+        public void Release(int coroutineLockType, long coroutineLockQueueKey)
+        {
+            if (IsDisposed)
+            {
+                return;
+            }
+            
+            if (!_coroutineLocks.TryGetValue(coroutineLockType, out var coroutineLock))
+            {
+                return;
+            }
+                
+            coroutineLock.Release(coroutineLockQueueKey);
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/CoroutineLock/CoroutineLockComponent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8abfde11ad4d344eda0bf16b249a0dae
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/CoroutineLock/CoroutineLockQueue.cs

@@ -0,0 +1,35 @@
+// ReSharper disable ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
+using System.Collections.Generic;
+using NBC.Pool;
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+namespace NBC.Async
+{
+    internal sealed class CoroutineLockQueuePool : PoolCore<CoroutineLockQueue>
+    {
+        public CoroutineLockQueuePool() : base(2000) { }
+    }
+    
+    internal sealed class CoroutineLockQueue : Queue<WaitCoroutineLock>, IPool
+    {
+        private bool _isPool;
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/CoroutineLock/CoroutineLockQueue.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c1a15c49a7b7b488c8aac3d7720d506e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/CoroutineLock/WaitCoroutineLock.cs

@@ -0,0 +1,146 @@
+using System;
+using NBC.Event;
+using NBC.Pool;
+
+#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+namespace NBC.Async
+{
+    internal sealed class WaitCoroutineLockPool : PoolCore<WaitCoroutineLock>
+    {
+        private readonly Scene _scene;
+        private readonly CoroutineLockComponent _coroutineLockComponent;
+
+        public WaitCoroutineLockPool(CoroutineLockComponent coroutineLockComponent) : base(2000)
+        {
+            _scene = coroutineLockComponent.Scene;
+            _coroutineLockComponent = coroutineLockComponent;
+        }
+
+        public WaitCoroutineLock Rent(CoroutineLock coroutineLock, ref long coroutineLockQueueKey, string tag = null, int timeOut = 30000)
+        {
+            var timerId = 0L;
+            var lockId = _coroutineLockComponent.LockId;
+            var waitCoroutineLock = _coroutineLockComponent.WaitCoroutineLockPool.Rent();
+
+            if (timeOut > 0)
+            {
+                timerId = _scene.TimerComponent.Net.OnceTimer(timeOut, new CoroutineLockTimeout(ref lockId, waitCoroutineLock));
+            }
+
+            waitCoroutineLock.Initialize(coroutineLock, this, ref coroutineLockQueueKey, ref timerId, ref lockId, tag);
+            return waitCoroutineLock;
+        }
+    }
+
+    internal struct CoroutineLockTimeout
+    {
+        public readonly long LockId;
+        public readonly WaitCoroutineLock WaitCoroutineLock;
+
+        public CoroutineLockTimeout(ref long lockId, WaitCoroutineLock waitCoroutineLock)
+        {
+            LockId = lockId;
+            WaitCoroutineLock = waitCoroutineLock;
+        }
+    }
+
+    internal sealed class OnCoroutineLockTimeout : EventSystem<CoroutineLockTimeout>
+    {
+        protected override void Handler(CoroutineLockTimeout self)
+        {
+            var selfWaitCoroutineLock = self.WaitCoroutineLock;
+            
+            if (self.LockId != selfWaitCoroutineLock.LockId)
+            {
+                return;
+            }
+            
+            Log.Error($"coroutine lock timeout CoroutineLockQueueType:{selfWaitCoroutineLock.CoroutineLock.CoroutineLockType} Key:{selfWaitCoroutineLock.CoroutineLockQueueKey} Tag:{selfWaitCoroutineLock.Tag}");
+        }
+    }
+
+    /// <summary>
+    /// 一个协程锁的实例，用户可以用过这个手动释放锁
+    /// </summary>
+    public sealed class WaitCoroutineLock : IPool, IDisposable
+    {
+        private bool _isPool;
+        internal string Tag { get; private set; }
+        internal long LockId { get; private set; }
+        internal long TimerId { get; private set; }
+        internal long CoroutineLockQueueKey { get; private set; }
+        internal CoroutineLock CoroutineLock { get; private set; }
+
+        private bool _isSetResult;
+        private FTask<WaitCoroutineLock> _tcs;
+        private WaitCoroutineLockPool _waitCoroutineLockPool;
+        internal void Initialize(CoroutineLock coroutineLock, WaitCoroutineLockPool waitCoroutineLockPool, ref long coroutineLockQueueKey, ref long timerId, ref long lockId, string tag)
+        {
+            Tag = tag;
+            LockId = lockId;
+            TimerId = timerId;
+            CoroutineLock = coroutineLock;
+            CoroutineLockQueueKey = coroutineLockQueueKey;
+            _waitCoroutineLockPool = waitCoroutineLockPool;
+        }
+        /// <summary>
+        /// 释放协程锁
+        /// </summary>
+        public void Dispose()
+        {
+            if (LockId == 0)
+            {
+                Log.Error("WaitCoroutineLock is already disposed");
+                return;
+            }
+            
+            CoroutineLock.Release(CoroutineLockQueueKey);
+            
+            _tcs = null;
+            Tag = null;
+            LockId = 0;
+            TimerId = 0;
+            _isSetResult = false;
+            CoroutineLockQueueKey = 0;
+            _waitCoroutineLockPool.Return(this);
+            CoroutineLock = null;
+            _waitCoroutineLockPool = null;
+        }
+        
+        internal FTask<WaitCoroutineLock> Tcs
+        {
+            get { return _tcs ??= FTask<WaitCoroutineLock>.Create(); }
+        }
+
+        internal void SetResult()
+        {
+            if (_isSetResult)
+            {
+                Log.Error("WaitCoroutineLock is already SetResult");
+                return;
+            }
+            
+            _isSetResult = true;
+            Tcs.SetResult(this);
+        }
+
+        /// <summary>
+        /// 获取一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <returns></returns>
+        public bool IsPool()
+        {
+            return _isPool;
+        }
+
+        /// <summary>
+        /// 设置一个值，该值指示当前实例是否为对象池中的实例。
+        /// </summary>
+        /// <param name="isPool"></param>
+        public void SetIsPool(bool isPool)
+        {
+            _isPool = isPool;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/CoroutineLock/WaitCoroutineLock.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c6d5307f677ba48f891c12ac183a0128
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/EntityComponent.cs

@@ -0,0 +1,472 @@
+// ReSharper disable ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using NBC.Entitas;
+using NBC.Assembly;
+using NBC.Async;
+using NBC.DataStructure.Collection;
+using NBC.Entitas.Interface;
+using NBC.Helper;
+
+#pragma warning disable CS8602 // Dereference of a possibly null reference.
+#pragma warning disable CS8765 // Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes).
+
+#pragma warning disable CS8604 // Possible null reference argument.
+#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+namespace NBC.Entitas
+{
+    internal sealed class UpdateQueueInfo
+    {
+        public bool IsStop;
+        public readonly Type Type;
+        public readonly long RunTimeId;
+
+        public UpdateQueueInfo(Type type, long runTimeId)
+        {
+            Type = type;
+            IsStop = false;
+            RunTimeId = runTimeId;
+        }
+    }
+    
+    internal sealed class FrameUpdateQueueInfo
+    {
+        public readonly Type Type;
+        public readonly long RunTimeId;
+
+        public FrameUpdateQueueInfo(Type type, long runTimeId)
+        {
+            Type = type;
+            RunTimeId = runTimeId;
+        }
+    }
+
+    internal struct CustomEntitiesSystemKey : IEquatable<CustomEntitiesSystemKey>
+    {
+        public int CustomEventType { get; }
+        public Type EntitiesType { get; }
+        public CustomEntitiesSystemKey(int customEventType, Type entitiesType)
+        {
+            CustomEventType = customEventType;
+            EntitiesType = entitiesType;
+        }
+        public bool Equals(CustomEntitiesSystemKey other)
+        {
+            return CustomEventType == other.CustomEventType && EntitiesType == other.EntitiesType;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is CustomEntitiesSystemKey other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(CustomEventType, EntitiesType);
+        }
+    }
+    
+    /// <summary>
+    /// Entity管理组件
+    /// </summary>
+    public sealed class EntityComponent : Entity, ISceneUpdate, IAssembly
+    {
+        private readonly OneToManyList<long, Type> _assemblyList = new();
+        private readonly OneToManyList<long, Type> _assemblyHashCodes = new();
+        
+        private readonly Dictionary<Type, IAwakeSystem> _awakeSystems = new();
+        private readonly Dictionary<Type, IUpdateSystem> _updateSystems = new();
+        private readonly Dictionary<Type, IDestroySystem> _destroySystems = new();
+        private readonly Dictionary<Type, IDeserializeSystem> _deserializeSystems = new();
+        private readonly Dictionary<Type, IFrameUpdateSystem> _frameUpdateSystem = new();
+        
+        private readonly OneToManyList<long, CustomEntitiesSystemKey> _assemblyCustomSystemList = new();
+        private readonly Dictionary<CustomEntitiesSystemKey, ICustomEntitiesSystem> _customEntitiesSystems = new Dictionary<CustomEntitiesSystemKey, ICustomEntitiesSystem>();
+        
+        private readonly Dictionary<Type, long> _hashCodes = new Dictionary<Type, long>();
+        private readonly Queue<UpdateQueueInfo> _updateQueue = new Queue<UpdateQueueInfo>();
+        private readonly Queue<FrameUpdateQueueInfo> _frameUpdateQueue = new Queue<FrameUpdateQueueInfo>();
+        private readonly Dictionary<long, UpdateQueueInfo> _updateQueueDic = new Dictionary<long, UpdateQueueInfo>();
+
+        internal async FTask<EntityComponent> Initialize()
+        {
+            await AssemblySystem.Register(this);
+            return this;
+        }
+
+        #region Assembly
+
+        public FTask Load(long assemblyIdentity)
+        {
+            var task = FTask.Create(false);
+            Scene?.ThreadSynchronizationContext.Post(() =>
+            {
+                LoadInner(assemblyIdentity);
+                task.SetResult();
+            });
+            return task;
+        }
+
+        public FTask ReLoad(long assemblyIdentity)
+        {
+            var task = FTask.Create(false);
+            Scene?.ThreadSynchronizationContext.Post(() =>
+            {
+                OnUnLoadInner(assemblyIdentity);
+                LoadInner(assemblyIdentity);
+                task.SetResult();
+            });
+            
+            return task;
+        }
+
+        public FTask OnUnLoad(long assemblyIdentity)
+        {
+            var task = FTask.Create(false);
+            Scene?.ThreadSynchronizationContext.Post(() =>
+            {
+                OnUnLoadInner(assemblyIdentity);
+                task.SetResult();
+            });
+            return task;
+        }
+
+        private void LoadInner(long assemblyIdentity)
+        {
+            foreach (var entityType in AssemblySystem.ForEach(assemblyIdentity, typeof(IEntity)))
+            {
+                _hashCodes.Add(entityType, HashCodeHelper.ComputeHash64(entityType.FullName));
+                _assemblyHashCodes.Add(assemblyIdentity, entityType);
+            }
+            
+            foreach (var entitiesSystemType in AssemblySystem.ForEach(assemblyIdentity, typeof(IEntitiesSystem)))
+            {
+                Type entitiesType = null;
+                var entity = Activator.CreateInstance(entitiesSystemType);
+
+                switch (entity)
+                {
+                    case IAwakeSystem iAwakeSystem:
+                    {
+                        entitiesType = iAwakeSystem.EntitiesType();
+                        _awakeSystems.Add(entitiesType, iAwakeSystem);
+                        break;
+                    }
+                    case IDestroySystem iDestroySystem:
+                    {
+                        entitiesType = iDestroySystem.EntitiesType();
+                        _destroySystems.Add(entitiesType, iDestroySystem);
+                        break;
+                    }
+                    case IDeserializeSystem iDeserializeSystem:
+                    {
+                        entitiesType = iDeserializeSystem.EntitiesType();
+                        _deserializeSystems.Add(entitiesType, iDeserializeSystem);
+                        break;
+                    }
+                    case IUpdateSystem iUpdateSystem:
+                    {
+                        entitiesType = iUpdateSystem.EntitiesType();
+                        _updateSystems.Add(entitiesType, iUpdateSystem);
+                        break;
+                    }
+                    case IFrameUpdateSystem iFrameUpdateSystem:
+                    {
+                        entitiesType = iFrameUpdateSystem.EntitiesType();
+                        _frameUpdateSystem.Add(entitiesType, iFrameUpdateSystem);
+                        break;
+                    }
+                    default:
+                    {
+                        Log.Error($"IEntitiesSystem not support type {entitiesSystemType}");
+                        return;
+                    }
+                }
+
+                _assemblyList.Add(assemblyIdentity, entitiesType);
+            }
+            
+            foreach (var customEntitiesSystemType in AssemblySystem.ForEach(assemblyIdentity, typeof(ICustomEntitiesSystem)))
+            {
+                var entity = (ICustomEntitiesSystem)Activator.CreateInstance(customEntitiesSystemType);
+                var customEntitiesSystemKey = new CustomEntitiesSystemKey(entity.CustomEventType, entity.EntitiesType());
+                _customEntitiesSystems.Add(customEntitiesSystemKey, entity);
+                _assemblyCustomSystemList.Add(assemblyIdentity, customEntitiesSystemKey);
+            }
+        }
+
+        private void OnUnLoadInner(long assemblyIdentity)
+        {
+            if (_assemblyHashCodes.TryGetValue(assemblyIdentity, out var entityType))
+            {
+                foreach (var type in entityType)
+                {
+                    _hashCodes.Remove(type);
+                }
+
+                _assemblyHashCodes.RemoveByKey(assemblyIdentity);
+            }
+
+            if (_assemblyList.TryGetValue(assemblyIdentity, out var assembly))
+            {
+                foreach (var type in assembly)
+                {
+                    _awakeSystems.Remove(type);
+                    _updateSystems.Remove(type);
+                    _destroySystems.Remove(type);
+                    _deserializeSystems.Remove(type);
+                    _frameUpdateSystem.Remove(type);
+                }
+                
+                _assemblyList.RemoveByKey(assemblyIdentity);
+            }
+
+            if (_assemblyCustomSystemList.TryGetValue(assemblyIdentity, out var customSystemAssembly))
+            {
+                foreach (var customEntitiesSystemKey in customSystemAssembly)
+                {
+                    _customEntitiesSystems.Remove(customEntitiesSystemKey);
+                }
+
+                _assemblyCustomSystemList.RemoveByKey(assemblyIdentity);
+            }
+        }
+
+        #endregion
+
+        #region Event
+
+        /// <summary>
+        /// 触发实体的唤醒方法
+        /// </summary>
+        /// <param name="entity">实体对象</param>
+        public void Awake(Entity entity)
+        {
+            if (!_awakeSystems.TryGetValue(entity.Type, out var awakeSystem))
+            {
+                return;
+            }
+
+            try
+            {
+                awakeSystem.Invoke(entity);
+            }
+            catch (Exception e)
+            {
+                Log.Error($"{entity.Type.FullName} Error {e}");
+            }
+        }
+        
+        /// <summary>
+        /// 触发实体的销毁方法
+        /// </summary>
+        /// <param name="entity">实体对象</param>
+        public void Destroy(Entity entity)
+        {
+            if (!_destroySystems.TryGetValue(entity.Type, out var system))
+            {
+                return;
+            }
+
+            try
+            {
+                system.Invoke(entity);
+            }
+            catch (Exception e)
+            {
+                Log.Error($"{entity.Type.FullName} Destroy Error {e}");
+            }
+        }
+        
+        /// <summary>
+        /// 触发实体的反序列化方法
+        /// </summary>
+        /// <param name="entity">实体对象</param>
+        public void Deserialize(Entity entity) 
+        {
+            if (!_deserializeSystems.TryGetValue(entity.Type, out var system))
+            {
+                return;
+            }
+
+            try
+            {
+                system.Invoke(entity);
+            }
+            catch (Exception e)
+            {
+                Log.Error($"{entity.Type.FullName} Deserialize Error {e}");
+            }
+        }
+
+        #endregion
+
+        #region CustomEvent
+
+        public void CustomSystem(Entity entity, int customEventType)
+        {
+            var customEntitiesSystemKey = new CustomEntitiesSystemKey(customEventType, entity.Type);
+            
+            if (!_customEntitiesSystems.TryGetValue(customEntitiesSystemKey, out var system))
+            {
+                return;
+            }
+
+            try
+            {
+                system.Invoke(entity);
+            }
+            catch (Exception e)
+            {
+                Log.Error($"{entity.Type.FullName} CustomSystem Error {e}");
+            }
+        }
+
+        #endregion
+
+        #region Update
+
+        /// <summary>
+        /// 将实体加入更新队列，准备进行更新
+        /// </summary>
+        /// <param name="entity">实体对象</param>
+        public void StartUpdate(Entity entity)
+        {
+            var type = entity.Type;
+            var entityRuntimeId = entity.RuntimeId;
+
+            if (_updateSystems.ContainsKey(type))
+            {
+                var updateQueueInfo = new UpdateQueueInfo(type, entityRuntimeId);
+                _updateQueue.Enqueue(updateQueueInfo);
+                _updateQueueDic.Add(entityRuntimeId, updateQueueInfo);
+            }
+
+            if (_frameUpdateSystem.ContainsKey(type))
+            {
+                _frameUpdateQueue.Enqueue(new FrameUpdateQueueInfo(type, entityRuntimeId));
+            }
+        }
+
+        /// <summary>
+        /// 停止实体进行更新
+        /// </summary>
+        /// <param name="entity">实体对象</param>
+        public void StopUpdate(Entity entity)
+        {
+            if (!_updateQueueDic.Remove(entity.RuntimeId, out var updateQueueInfo))
+            {
+                return;
+            }
+
+            updateQueueInfo.IsStop = true;
+        }
+
+        /// <summary>
+        /// 执行实体系统的更新逻辑
+        /// </summary>
+        public void Update()
+        {
+            var updateQueueCount = _updateQueue.Count;
+
+            while (updateQueueCount-- > 0)
+            {
+                var updateQueueStruct = _updateQueue.Dequeue();
+
+                if (updateQueueStruct.IsStop)
+                {
+                    continue;
+                }
+                
+                if (!_updateSystems.TryGetValue(updateQueueStruct.Type, out var updateSystem))
+                {
+                    continue;
+                }
+                
+                var entity = Scene.GetEntity(updateQueueStruct.RunTimeId);
+                
+                if (entity == null || entity.IsDisposed)
+                {
+                    _updateQueueDic.Remove(updateQueueStruct.RunTimeId);
+                    continue;
+                }
+                
+                _updateQueue.Enqueue(updateQueueStruct);
+                
+                try
+                {
+                    updateSystem.Invoke(entity);
+                }
+                catch (Exception e)
+                {
+                    Log.Error($"{updateQueueStruct.Type.FullName} Update Error {e}");
+                }
+            }
+        }
+
+        /// <summary>
+        /// 执行实体系统的帧更新逻辑
+        /// </summary>
+        public void FrameUpdate()
+        {
+            var count = _frameUpdateQueue.Count;
+
+            while (count-- > 0)
+            {
+                var frameUpdateQueueStruct = _frameUpdateQueue.Dequeue();
+                
+                if (!_frameUpdateSystem.TryGetValue(frameUpdateQueueStruct.Type, out var frameUpdateSystem))
+                {
+                    continue;
+                }
+                
+                var entity = Scene.GetEntity(frameUpdateQueueStruct.RunTimeId);
+
+                if (entity == null || entity.IsDisposed)
+                {
+                    continue;
+                }
+
+                _frameUpdateQueue.Enqueue(frameUpdateQueueStruct);
+
+                try
+                {
+                    frameUpdateSystem.Invoke(entity);
+                }
+                catch (Exception e)
+                {
+                    Log.Error($"{frameUpdateQueueStruct.Type.FullName} FrameUpdate Error {e}");
+                }
+            }
+        }
+
+        #endregion
+
+        public long GetHashCode(Type type)
+        {
+            return _hashCodes[type];
+        }
+
+        /// <summary>
+        /// 释放实体系统管理器资源
+        /// </summary>
+        public override void Dispose()
+        {
+            _updateQueue.Clear();
+            _frameUpdateQueue.Clear();
+
+            _assemblyList.Clear();
+            _awakeSystems.Clear();
+            _updateSystems.Clear();
+            _destroySystems.Clear();
+            _deserializeSystems.Clear();
+            _frameUpdateSystem.Clear();
+
+            AssemblySystem.UnRegister(this);
+            base.Dispose();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/EntityComponent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 41c0ffdbeaaf84d848105eb341414c4a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/EventComponent.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5ff190d313de0433bb5c6cad4f116d1a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/EventComponent/EventComponent.cs

@@ -0,0 +1,255 @@
+using System;
+using System.Reflection;
+using NBC.Assembly;
+using NBC.Async;
+using NBC.DataStructure.Collection;
+using NBC.Entitas;
+
+// ReSharper disable PossibleMultipleEnumeration
+#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+// ReSharper disable MethodOverloadWithOptionalParameter
+
+namespace NBC.Event
+{
+    internal sealed class EventCache
+    {
+        public readonly Type EnventType;
+        public readonly object Obj;
+        public EventCache(Type enventType, object obj)
+        {
+            EnventType = enventType;
+            Obj = obj;
+        }
+    }
+
+    public sealed class EventComponent : Entity, IAssembly
+    {
+        private readonly OneToManyList<Type, IEvent> _events = new();
+        private readonly OneToManyList<Type, IAsyncEvent> _asyncEvents = new();
+        private readonly OneToManyList<long, EventCache> _assemblyEvents = new();
+        private readonly OneToManyList<long, EventCache> _assemblyAsyncEvents = new();
+
+        internal async FTask<EventComponent> Initialize()
+        {
+            await AssemblySystem.Register(this);
+            return this;
+        }
+
+        #region Assembly
+
+        public async FTask Load(long assemblyIdentity)
+        {
+            var tcs = FTask.Create(false);
+            Scene?.ThreadSynchronizationContext.Post(() =>
+            {
+                LoadInner(assemblyIdentity);
+                tcs.SetResult();
+            });
+            await tcs;
+        }
+
+        public async FTask ReLoad(long assemblyIdentity)
+        {
+            var tcs = FTask.Create(false);
+            Scene?.ThreadSynchronizationContext.Post(() =>
+            {
+                OnUnLoadInner(assemblyIdentity);
+                LoadInner(assemblyIdentity);
+                tcs.SetResult();
+            });
+            await tcs;
+        }
+
+        public async FTask OnUnLoad(long assemblyIdentity)
+        {
+            var tcs = FTask.Create(false);
+            Scene?.ThreadSynchronizationContext.Post(() =>
+            {
+                OnUnLoadInner(assemblyIdentity);
+                tcs.SetResult();
+            });
+            await tcs;
+        }
+
+        private void LoadInner(long assemblyIdentity)
+        {
+            
+            foreach (var type in AssemblySystem.ForEach(assemblyIdentity, typeof(IEvent)))
+            {
+                var @event = (IEvent)Activator.CreateInstance(type);
+
+                if (@event == null)
+                {
+                    continue;
+                }
+                
+                var eventType = @event.EventType();
+                _events.Add(eventType, @event);
+                _assemblyEvents.Add(assemblyIdentity, new EventCache(eventType, @event));
+            }
+            _events.SortAll();
+
+            foreach (var type in AssemblySystem.ForEach(assemblyIdentity, typeof(IAsyncEvent)))
+            {
+                var @event = (IAsyncEvent)Activator.CreateInstance(type);
+
+                if (@event == null)
+                {
+                    continue;
+                }
+                
+                var eventType = @event.EventType();
+                _asyncEvents.Add(eventType, @event);
+                _assemblyAsyncEvents.Add(assemblyIdentity, new EventCache(eventType, @event));
+            }
+            _asyncEvents.SortAll();
+        }
+
+        private void OnUnLoadInner(long assemblyIdentity)
+        {
+            if (_assemblyEvents.TryGetValue(assemblyIdentity, out var events))
+            {
+                foreach (var @event in events)
+                {
+                    _events.RemoveValue(@event.EnventType, (IEvent)@event.Obj);
+                }
+
+                _assemblyEvents.RemoveByKey(assemblyIdentity);
+            }
+
+            if (_assemblyAsyncEvents.TryGetValue(assemblyIdentity, out var asyncEvents))
+            {
+                foreach (var @event in asyncEvents)
+                {
+                    _asyncEvents.RemoveValue(@event.EnventType, (IAsyncEvent)@event.Obj);
+                }
+
+                _assemblyAsyncEvents.RemoveByKey(assemblyIdentity);
+            }
+        }
+
+        #endregion
+
+        #region Publish
+
+        /// <summary>
+        /// 发布一个值类型的事件数据。
+        /// </summary>
+        /// <typeparam name="TEventData">事件数据类型（值类型）。</typeparam>
+        /// <param name="eventData">事件数据实例。</param>
+        public void Publish<TEventData>(TEventData eventData) where TEventData : struct
+        {
+            if (!_events.TryGetValue(typeof(TEventData), out var list))
+            {
+                return;
+            }
+
+            foreach (var @event in list)
+            {
+                try
+                {
+                    @event.Invoke(eventData);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+        }
+
+        /// <summary>
+        /// 发布一个继承自 Entity 的事件数据。
+        /// </summary>
+        /// <typeparam name="TEventData">事件数据类型（继承自 Entity）。</typeparam>
+        /// <param name="eventData">事件数据实例。</param>
+        /// <param name="isDisposed">是否释放事件数据。</param>
+        public void Publish<TEventData>(TEventData eventData, bool isDisposed = true) where TEventData : Entity
+        {
+            if (!_events.TryGetValue(typeof(TEventData), out var list))
+            {
+                return;
+            }
+
+            foreach (var @event in list)
+            {
+                try
+                {
+                    @event.Invoke(eventData);
+                }
+                catch (Exception e)
+                {
+                    Log.Error(e);
+                }
+            }
+
+            if (isDisposed)
+            {
+                eventData.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// 异步发布一个值类型的事件数据。
+        /// </summary>
+        /// <typeparam name="TEventData">事件数据类型（值类型）。</typeparam>
+        /// <param name="eventData">事件数据实例。</param>
+        /// <returns>表示异步操作的任务。</returns>
+        public async FTask PublishAsync<TEventData>(TEventData eventData) where TEventData : struct
+        {
+            if (!_asyncEvents.TryGetValue(typeof(TEventData), out var list))
+            {
+                return;
+            }
+
+            using var tasks = ListPool<FTask>.Create();
+
+            foreach (var @event in list)
+            {
+                tasks.Add(@event.InvokeAsync(eventData));
+            }
+
+            await FTask.WaitAll(tasks);
+        }
+
+        /// <summary>
+        /// 异步发布一个继承自 Entity 的事件数据。
+        /// </summary>
+        /// <typeparam name="TEventData">事件数据类型（继承自 Entity）。</typeparam>
+        /// <param name="eventData">事件数据实例。</param>
+        /// <param name="isDisposed">是否释放事件数据。</param>
+        /// <returns>表示异步操作的任务。</returns>
+        public async FTask PublishAsync<TEventData>(TEventData eventData, bool isDisposed = true) where TEventData : Entity
+        {
+            if (!_asyncEvents.TryGetValue(eventData.GetType(), out var list))
+            {
+                return;
+            }
+
+            using var tasks = ListPool<FTask>.Create();
+
+            foreach (var @event in list)
+            {
+                tasks.Add(@event.InvokeAsync(eventData));
+            }
+
+            await FTask.WaitAll(tasks);
+
+            if (isDisposed)
+            {
+                eventData.Dispose();
+            }
+        }
+        
+        #endregion
+
+        public override void Dispose()
+        {
+            _events.Clear();
+            _asyncEvents.Clear();
+            _assemblyEvents.Clear();
+            _assemblyAsyncEvents.Clear();
+            base.Dispose();
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/EventComponent/EventComponent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bc6c3f6b01eb14a35934175e36eeb544
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/EventComponent/Interface.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 10dcbb383d66a4915b44d6f20331a7bf
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/EventComponent/Interface/IEvent.cs

@@ -0,0 +1,112 @@
+using System;
+using NBC.Async;
+
+namespace NBC.Event
+{
+    /// <summary>
+    /// 事件的接口
+    /// </summary>
+    public interface IEvent
+    {
+        /// <summary>
+        /// 用于指定事件的Type
+        /// </summary>
+        /// <returns></returns>
+        Type EventType();
+        /// <summary>
+        /// 时间内部使用的入口
+        /// </summary>
+        /// <param name="self"></param>
+        void Invoke(object self);
+    }
+    
+    /// <summary>
+    /// 异步事件的接口
+    /// </summary>
+    public interface IAsyncEvent
+    {
+        /// <summary>
+        /// <see cref="IEvent.EventType"/>
+        /// </summary>
+        /// <returns></returns>
+        Type EventType();
+        /// <summary>
+        /// <see cref="IEvent.Invoke"/>
+        /// </summary>
+        /// <returns></returns>
+        FTask InvokeAsync(object self);
+    }
+    
+    /// <summary>
+    /// 事件的抽象类，要使用事件必须要继承这个抽象接口。
+    /// </summary>
+    /// <typeparam name="T">要监听的事件泛型类型</typeparam>
+    public abstract class EventSystem<T> : IEvent
+    {
+        private readonly Type _selfType = typeof(T);
+        /// <summary>
+        /// <see cref="IEvent.EventType"/>
+        /// </summary>
+        /// <returns></returns>
+        public Type EventType()
+        {
+            return _selfType;
+        }
+        /// <summary>
+        /// 事件调用的方法，要在这个方法里编写事件发生的逻辑
+        /// </summary>
+        /// <param name="self"></param>
+        protected abstract void Handler(T self);
+        /// <summary>
+        /// <see cref="IEvent.Invoke"/>
+        /// </summary>
+        /// <returns></returns>
+        public void Invoke(object self)
+        {
+            try
+            {
+                Handler((T) self);
+            }
+            catch (Exception e)
+            {
+                Log.Error($"{_selfType.Name} Error {e}");
+            }
+        }
+    }
+    /// <summary>
+    /// 异步事件的抽象类，要使用事件必须要继承这个抽象接口。
+    /// </summary>
+    /// <typeparam name="T">要监听的事件泛型类型</typeparam>
+    public abstract class AsyncEventSystem<T> : IAsyncEvent
+    {
+        private readonly Type _selfType = typeof(T);
+        /// <summary>
+        /// <see cref="IEvent.EventType"/>
+        /// </summary>
+        /// <returns></returns>
+        public Type EventType()
+        {
+            return _selfType;
+        }
+        /// <summary>
+        /// 事件调用的方法，要在这个方法里编写事件发生的逻辑
+        /// </summary>
+        /// <param name="self"></param>
+        protected abstract FTask Handler(T self);
+        /// <summary>
+        /// <see cref="IEvent.Invoke"/>
+        /// </summary>
+        /// <returns></returns>
+        public async FTask InvokeAsync(object self)
+        {
+            try
+            {
+                await Handler((T) self);
+            }
+            catch (Exception e)
+            {
+                Log.Error($"{_selfType.Name} Error {e}");
+            }
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/EventComponent/Interface/IEvent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1e46ad748051f4277a8f660fa842b19d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/MessagePoolComponent.cs

@@ -0,0 +1,139 @@
+// ReSharper disable ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using NBC.Entitas;
+using NBC.DataStructure.Collection;
+using NBC.Pool;
+using NBC.Serialize;
+
+namespace NBC.Entitas
+{
+    /// <summary>
+    /// 消息的对象池组件
+    /// </summary>
+    public sealed class MessagePoolComponent : Entity
+    {
+        private int _poolCount;
+        private const int MaxCapacity = ushort.MaxValue;
+        private readonly OneToManyQueue<Type, AMessage> _poolQueue = new OneToManyQueue<Type, AMessage>();
+        private readonly Dictionary<Type, Func<AMessage>> _typeCheckCache = new Dictionary<Type, Func<AMessage>>();
+        /// <summary>
+        /// 销毁组件
+        /// </summary>
+        public override void Dispose()
+        {
+            _poolCount = 0;
+            _poolQueue.Clear();
+            _typeCheckCache.Clear();
+            base.Dispose();
+        }
+        /// <summary>
+        /// 从对象池里获取一个消息，如果没有就创建一个新的
+        /// </summary>
+        /// <typeparam name="T">消息的泛型类型</typeparam>
+        /// <returns></returns>
+        public T Rent<T>() where T : AMessage, new()
+        {
+            if (!_poolQueue.TryDequeue(typeof(T), out var queue))
+            {
+                var instance = new T();
+                instance.SetScene(Scene);
+                instance.SetIsPool(true);
+                return instance;
+            }
+
+            queue.SetIsPool(true);
+            _poolCount--;
+            return (T)queue;
+        }
+
+        /// <summary>
+        /// <see cref="Rent"/>
+        /// </summary>
+        /// <param name="type">消息的类型</param>
+        /// <returns></returns>
+        /// <exception cref="NotSupportedException"></exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AMessage Rent(Type type)
+        {
+            if (!_poolQueue.TryDequeue(type, out var queue))
+            {
+                if (!_typeCheckCache.TryGetValue(type, out var createInstance))
+                {
+                    if (!typeof(AMessage).IsAssignableFrom(type))
+                    {
+                        throw new NotSupportedException($"{this.GetType().FullName} Type:{type.FullName} must inherit from IPool");
+                    }
+                    else
+                    {
+                        createInstance = CreateInstance.CreateMessage(type);
+                        _typeCheckCache[type] = createInstance;
+                    }
+                }
+                
+                var instance = createInstance();
+                instance.SetScene(Scene);
+                instance.SetIsPool(true);
+                return instance;
+            }
+            
+            queue.SetIsPool(true);
+            _poolCount--;
+            return queue;
+        }
+        /// <summary>
+        /// 返还一个消息到对象池中
+        /// </summary>
+        /// <param name="obj"></param>
+        public void Return(AMessage obj)
+        {
+            if (obj == null)
+            {
+                return;
+            }
+
+            if (!obj.IsPool())
+            {
+                return;
+            }
+
+            if (_poolCount >= MaxCapacity)
+            {
+                return;
+            }
+            
+            _poolCount++;
+            obj.SetIsPool(false);
+            _poolQueue.Enqueue(obj.GetType(), obj);
+        }
+
+        /// <summary>
+        /// <see cref="Return"/>
+        /// </summary>
+        /// <param name="obj">返还的消息</param>
+        /// <typeparam name="T">返还的消息泛型类型</typeparam>
+        public void Return<T>(T obj) where T : AMessage
+        {
+            if (obj == null)
+            {
+                return;
+            }
+
+            if (!obj.IsPool())
+            {
+                return;
+            }
+
+            if (_poolCount >= MaxCapacity)
+            {
+                return;
+            }
+            
+            _poolCount++;
+            obj.SetIsPool(false);
+            _poolQueue.Enqueue(typeof(T), obj);
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/MessagePoolComponent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b4db4a3115fd64377b5b89f2bdc001a1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/TimerComponent.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: de3b132dd12a0427face9541cc1ba095
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/TimerComponent/Interface.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 20842cefeece84173bf625c41a94ef63
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/TimerComponent/Interface/TimerHandler.cs

@@ -0,0 +1,10 @@
+using NBC.Event;
+
+namespace NBC
+{
+    /// <summary>
+    /// 计时器抽象类，提供了一个基础框架，用于创建处理计时器事件的具体类。
+    /// </summary>
+    /// <typeparam name="T">事件的类型参数</typeparam>
+    public abstract class TimerHandler<T> : EventSystem<T> { }
+}

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/TimerComponent/Interface/TimerHandler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0bb411c4d246b43aba54eb60b7654492
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/TimerComponent/TimerAction.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Runtime.InteropServices;
+
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+#pragma warning disable CS8625
+#pragma warning disable CS8618
+
+namespace NBC
+{
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct TimerAction
+    {
+        public long TimerId;
+        public long StartTime;
+        public long TriggerTime;
+        public readonly object Callback;
+        public readonly TimerType TimerType;
+        public TimerAction(long timerId, TimerType timerType, long startTime, long triggerTime, object callback) 
+        {
+            TimerId = timerId;
+            Callback = callback;
+            TimerType = timerType;
+            StartTime = startTime;
+            TriggerTime = triggerTime;
+        }
+    }
+}

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/TimerComponent/TimerAction.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5c875fd82f74f430c963315b79f7a9a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/NBC/Runtime/Core/Entitas/Component/TimerComponent/TimerComponent.cs

@@ -0,0 +1,45 @@
+// ReSharper disable ForCanBeConvertedToForeach
+
+using NBC.Entitas;
+using NBC.Entitas.Interface;
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+using UnityEngine;
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+namespace NBC
+{
+    public sealed class TimerComponentUpdateSystem : UpdateSystem<TimerComponent>
+    {
+        protected override void Update(TimerComponent self)
+        {
+            self.Update();
+        }
+    }
+
+    /// <summary>
+    /// 时间调度组件
+    /// </summary>
+    public sealed class TimerComponent : Entity
+    {
+        /// <summary>
+        /// 使用系统时间创建的计时器核心。
+        /// </summary>
+        public TimerSchedulerNet Net { get; private set; }
+
+        /// <summary>
+        /// 使用 Unity 时间创建的计时器核心。
+        /// </summary>
+        public TimerSchedulerNetUnity Unity { get; private set; }
+
+        internal TimerComponent Initialize()
+        {
+            Net = new TimerSchedulerNet(Scene);
+            Unity = new TimerSchedulerNetUnity(Scene);
+            return this;
+        }
+        public void Update()
+        {
+            Net.Update();
+            Unity.Update();
+        }
+    }
+}