diff --git a/TYLDDB-CSharp.sln b/TYLDDB-CSharp.sln
index d409f8a..bd725a6 100644
--- a/TYLDDB-CSharp.sln
+++ b/TYLDDB-CSharp.sln
@@ -12,16 +12,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TYLDDB.Test", "TYLDDB.Test\TYLDDB.Test.csproj", "{FDFD566C-CB13-43EB-970E-0EC0A21E36C0}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TYLDDB.Utils.FastCache.Test", "TYLDDB.Utils.FastCache.Test\TYLDDB.Utils.FastCache.Test.csproj", "{A58C0A6B-9BD4-4B29-9B5F-5FDFB849D23B}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Test", "Test", "{95BC8FAF-AB03-44A3-A7E7-8E42FA7138E3}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TYLDDB.Utils.Writer.Test", "TYLDDB.Utils.Writer.Test\TYLDDB.Utils.Writer.Test.csproj", "{1BA4CC53-078F-4943-B8EF-A522DA9E5060}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TimeRecord", "TimeRecord\TimeRecord.csproj", "{F95CF6BC-2255-47F8-AAB3-B7812BB2894D}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TYLDDB.Parser.Test", "TYLDDB.Parser.Test\TYLDDB.Parser.Test.csproj", "{0B96CCF3-16C7-4B18-9D07-A19D5D8E9641}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -36,32 +30,17 @@ Global
 		{FDFD566C-CB13-43EB-970E-0EC0A21E36C0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FDFD566C-CB13-43EB-970E-0EC0A21E36C0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{FDFD566C-CB13-43EB-970E-0EC0A21E36C0}.Release|Any CPU.Build.0 = Release|Any CPU
-		{A58C0A6B-9BD4-4B29-9B5F-5FDFB849D23B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A58C0A6B-9BD4-4B29-9B5F-5FDFB849D23B}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A58C0A6B-9BD4-4B29-9B5F-5FDFB849D23B}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{A58C0A6B-9BD4-4B29-9B5F-5FDFB849D23B}.Release|Any CPU.Build.0 = Release|Any CPU
-		{1BA4CC53-078F-4943-B8EF-A522DA9E5060}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{1BA4CC53-078F-4943-B8EF-A522DA9E5060}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{1BA4CC53-078F-4943-B8EF-A522DA9E5060}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{1BA4CC53-078F-4943-B8EF-A522DA9E5060}.Release|Any CPU.Build.0 = Release|Any CPU
 		{F95CF6BC-2255-47F8-AAB3-B7812BB2894D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{F95CF6BC-2255-47F8-AAB3-B7812BB2894D}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F95CF6BC-2255-47F8-AAB3-B7812BB2894D}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F95CF6BC-2255-47F8-AAB3-B7812BB2894D}.Release|Any CPU.Build.0 = Release|Any CPU
-		{0B96CCF3-16C7-4B18-9D07-A19D5D8E9641}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{0B96CCF3-16C7-4B18-9D07-A19D5D8E9641}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{0B96CCF3-16C7-4B18-9D07-A19D5D8E9641}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{0B96CCF3-16C7-4B18-9D07-A19D5D8E9641}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{FDFD566C-CB13-43EB-970E-0EC0A21E36C0} = {95BC8FAF-AB03-44A3-A7E7-8E42FA7138E3}
-		{A58C0A6B-9BD4-4B29-9B5F-5FDFB849D23B} = {95BC8FAF-AB03-44A3-A7E7-8E42FA7138E3}
-		{1BA4CC53-078F-4943-B8EF-A522DA9E5060} = {95BC8FAF-AB03-44A3-A7E7-8E42FA7138E3}
 		{F95CF6BC-2255-47F8-AAB3-B7812BB2894D} = {95BC8FAF-AB03-44A3-A7E7-8E42FA7138E3}
-		{0B96CCF3-16C7-4B18-9D07-A19D5D8E9641} = {95BC8FAF-AB03-44A3-A7E7-8E42FA7138E3}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {19390089-354C-41AD-AF7D-9FB3998A88EA}
diff --git a/TYLDDB.Test/Program.cs b/TYLDDB.Test/Program.cs
index f727e38..9158a16 100644
--- a/TYLDDB.Test/Program.cs
+++ b/TYLDDB.Test/Program.cs
@@ -36,8 +36,12 @@
 }
 WriteTime("从发起读取数据库名称到成功返回读取内容的总时间为: ", readAllDbNameTimer.ElapsedMilliseconds());
 
-
-
+///////////////////////////////////////////////////////////////////////////////////////////////////////// 数据库解析缓存
+HighPrecisionTimer parseDbTimer = new(); // 从发起解析文件到成功解析并写入缓存的总时间
+parseDbTimer.Start();
+await lddb.ParseAsync();
+parseDbTimer.Stop();
+WriteTime("从发起解析文件到成功解析并写入缓存的总时间: ", parseDbTimer.ElapsedMilliseconds());
 
 
 
diff --git a/TYLDDB.Utils.FastCache.Test/Program.cs b/TYLDDB.Utils.FastCache.Test/Program.cs
deleted file mode 100644
index 5172226..0000000
--- a/TYLDDB.Utils.FastCache.Test/Program.cs
+++ /dev/null
@@ -1,149 +0,0 @@
-using TimeRecord;
-using TYLDDB.Utils.FastCache;
-
-Console.WriteLine("基于信号量的缓存读写运行");
-SemaphoreSlimDefault();
-
-Console.WriteLine();
-Console.WriteLine("基于信号量的缓存读写运行");
-ConcurrentDictionary();
-Console.ReadLine();
-
-// 基于信号量的缓存读写运行
-static async void SemaphoreSlimDefault()
-{
-    var setTime = new HighPrecisionTimer();
-    var setAsyncTime = new HighPrecisionTimer();
-    var getByKeyTime = new HighPrecisionTimer();
-    var getByKeyAsyncTime = new HighPrecisionTimer();
-    var getKeysByValueTime = new HighPrecisionTimer();
-    var getKeysByValueAsyncTime = new HighPrecisionTimer();
-    var getAllCacheTime = new HighPrecisionTimer();
-    var getAllCacheAsyncTime = new HighPrecisionTimer();
-
-    var cache = new SemaphoreThreadLock();
-
-    setTime.Start();
-    cache.Set("TESTKEY1", "TESTVALUE1");
-    setTime.Stop();
-
-    setAsyncTime.Start();
-    await cache.SetAsync("TESTKEY2", "TESTVALUE2");
-    setAsyncTime.Stop();
-
-    getByKeyTime.Start();
-    Console.WriteLine("TESTKEY1对应的值：" + cache.GetByKey("TESTKEY1"));
-    getByKeyTime.Stop();
-
-    getByKeyAsyncTime.Start();
-    Console.WriteLine("TESTKEY2对应的值：" + await cache.GetByKeyAsync("TESTKEY2"));
-    getByKeyAsyncTime.Stop();
-
-    cache.Set("TESTKEY3", "TESTVALUE2");
-
-    Console.WriteLine("TESTVALUE2对应的所有键：");
-    getKeysByValueTime.Start();
-    Console.WriteLine(string.Join(", ", cache.GetKeysByValue("TESTVALUE2")));
-    getKeysByValueTime.Stop();
-
-    Console.WriteLine("TESTVALUE2对应的所有键：");
-    getKeysByValueAsyncTime.Start();
-    Console.WriteLine(string.Join(", ", await cache.GetKeysByValueAsync("TESTVALUE2")));
-    getKeysByValueAsyncTime.Stop();
-
-    // 获取并输出所有缓存项（同步方法）
-    getAllCacheTime.Start();
-    var allCacheSync = cache.GetAllCache();
-    Console.WriteLine("同步获取所有缓存项:");
-    foreach (var kvp in allCacheSync)
-    {
-        Console.WriteLine($"{kvp.Key}: {kvp.Value}");
-    }
-    getAllCacheTime.Stop();
-
-    // 获取并输出所有缓存项（异步方法）
-    getAllCacheAsyncTime.Start();
-    var allCacheAsync = await cache.GetAllCacheAsync();
-    Console.WriteLine("异步获取所有缓存项:");
-    foreach (var kvp in allCacheAsync)
-    {
-        Console.WriteLine($"{kvp.Key}: {kvp.Value}");
-    }
-    getAllCacheAsyncTime.Stop();
-
-
-    Console.WriteLine("时间消耗：");
-    Console.WriteLine($"设置键值(同步)：{setTime.ElapsedMilliseconds()}ms 设置键值(异步)：{setAsyncTime.ElapsedMilliseconds()}ms");
-    Console.WriteLine($"根据键获取值(同步)：{getByKeyTime.ElapsedMilliseconds()}ms 根据键获取值(异步)：{getByKeyAsyncTime.ElapsedMilliseconds()}ms");
-    Console.WriteLine($"根据值获取键(同步)：{getKeysByValueTime.ElapsedMilliseconds()}ms 根据值获取键(异步)：{getKeysByValueAsyncTime.ElapsedMilliseconds()}ms");
-    Console.WriteLine($"获取所有缓存项(同步)：{getAllCacheTime.ElapsedMilliseconds()}ms 获取所有缓存项(异步)：{getAllCacheAsyncTime.ElapsedMilliseconds()}ms");
-}
-
-// 基于并发词典的缓存读写运行
-static async void ConcurrentDictionary()
-{
-    var setTime = new HighPrecisionTimer();
-    var setAsyncTime = new HighPrecisionTimer();
-    var getByKeyTime = new HighPrecisionTimer();
-    var getByKeyAsyncTime = new HighPrecisionTimer();
-    var getKeysByValueTime = new HighPrecisionTimer();
-    var getKeysByValueAsyncTime = new HighPrecisionTimer();
-    var getAllCacheTime = new HighPrecisionTimer();
-    var getAllCacheAsyncTime = new HighPrecisionTimer();
-
-    var cache = new ConcurrentDictionary();
-
-    setTime.Start();
-    cache.Set("TESTKEY1", "TESTVALUE1");
-    setTime.Stop();
-
-    setAsyncTime.Start();
-    await cache.SetAsync("TESTKEY2", "TESTVALUE2");
-    setAsyncTime.Stop();
-
-    getByKeyTime.Start();
-    Console.WriteLine("TESTKEY1对应的值：" + cache.GetByKey("TESTKEY1"));
-    getByKeyTime.Stop();
-
-    getByKeyAsyncTime.Start();
-    Console.WriteLine("TESTKEY2对应的值：" + await cache.GetByKeyAsync("TESTKEY2"));
-    getByKeyAsyncTime.Stop();
-
-    cache.Set("TESTKEY3", "TESTVALUE2");
-
-    Console.WriteLine("TESTVALUE2对应的所有键：");
-    getKeysByValueTime.Start();
-    Console.WriteLine(string.Join(", ", cache.GetKeysByValue("TESTVALUE2")));
-    getKeysByValueTime.Stop();
-
-    Console.WriteLine("TESTVALUE2对应的所有键：");
-    getKeysByValueAsyncTime.Start();
-    Console.WriteLine(string.Join(", ", await cache.GetKeysByValueAsync("TESTVALUE2")));
-    getKeysByValueAsyncTime.Stop();
-
-    // 获取并输出所有缓存项（同步方法）
-    getAllCacheTime.Start();
-    var allCacheSync = cache.GetAllCache();
-    Console.WriteLine("同步获取所有缓存项:");
-    foreach (var kvp in allCacheSync)
-    {
-        Console.WriteLine($"{kvp.Key}: {kvp.Value}");
-    }
-    getAllCacheTime.Stop();
-
-    // 获取并输出所有缓存项（异步方法）
-    getAllCacheAsyncTime.Start();
-    var allCacheAsync = await cache.GetAllCacheAsync();
-    Console.WriteLine("异步获取所有缓存项:");
-    foreach (var kvp in allCacheAsync)
-    {
-        Console.WriteLine($"{kvp.Key}: {kvp.Value}");
-    }
-    getAllCacheAsyncTime.Stop();
-
-    Console.WriteLine("时间消耗：");
-    Console.WriteLine($"设置键值(同步)：{setTime.ElapsedMilliseconds()}ms 设置键值(异步)：{setAsyncTime.ElapsedMilliseconds()}ms");
-    Console.WriteLine($"根据键获取值(同步)：{getByKeyTime.ElapsedMilliseconds()}ms 根据键获取值(异步)：{getByKeyAsyncTime.ElapsedMilliseconds()}ms");
-    Console.WriteLine($"根据值获取键(同步)：{getKeysByValueTime.ElapsedMilliseconds()}ms 根据值获取键(异步)：{getKeysByValueAsyncTime.ElapsedMilliseconds()}ms");
-    Console.WriteLine($"获取所有缓存项(同步)：{getAllCacheTime.ElapsedMilliseconds()}ms 获取所有缓存项(异步)：{getAllCacheAsyncTime.ElapsedMilliseconds()}ms");
-}
diff --git a/TYLDDB.Utils.FastCache.Test/TYLDDB.Utils.FastCache.Test.csproj b/TYLDDB.Utils.FastCache.Test/TYLDDB.Utils.FastCache.Test.csproj
deleted file mode 100644
index 700866e..0000000
--- a/TYLDDB.Utils.FastCache.Test/TYLDDB.Utils.FastCache.Test.csproj
+++ /dev/null
@@ -1,15 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\TimeRecord\TimeRecord.csproj" />
-    <ProjectReference Include="..\TYLDDB\TYLDDB.csproj" />
-  </ItemGroup>
-
-</Project>
diff --git a/TYLDDB/Parser/Parser.cs b/TYLDDB/Parser/Parser.cs
index 326f561..02c995b 100644
--- a/TYLDDB/Parser/Parser.cs
+++ b/TYLDDB/Parser/Parser.cs
@@ -8,7 +8,7 @@ namespace TYLDDB.Parser
     /// Data type parser.<br />
     /// 数据类型解析器。
     /// </summary>
-    public class Parser
+    public class DataParser
     {
         // 定义正则表达式来匹配键值对（类型::"key"="value"）
         private readonly static string pattern = @"(?<=^|\s)(\w+)\s*::\s*""([^""]+)""";
diff --git a/TYLDDB/TYLDDB.cs b/TYLDDB/TYLDDB.cs
index c268361..cdc8d6a 100644
--- a/TYLDDB/TYLDDB.cs
+++ b/TYLDDB/TYLDDB.cs
@@ -1,8 +1,10 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using TYLDDB.Basic;
+using TYLDDB.Parser;
 using TYLDDB.Utils;
-using TYLDDB.Utils.FastCache;
+using TYLDDB.Utils.FastCache.ConcurrentDictionary;
+using TYLDDB.Utils.FastCache.SemaphoreThreadLock;
 
 namespace TYLDDB
 {
@@ -27,10 +29,9 @@ public LDDB()
         private string _database; // 存储正在访问的数据库
         private string _databaseContent; // 存储数据库内容
         private bool _isRead = false; // 是否已调用读取文件
-        private event Action OnFileReadComplete;
         private Database database = new Database();
-        private Cache cdCache = new ConcurrentDictionary();
-        private Cache stlCache = new SemaphoreThreadLock();
+        private CdStringDictionary cdStringDictionary = new CdStringDictionary();
+        private StlStringDictionary StlStringDictionary = new StlStringDictionary();
 
         ///////////////////////////////////////////////////// 公开字段
         /// <summary>
@@ -39,11 +40,16 @@ public LDDB()
         /// </summary>
         public string FilePath
         {
-            get => _filePath; // 获取文件路径
+            get
+            {
+                return _filePath; // 获取文件路径
+            }
             set
             {
-                ValidateFilePath(value); // 在设置值之前进行验证
-                _filePath = value; // 只有通过验证后才设置值
+                if (ValidateFilePath(value)) // 在设置值之前进行验证
+                {
+                    _filePath = value;
+                }
             }
         }
         /// <summary>
@@ -57,12 +63,15 @@ public string FilePath
         /// </summary>
         /// <param name="path">路径</param>
         /// <exception cref="FilePathIsNullOrWhiteSpace"></exception>
-        private static void ValidateFilePath(string path)
+        /// <returns>If <c>true</c>, it can be used, if <c>false</c>, it cannot be used.<br />如果为<c>true</c>则可以使用，若为<c>false</c>则不可使用。</returns>
+        private static bool ValidateFilePath(string path)
         {
             if (string.IsNullOrWhiteSpace(path))
             {
+                return false;
                 throw new FilePathIsNullOrWhiteSpace("文件路径不能为 null 或空白");
             }
+            return true;
         }
 
         /// <summary>
@@ -80,7 +89,7 @@ public void ReadingFile()
         /// 设置要加载的数据库
         /// </summary>
         /// <param name="db">name of the database<br/>数据库名称</param>
-        public void LoadDatabase(string db)
+        public async void LoadDatabase(string db)
         {
             switch (_isRead)
             {
@@ -92,6 +101,7 @@ public void LoadDatabase(string db)
                     _databaseContent = database.GetDatabaseContent(_fileContent, db);
                     break;
             }
+            await ParseAsync();
         }
 
         /// <summary>
@@ -105,5 +115,35 @@ public void LoadDatabase(string db)
         /// 读取全部数据库的名称
         /// </summary>
         public void ReadAllDatabaseName() => AllDatabaseName = database.GetDatabaseList(_fileContent);
+
+        /// <summary>
+        /// Reparse the entire database.<br />
+        /// 重新解析整个数据库。
+        /// </summary>
+        public async Task ParseAsync()
+        {
+            // 创建多个任务，并使用 LongRunning 来确保每个任务在独立线程中运行
+            Task cdStringCacheTask = Task.Factory.StartNew(() => CdString(), TaskCreationOptions.LongRunning);
+            //Task cdIntCacheTask = Task.Factory.StartNew(() => CdInt(), TaskCreationOptions.LongRunning);
+            //Task cdShortCacheTask = Task.Factory.StartNew(() => CdShort(), TaskCreationOptions.LongRunning);
+
+            // 等待所有任务完成
+            await Task.WhenAll(cdStringCacheTask);
+
+            async void CdString()
+            {
+                var dict = DataParser.ParseString(_databaseContent);
+
+                // 遍历 dict 中的每一项
+                foreach (var kvp in dict)
+                {
+                    var key = kvp.Key;   // 获取第一个值 (key)
+                    var value = kvp.Value;  // 获取第二个值 (value)
+
+                    // 将 key-value 对存储到缓存
+                    await cdStringDictionary.SetAsync(key, value);
+                }
+            }
+        }
     }
 }
diff --git a/TYLDDB/TYLDDB.csproj b/TYLDDB/TYLDDB.csproj
index a8a6ed5..b470d6c 100644
--- a/TYLDDB/TYLDDB.csproj
+++ b/TYLDDB/TYLDDB.csproj
@@ -4,7 +4,7 @@
     <TargetFrameworks>netstandard2.1;net6.0;net8.0;net9.0</TargetFrameworks>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <Title>TYLDDB.NET</Title>
-    <Version>1.0.0-alpha.3</Version>
+    <Version>1.0.0-alpha.4</Version>
     <Authors>TYLDDB-Project</Authors>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
diff --git a/TYLDDB/Utils/FastCache/Cache.cs b/TYLDDB/Utils/FastCache/Cache.cs
deleted file mode 100644
index dc06ba2..0000000
--- a/TYLDDB/Utils/FastCache/Cache.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace TYLDDB.Utils.FastCache
-{
-    /// <summary>
-    /// For cached abstract classes, you need to inherit the class to do concrete implementation.<br />
-    /// 对于缓存的抽象类，需要继承该类来做具体实现。
-    /// </summary>
-    public abstract class Cache : ICache
-    {
-        /// <inheritdoc/>
-        public abstract void Clear();
-        /// <inheritdoc/>
-        public virtual async Task ClearAsync() => await Task.Run(() => Clear());
-        /// <inheritdoc/>
-        public abstract Dictionary<string, string> GetAllCache();
-        /// <inheritdoc/>
-        public virtual async Task<Dictionary<string, string>> GetAllCacheAsync() => await Task.FromResult(GetAllCache());
-        /// <inheritdoc/>
-        public abstract string GetByKey(string key);
-        /// <inheritdoc/>
-        public virtual async Task<string> GetByKeyAsync(string key) => await Task.FromResult(GetByKey(key));
-        /// <inheritdoc/>
-        public abstract List<string> GetKeysByValue(string value);
-        /// <inheritdoc/>
-        public virtual async Task<List<string>> GetKeysByValueAsync(string value) => await Task.FromResult(GetKeysByValue(value));
-        /// <inheritdoc/>
-        public abstract bool RemoveByKey(string key);
-        /// <inheritdoc/>
-        public virtual async Task<bool> RemoveByKeyAsync(string key) => await Task.FromResult(RemoveByKey(key));
-        /// <inheritdoc/>
-        public abstract bool Set(string key, string value);
-        /// <inheritdoc/>
-        public virtual async Task<bool> SetAsync(string key, string value) => await Task.FromResult(Set(key, value));
-    }
-}
diff --git a/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdBooleanDictionary.cs b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdBooleanDictionary.cs
new file mode 100644
index 0000000..9a50a8f
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdBooleanDictionary.cs
@@ -0,0 +1,124 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.ConcurrentDictionary
+{
+    /// <summary>
+    /// Use concurrent dictionaries to achieve high concurrency stability.<br />
+    /// 使用并发词典来实现高并发的稳定性。
+    /// </summary>
+    public class CdBooleanDictionary
+    {
+        /// <summary>
+        /// Thread-safe dictionary to store cache data.<br />
+        /// 线程安全的字典，用于存储缓存数据。
+        /// </summary>
+        private readonly ConcurrentDictionary<string, bool> _cache = new ConcurrentDictionary<string, bool>();
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual bool GetByKey(string key)
+        {
+            _cache.TryGetValue(key, out var value);
+            return value;
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<bool> GetByKeyAsync(string key) => await Task.FromResult(GetByKey(key));
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual List<string> GetKeysByValue(bool value)
+        {
+            var keys = new List<string>();
+            foreach (var kvp in _cache)
+            {
+                if (kvp.Value == value)
+                {
+                    keys.Add(kvp.Key);
+                }
+            }
+            return keys;
+        }
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(bool value) => await Task.FromResult(GetKeysByValue(value));
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual bool Set(string key, bool value)
+        {
+            // Using AddOrUpdate to ensure atomic insert or update operation
+            _cache.AddOrUpdate(key, value, (existingKey, existingValue) => value);
+            return true;
+        }
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual async Task<bool> SetAsync(string key, bool value) => await Task.FromResult(Set(key, value));
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual bool RemoveByKey(string key) => _cache.TryRemove(key, out _);
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key) => await Task.FromResult(RemoveByKey(key));
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual void Clear() => _cache.Clear();
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual async Task ClearAsync() => await Task.Run(() => Clear());
+
+        /// <summary>
+        /// Get all cache entries as a dictionary.<br />
+        /// 获取所有缓存项，返回字典。
+        /// </summary>
+        /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
+        public virtual Dictionary<string, bool> GetAllCache() => new Dictionary<string, bool>(_cache);
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdCharDictionary.cs b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdCharDictionary.cs
new file mode 100644
index 0000000..9e27136
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdCharDictionary.cs
@@ -0,0 +1,124 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.ConcurrentDictionary
+{
+    /// <summary>
+    /// Use concurrent dictionaries to achieve high concurrency stability.<br />
+    /// 使用并发词典来实现高并发的稳定性。
+    /// </summary>
+    public class CdCharDictionary
+    {
+        /// <summary>
+        /// Thread-safe dictionary to store cache data.<br />
+        /// 线程安全的字典，用于存储缓存数据。
+        /// </summary>
+        private readonly ConcurrentDictionary<string, char> _cache = new ConcurrentDictionary<string, char>();
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual char GetByKey(string key)
+        {
+            _cache.TryGetValue(key, out var value);
+            return value;
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<char> GetByKeyAsync(string key) => await Task.FromResult(GetByKey(key));
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual List<string> GetKeysByValue(char value)
+        {
+            var keys = new List<string>();
+            foreach (var kvp in _cache)
+            {
+                if (kvp.Value == value)
+                {
+                    keys.Add(kvp.Key);
+                }
+            }
+            return keys;
+        }
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(char value) => await Task.FromResult(GetKeysByValue(value));
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual bool Set(string key, char value)
+        {
+            // Using AddOrUpdate to ensure atomic insert or update operation
+            _cache.AddOrUpdate(key, value, (existingKey, existingValue) => value);
+            return true;
+        }
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual async Task<bool> SetAsync(string key, char value) => await Task.FromResult(Set(key, value));
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual bool RemoveByKey(string key) => _cache.TryRemove(key, out _);
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key) => await Task.FromResult(RemoveByKey(key));
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual void Clear() => _cache.Clear();
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual async Task ClearAsync() => await Task.Run(() => Clear());
+
+        /// <summary>
+        /// Get all cache entries as a dictionary.<br />
+        /// 获取所有缓存项，返回字典。
+        /// </summary>
+        /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
+        public virtual Dictionary<string, char> GetAllCache() => new Dictionary<string, char>(_cache);
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdDecimalDictionary.cs b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdDecimalDictionary.cs
new file mode 100644
index 0000000..aa0a9d5
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdDecimalDictionary.cs
@@ -0,0 +1,124 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.ConcurrentDictionary
+{
+    /// <summary>
+    /// Use concurrent dictionaries to achieve high concurrency stability.<br />
+    /// 使用并发词典来实现高并发的稳定性。
+    /// </summary>
+    public class CdDecimalDictionary
+    {
+        /// <summary>
+        /// Thread-safe dictionary to store cache data.<br />
+        /// 线程安全的字典，用于存储缓存数据。
+        /// </summary>
+        private readonly ConcurrentDictionary<string, decimal> _cache = new ConcurrentDictionary<string, decimal>();
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual decimal GetByKey(string key)
+        {
+            _cache.TryGetValue(key, out var value);
+            return value;
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<decimal> GetByKeyAsync(string key) => await Task.FromResult(GetByKey(key));
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual List<string> GetKeysByValue(decimal value)
+        {
+            var keys = new List<string>();
+            foreach (var kvp in _cache)
+            {
+                if (kvp.Value == value)
+                {
+                    keys.Add(kvp.Key);
+                }
+            }
+            return keys;
+        }
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(decimal value) => await Task.FromResult(GetKeysByValue(value));
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual bool Set(string key, decimal value)
+        {
+            // Using AddOrUpdate to ensure atomic insert or update operation
+            _cache.AddOrUpdate(key, value, (existingKey, existingValue) => value);
+            return true;
+        }
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual async Task<bool> SetAsync(string key, decimal value) => await Task.FromResult(Set(key, value));
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual bool RemoveByKey(string key) => _cache.TryRemove(key, out _);
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key) => await Task.FromResult(RemoveByKey(key));
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual void Clear() => _cache.Clear();
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual async Task ClearAsync() => await Task.Run(() => Clear());
+
+        /// <summary>
+        /// Get all cache entries as a dictionary.<br />
+        /// 获取所有缓存项，返回字典。
+        /// </summary>
+        /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
+        public virtual Dictionary<string, decimal> GetAllCache() => new Dictionary<string, decimal>(_cache);
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdDoubleDictionary.cs b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdDoubleDictionary.cs
new file mode 100644
index 0000000..c2c09e7
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdDoubleDictionary.cs
@@ -0,0 +1,124 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.ConcurrentDictionary
+{
+    /// <summary>
+    /// Use concurrent dictionaries to achieve high concurrency stability.<br />
+    /// 使用并发词典来实现高并发的稳定性。
+    /// </summary>
+    public class CdDoubleDictionary
+    {
+        /// <summary>
+        /// Thread-safe dictionary to store cache data.<br />
+        /// 线程安全的字典，用于存储缓存数据。
+        /// </summary>
+        private readonly ConcurrentDictionary<string, double> _cache = new ConcurrentDictionary<string, double>();
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual double GetByKey(string key)
+        {
+            _cache.TryGetValue(key, out var value);
+            return value;
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<double> GetByKeyAsync(string key) => await Task.FromResult(GetByKey(key));
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual List<string> GetKeysByValue(double value)
+        {
+            var keys = new List<string>();
+            foreach (var kvp in _cache)
+            {
+                if (kvp.Value == value)
+                {
+                    keys.Add(kvp.Key);
+                }
+            }
+            return keys;
+        }
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(double value) => await Task.FromResult(GetKeysByValue(value));
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual bool Set(string key, double value)
+        {
+            // Using AddOrUpdate to ensure atomic insert or update operation
+            _cache.AddOrUpdate(key, value, (existingKey, existingValue) => value);
+            return true;
+        }
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual async Task<bool> SetAsync(string key, double value) => await Task.FromResult(Set(key, value));
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual bool RemoveByKey(string key) => _cache.TryRemove(key, out _);
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key) => await Task.FromResult(RemoveByKey(key));
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual void Clear() => _cache.Clear();
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual async Task ClearAsync() => await Task.Run(() => Clear());
+
+        /// <summary>
+        /// Get all cache entries as a dictionary.<br />
+        /// 获取所有缓存项，返回字典。
+        /// </summary>
+        /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
+        public virtual Dictionary<string, double> GetAllCache() => new Dictionary<string, double>(_cache);
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdFloatDictionary.cs b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdFloatDictionary.cs
new file mode 100644
index 0000000..bed0e42
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdFloatDictionary.cs
@@ -0,0 +1,124 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.ConcurrentDictionary
+{
+    /// <summary>
+    /// Use concurrent dictionaries to achieve high concurrency stability.<br />
+    /// 使用并发词典来实现高并发的稳定性。
+    /// </summary>
+    public class CdFloatDictionary
+    {
+        /// <summary>
+        /// Thread-safe dictionary to store cache data.<br />
+        /// 线程安全的字典，用于存储缓存数据。
+        /// </summary>
+        private readonly ConcurrentDictionary<string, float> _cache = new ConcurrentDictionary<string, float>();
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual float GetByKey(string key)
+        {
+            _cache.TryGetValue(key, out var value);
+            return value;
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<float> GetByKeyAsync(string key) => await Task.FromResult(GetByKey(key));
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual List<string> GetKeysByValue(float value)
+        {
+            var keys = new List<string>();
+            foreach (var kvp in _cache)
+            {
+                if (kvp.Value == value)
+                {
+                    keys.Add(kvp.Key);
+                }
+            }
+            return keys;
+        }
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(float value) => await Task.FromResult(GetKeysByValue(value));
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual bool Set(string key, float value)
+        {
+            // Using AddOrUpdate to ensure atomic insert or update operation
+            _cache.AddOrUpdate(key, value, (existingKey, existingValue) => value);
+            return true;
+        }
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual async Task<bool> SetAsync(string key, float value) => await Task.FromResult(Set(key, value));
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual bool RemoveByKey(string key) => _cache.TryRemove(key, out _);
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key) => await Task.FromResult(RemoveByKey(key));
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual void Clear() => _cache.Clear();
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual async Task ClearAsync() => await Task.Run(() => Clear());
+
+        /// <summary>
+        /// Get all cache entries as a dictionary.<br />
+        /// 获取所有缓存项，返回字典。
+        /// </summary>
+        /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
+        public virtual Dictionary<string, float> GetAllCache() => new Dictionary<string, float>(_cache);
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdIntegerDictionary.cs b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdIntegerDictionary.cs
new file mode 100644
index 0000000..feb3f2f
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdIntegerDictionary.cs
@@ -0,0 +1,124 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.ConcurrentDictionary
+{
+    /// <summary>
+    /// Use concurrent dictionaries to achieve high concurrency stability.<br />
+    /// 使用并发词典来实现高并发的稳定性。
+    /// </summary>
+    public class CdIntegerDictionary
+    {
+        /// <summary>
+        /// Thread-safe dictionary to store cache data.<br />
+        /// 线程安全的字典，用于存储缓存数据。
+        /// </summary>
+        private readonly ConcurrentDictionary<string, int> _cache = new ConcurrentDictionary<string, int>();
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual int GetByKey(string key)
+        {
+            _cache.TryGetValue(key, out var value);
+            return value;
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<int> GetByKeyAsync(string key) => await Task.FromResult(GetByKey(key));
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual List<string> GetKeysByValue(int value)
+        {
+            var keys = new List<string>();
+            foreach (var kvp in _cache)
+            {
+                if (kvp.Value == value)
+                {
+                    keys.Add(kvp.Key);
+                }
+            }
+            return keys;
+        }
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(int value) => await Task.FromResult(GetKeysByValue(value));
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual bool Set(string key, int value)
+        {
+            // Using AddOrUpdate to ensure atomic insert or update operation
+            _cache.AddOrUpdate(key, value, (existingKey, existingValue) => value);
+            return true;
+        }
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual async Task<bool> SetAsync(string key, int value) => await Task.FromResult(Set(key, value));
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual bool RemoveByKey(string key) => _cache.TryRemove(key, out _);
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key) => await Task.FromResult(RemoveByKey(key));
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual void Clear() => _cache.Clear();
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual async Task ClearAsync() => await Task.Run(() => Clear());
+
+        /// <summary>
+        /// Get all cache entries as a dictionary.<br />
+        /// 获取所有缓存项，返回字典。
+        /// </summary>
+        /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
+        public virtual Dictionary<string, int> GetAllCache() => new Dictionary<string, int>(_cache);
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdLongDictionary.cs b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdLongDictionary.cs
new file mode 100644
index 0000000..43656d6
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdLongDictionary.cs
@@ -0,0 +1,124 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.ConcurrentDictionary
+{
+    /// <summary>
+    /// Use concurrent dictionaries to achieve high concurrency stability.<br />
+    /// 使用并发词典来实现高并发的稳定性。
+    /// </summary>
+    public class CdLongDictionary
+    {
+        /// <summary>
+        /// Thread-safe dictionary to store cache data.<br />
+        /// 线程安全的字典，用于存储缓存数据。
+        /// </summary>
+        private readonly ConcurrentDictionary<string, long> _cache = new ConcurrentDictionary<string, long>();
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual long GetByKey(string key)
+        {
+            _cache.TryGetValue(key, out var value);
+            return value;
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<long> GetByKeyAsync(string key) => await Task.FromResult(GetByKey(key));
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual List<string> GetKeysByValue(long value)
+        {
+            var keys = new List<string>();
+            foreach (var kvp in _cache)
+            {
+                if (kvp.Value == value)
+                {
+                    keys.Add(kvp.Key);
+                }
+            }
+            return keys;
+        }
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(long value) => await Task.FromResult(GetKeysByValue(value));
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual bool Set(string key, long value)
+        {
+            // Using AddOrUpdate to ensure atomic insert or update operation
+            _cache.AddOrUpdate(key, value, (existingKey, existingValue) => value);
+            return true;
+        }
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual async Task<bool> SetAsync(string key, long value) => await Task.FromResult(Set(key, value));
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual bool RemoveByKey(string key) => _cache.TryRemove(key, out _);
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key) => await Task.FromResult(RemoveByKey(key));
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual void Clear() => _cache.Clear();
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual async Task ClearAsync() => await Task.Run(() => Clear());
+
+        /// <summary>
+        /// Get all cache entries as a dictionary.<br />
+        /// 获取所有缓存项，返回字典。
+        /// </summary>
+        /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
+        public virtual Dictionary<string, long> GetAllCache() => new Dictionary<string, long>(_cache);
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdShortDictionary.cs b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdShortDictionary.cs
new file mode 100644
index 0000000..8ad8464
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdShortDictionary.cs
@@ -0,0 +1,124 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.ConcurrentDictionary
+{
+    /// <summary>
+    /// Use concurrent dictionaries to achieve high concurrency stability.<br />
+    /// 使用并发词典来实现高并发的稳定性。
+    /// </summary>
+    public class CdShortDictionary
+    {
+        /// <summary>
+        /// Thread-safe dictionary to store cache data.<br />
+        /// 线程安全的字典，用于存储缓存数据。
+        /// </summary>
+        private readonly ConcurrentDictionary<string, short> _cache = new ConcurrentDictionary<string, short>();
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual short GetByKey(string key)
+        {
+            _cache.TryGetValue(key, out var value);
+            return value;
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<short> GetByKeyAsync(string key) => await Task.FromResult(GetByKey(key));
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual List<string> GetKeysByValue(short value)
+        {
+            var keys = new List<string>();
+            foreach (var kvp in _cache)
+            {
+                if (kvp.Value == value)
+                {
+                    keys.Add(kvp.Key);
+                }
+            }
+            return keys;
+        }
+
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(short value) => await Task.FromResult(GetKeysByValue(value));
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual bool Set(string key, short value)
+        {
+            // Using AddOrUpdate to ensure atomic insert or update operation
+            _cache.AddOrUpdate(key, value, (existingKey, existingValue) => value);
+            return true;
+        }
+
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual async Task<bool> SetAsync(string key, short value) => await Task.FromResult(Set(key, value));
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual bool RemoveByKey(string key) => _cache.TryRemove(key, out _);
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key) => await Task.FromResult(RemoveByKey(key));
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual void Clear() => _cache.Clear();
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual async Task ClearAsync() => await Task.Run(() => Clear());
+
+        /// <summary>
+        /// Get all cache entries as a dictionary.<br />
+        /// 获取所有缓存项，返回字典。
+        /// </summary>
+        /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
+        public virtual Dictionary<string, short> GetAllCache() => new Dictionary<string, short>(_cache);
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/ConcurrentDictionary.cs b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdStringDictionary.cs
similarity index 50%
rename from TYLDDB/Utils/FastCache/ConcurrentDictionary.cs
rename to TYLDDB/Utils/FastCache/ConcurrentDictionary/CdStringDictionary.cs
index ba98a93..a859eae 100644
--- a/TYLDDB/Utils/FastCache/ConcurrentDictionary.cs
+++ b/TYLDDB/Utils/FastCache/ConcurrentDictionary/CdStringDictionary.cs
@@ -1,13 +1,14 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
-namespace TYLDDB.Utils.FastCache
+namespace TYLDDB.Utils.FastCache.ConcurrentDictionary
 {
     /// <summary>
-    /// Use thread locks based on concurrent dictionaries to achieve high concurrency stability.<br />
-    /// 使用基于信号量的线程锁来实现高并发的稳定性。
+    /// Use concurrent dictionaries to achieve high concurrency stability.<br />
+    /// 使用并发词典来实现高并发的稳定性。
     /// </summary>
-    public class ConcurrentDictionary : Cache
+    public class CdStringDictionary
     {
         /// <summary>
         /// Thread-safe dictionary to store cache data.<br />
@@ -21,19 +22,27 @@ public class ConcurrentDictionary : Cache
         /// </summary>
         /// <param name="key">Key<br />键</param>
         /// <returns>Value<br />值</returns>
-        public override string GetByKey(string key)
+        public virtual string GetByKey(string key)
         {
             _cache.TryGetValue(key, out var value);
             return value;
         }
 
+        /// <summary>
+        /// Asynchronous method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<string> GetByKeyAsync(string key) => await Task.FromResult(GetByKey(key));
+
         /// <summary>
         /// Get a list of keys that correspond to a specific value.<br />
         /// 获取与指定值对应的所有键的列表。
         /// </summary>
         /// <param name="value">Value to match<br />要匹配的值</param>
         /// <returns>List of keys<br />键的列表</returns>
-        public override List<string> GetKeysByValue(string value)
+        public virtual List<string> GetKeysByValue(string value)
         {
             var keys = new List<string>();
             foreach (var kvp in _cache)
@@ -46,6 +55,14 @@ public override List<string> GetKeysByValue(string value)
             return keys;
         }
 
+        /// <summary>
+        /// Get a list of keys that correspond to a specific value.<br />
+        /// 获取与指定值对应的所有键的列表。
+        /// </summary>
+        /// <param name="value">Value to match<br />要匹配的值</param>
+        /// <returns>List of keys<br />键的列表</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(string value) => await Task.FromResult(GetKeysByValue(value));
+
         /// <summary>
         /// Set a cache entry for a specified key.<br />
         /// 为指定键设置缓存项。
@@ -53,35 +70,55 @@ public override List<string> GetKeysByValue(string value)
         /// <param name="key">Key<br />键</param>
         /// <param name="value">Value<br />值</param>
         /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
-        public override bool Set(string key, string value)
+        public virtual bool Set(string key, string value)
         {
             // Using AddOrUpdate to ensure atomic insert or update operation
             _cache.AddOrUpdate(key, value, (existingKey, existingValue) => value);
             return true;
         }
 
+        /// <summary>
+        /// Set a cache entry for a specified key.<br />
+        /// 为指定键设置缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
+        public virtual async Task<bool> SetAsync(string key, string value) => await Task.FromResult(Set(key, value));
+
         /// <summary>
         /// Remove a cache entry by its key.<br />
         /// 根据键移除缓存项。
         /// </summary>
         /// <param name="key">Key<br />键</param>
         /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
-        public override bool RemoveByKey(string key)
-        {
-            return _cache.TryRemove(key, out _);
-        }
+        public virtual bool RemoveByKey(string key) => _cache.TryRemove(key, out _);
+
+        /// <summary>
+        /// Remove a cache entry by its key.<br />
+        /// 根据键移除缓存项。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key) => await Task.FromResult(RemoveByKey(key));
+
+        /// <summary>
+        /// Clear all cache entries.<br />
+        /// 清空所有缓存项。
+        /// </summary>
+        public virtual void Clear() => _cache.Clear();
 
         /// <summary>
         /// Clear all cache entries.<br />
         /// 清空所有缓存项。
         /// </summary>
-        public override void Clear() => _cache.Clear();
+        public virtual async Task ClearAsync() => await Task.Run(() => Clear());
 
         /// <summary>
         /// Get all cache entries as a dictionary.<br />
         /// 获取所有缓存项，返回字典。
         /// </summary>
         /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
-        public override Dictionary<string, string> GetAllCache() => new Dictionary<string, string>(_cache);
+        public virtual Dictionary<string, string> GetAllCache() => new Dictionary<string, string>(_cache);
     }
 }
diff --git a/TYLDDB/Utils/FastCache/ICache.cs b/TYLDDB/Utils/FastCache/ICache.cs
deleted file mode 100644
index ea3ecce..0000000
--- a/TYLDDB/Utils/FastCache/ICache.cs
+++ /dev/null
@@ -1,104 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace TYLDDB.Utils.FastCache
-{
-    /// <summary>
-    /// Use cached key-value pairs for fast reads and writes.<br />
-    /// 使用缓存的键值对来快速读写。
-    /// </summary>
-    public interface ICache
-    {
-        /// <summary>
-        /// Synchronization method: Obtain the corresponding value by key.<br />
-        /// 同步方法：根据键获取对应的值。
-        /// </summary>
-        /// <param name="key">Key<br />键</param>
-        /// <returns>Value<br />值</returns>
-        string GetByKey(string key);
-
-        /// <summary>
-        /// Asynchronous method: Obtains the corresponding value based on the key.<br />
-        /// 异步方法：根据键获取对应的值。
-        /// </summary>
-        /// <param name="key">Key<br />键</param>
-        /// <returns>Value<br />值</returns>
-        Task<string> GetByKeyAsync(string key);
-
-        /// <summary>
-        /// Synchronization method: Obtains one or more keys according to the value.<br />
-        /// 同步方法：根据值获取对应的一个或多个键。
-        /// </summary>
-        /// <param name="value">Value<br />值</param>
-        /// <returns>Key (List)<br />键 (List)</returns>
-        List<string> GetKeysByValue(string value);
-
-        /// <summary>
-        /// Asynchronous method: Get one or more keys based on the value.<br />
-        /// 异步方法：根据值获取对应的一个或多个键。
-        /// </summary>
-        /// <param name="value">Value<br />值</param>
-        /// <returns>Key (List)<br />键 (List)</returns>
-        Task<List<string>> GetKeysByValueAsync(string value);
-
-        /// <summary>
-        /// Set a key-value pair.<br />
-        /// 设置一个键值对。
-        /// </summary>
-        /// <param name="key">Key<br />键</param>
-        /// <param name="value">Value<br />值</param>
-        /// <returns>Whether the Settings are successful.<br />是否设置成功。</returns>
-        bool Set(string key, string value);
-
-        /// <summary>
-        /// Set a key-value pair.<br />
-        /// 设置一个键值对。
-        /// </summary>
-        /// <param name="key">Key<br />键</param>
-        /// <param name="value">Value<br />值</param>
-        /// <returns>Whether the Settings are successful.<br />是否设置成功。</returns>
-        Task<bool> SetAsync(string key, string value);
-
-        /// <summary>
-        /// Remove a key-value pair.<br />
-        /// 移除一个键值对。
-        /// </summary>
-        /// <param name="key">Key<br />键</param>
-        /// <returns>Whether the removal was successful or not.<br />是否移除成功。</returns>
-        bool RemoveByKey(string key);
-
-        /// <summary>
-        /// Remove a key-value pair.<br />
-        /// 移除一个键值对。
-        /// </summary>
-        /// <param name="key">Key<br />键</param>
-        /// <returns>Whether the removal was successful or not.<br />是否移除成功。</returns>
-        Task<bool> RemoveByKeyAsync(string key);
-
-        /// <summary>
-        /// Clear the cache.<br />
-        /// 清空缓存。
-        /// </summary>
-        void Clear();
-
-        /// <summary>
-        /// Clear the cache.<br />
-        /// 清空缓存。
-        /// </summary>
-        Task ClearAsync();
-
-        /// <summary>
-        /// Gets all key-value pairs.<br />
-        /// 获取所有的键值对。
-        /// </summary>
-        /// <returns>Key-value pair<br />键值对</returns>
-        Dictionary<string, string> GetAllCache();
-
-        /// <summary>
-        /// Gets all key-value pairs.<br />
-        /// 获取所有的键值对。
-        /// </summary>
-        /// <returns>Key-value pair<br />键值对</returns>
-        Task<Dictionary<string, string>> GetAllCacheAsync();
-    }
-}
diff --git a/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlBooleanDictionary.cs b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlBooleanDictionary.cs
new file mode 100644
index 0000000..6e41075
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlBooleanDictionary.cs
@@ -0,0 +1,291 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.SemaphoreThreadLock
+{
+    /// <summary>
+    /// Use semaphore based thread locks to achieve high concurrency stability.<br />
+    /// 使用基于信号量的线程锁来实现高并发的稳定性。
+    /// </summary>
+    public class StlBooleanDictionary
+    {
+        private readonly Dictionary<string, bool> keyValueDict;   // 存储键->值映射
+        private readonly Dictionary<bool, HashSet<string>> valueKeyDict; // 存储值->键的映射
+        private readonly SemaphoreSlim semaphore;  // 控制并发访问
+
+        /// <summary>
+        /// Use cached key-value pairs for fast reads and writes.<br />
+        /// 使用缓存的键值对来快速读写。
+        /// </summary>
+        public StlBooleanDictionary()
+        {
+            keyValueDict = new Dictionary<string, bool>();
+            valueKeyDict = new Dictionary<bool, HashSet<string>>();
+            semaphore = new SemaphoreSlim(1, 1);  // 使用信号量来同步
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual bool GetByKey(string key)
+        {
+            lock (semaphore)
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtains the corresponding value based on the key.<br />
+        /// 异步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<bool> GetByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtains one or more keys according to the value.<br />
+        /// 同步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual List<string> GetKeysByValue(bool value)
+        {
+            lock (semaphore)
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Get one or more keys based on the value.<br />
+        /// 异步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(bool value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual bool Set(string key, bool value)
+        {
+            lock (semaphore)
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual async Task<bool> SetAsync(string key, bool value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual bool RemoveByKey(string key)
+        {
+            lock (semaphore)
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual void Clear()
+        {
+            lock (semaphore)
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual async void ClearAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual Dictionary<string, bool> GetAllCache()
+        {
+            lock (semaphore)
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, bool>(keyValueDict);
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual async Task<Dictionary<string, bool>> GetAllCacheAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, bool>(keyValueDict);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlCharDictionary.cs b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlCharDictionary.cs
new file mode 100644
index 0000000..c2695e1
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlCharDictionary.cs
@@ -0,0 +1,291 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.SemaphoreThreadLock
+{
+    /// <summary>
+    /// Use semaphore based thread locks to achieve high concurrency stability.<br />
+    /// 使用基于信号量的线程锁来实现高并发的稳定性。
+    /// </summary>
+    public class StlCharDictionary
+    {
+        private readonly Dictionary<string, char> keyValueDict;   // 存储键->值映射
+        private readonly Dictionary<char, HashSet<string>> valueKeyDict; // 存储值->键的映射
+        private readonly SemaphoreSlim semaphore;  // 控制并发访问
+
+        /// <summary>
+        /// Use cached key-value pairs for fast reads and writes.<br />
+        /// 使用缓存的键值对来快速读写。
+        /// </summary>
+        public StlCharDictionary()
+        {
+            keyValueDict = new Dictionary<string, char>();
+            valueKeyDict = new Dictionary<char, HashSet<string>>();
+            semaphore = new SemaphoreSlim(1, 1);  // 使用信号量来同步
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual char GetByKey(string key)
+        {
+            lock (semaphore)
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtains the corresponding value based on the key.<br />
+        /// 异步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<char> GetByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtains one or more keys according to the value.<br />
+        /// 同步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual List<string> GetKeysByValue(char value)
+        {
+            lock (semaphore)
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Get one or more keys based on the value.<br />
+        /// 异步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(char value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual bool Set(string key, char value)
+        {
+            lock (semaphore)
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual async Task<bool> SetAsync(string key, char value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual bool RemoveByKey(string key)
+        {
+            lock (semaphore)
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual void Clear()
+        {
+            lock (semaphore)
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual async void ClearAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual Dictionary<string, char> GetAllCache()
+        {
+            lock (semaphore)
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, char>(keyValueDict);
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual async Task<Dictionary<string, char>> GetAllCacheAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, char>(keyValueDict);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlDecimalDictionary.cs b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlDecimalDictionary.cs
new file mode 100644
index 0000000..ebd14bd
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlDecimalDictionary.cs
@@ -0,0 +1,291 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.SemaphoreThreadLock
+{
+    /// <summary>
+    /// Use semaphore based thread locks to achieve high concurrency stability.<br />
+    /// 使用基于信号量的线程锁来实现高并发的稳定性。
+    /// </summary>
+    public class StlDecimalDictionary
+    {
+        private readonly Dictionary<string, decimal> keyValueDict;   // 存储键->值映射
+        private readonly Dictionary<decimal, HashSet<string>> valueKeyDict; // 存储值->键的映射
+        private readonly SemaphoreSlim semaphore;  // 控制并发访问
+
+        /// <summary>
+        /// Use cached key-value pairs for fast reads and writes.<br />
+        /// 使用缓存的键值对来快速读写。
+        /// </summary>
+        public StlDecimalDictionary()
+        {
+            keyValueDict = new Dictionary<string, decimal>();
+            valueKeyDict = new Dictionary<decimal, HashSet<string>>();
+            semaphore = new SemaphoreSlim(1, 1);  // 使用信号量来同步
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual decimal GetByKey(string key)
+        {
+            lock (semaphore)
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtains the corresponding value based on the key.<br />
+        /// 异步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<decimal> GetByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtains one or more keys according to the value.<br />
+        /// 同步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual List<string> GetKeysByValue(decimal value)
+        {
+            lock (semaphore)
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Get one or more keys based on the value.<br />
+        /// 异步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(decimal value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual bool Set(string key, decimal value)
+        {
+            lock (semaphore)
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual async Task<bool> SetAsync(string key, decimal value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual bool RemoveByKey(string key)
+        {
+            lock (semaphore)
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual void Clear()
+        {
+            lock (semaphore)
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual async void ClearAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual Dictionary<string, decimal> GetAllCache()
+        {
+            lock (semaphore)
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, decimal>(keyValueDict);
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual async Task<Dictionary<string, decimal>> GetAllCacheAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, decimal>(keyValueDict);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlDoubleDictionary.cs b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlDoubleDictionary.cs
new file mode 100644
index 0000000..a2b624d
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlDoubleDictionary.cs
@@ -0,0 +1,291 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.SemaphoreThreadLock
+{
+    /// <summary>
+    /// Use semaphore based thread locks to achieve high concurrency stability.<br />
+    /// 使用基于信号量的线程锁来实现高并发的稳定性。
+    /// </summary>
+    public class StlDoubleDictionary
+    {
+        private readonly Dictionary<string, double> keyValueDict;   // 存储键->值映射
+        private readonly Dictionary<double, HashSet<string>> valueKeyDict; // 存储值->键的映射
+        private readonly SemaphoreSlim semaphore;  // 控制并发访问
+
+        /// <summary>
+        /// Use cached key-value pairs for fast reads and writes.<br />
+        /// 使用缓存的键值对来快速读写。
+        /// </summary>
+        public StlDoubleDictionary()
+        {
+            keyValueDict = new Dictionary<string, double>();
+            valueKeyDict = new Dictionary<double, HashSet<string>>();
+            semaphore = new SemaphoreSlim(1, 1);  // 使用信号量来同步
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual double GetByKey(string key)
+        {
+            lock (semaphore)
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtains the corresponding value based on the key.<br />
+        /// 异步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<double> GetByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtains one or more keys according to the value.<br />
+        /// 同步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual List<string> GetKeysByValue(double value)
+        {
+            lock (semaphore)
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Get one or more keys based on the value.<br />
+        /// 异步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(double value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual bool Set(string key, double value)
+        {
+            lock (semaphore)
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual async Task<bool> SetAsync(string key, double value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual bool RemoveByKey(string key)
+        {
+            lock (semaphore)
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual void Clear()
+        {
+            lock (semaphore)
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual async void ClearAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual Dictionary<string, double> GetAllCache()
+        {
+            lock (semaphore)
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, double>(keyValueDict);
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual async Task<Dictionary<string, double>> GetAllCacheAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, double>(keyValueDict);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlFloatDictionary.cs b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlFloatDictionary.cs
new file mode 100644
index 0000000..e746d61
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlFloatDictionary.cs
@@ -0,0 +1,291 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.SemaphoreThreadLock
+{
+    /// <summary>
+    /// Use semaphore based thread locks to achieve high concurrency stability.<br />
+    /// 使用基于信号量的线程锁来实现高并发的稳定性。
+    /// </summary>
+    public class StlFloatDictionary
+    {
+        private readonly Dictionary<string, float> keyValueDict;   // 存储键->值映射
+        private readonly Dictionary<float, HashSet<string>> valueKeyDict; // 存储值->键的映射
+        private readonly SemaphoreSlim semaphore;  // 控制并发访问
+
+        /// <summary>
+        /// Use cached key-value pairs for fast reads and writes.<br />
+        /// 使用缓存的键值对来快速读写。
+        /// </summary>
+        public StlFloatDictionary()
+        {
+            keyValueDict = new Dictionary<string, float>();
+            valueKeyDict = new Dictionary<float, HashSet<string>>();
+            semaphore = new SemaphoreSlim(1, 1);  // 使用信号量来同步
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual float GetByKey(string key)
+        {
+            lock (semaphore)
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtains the corresponding value based on the key.<br />
+        /// 异步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<float> GetByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtains one or more keys according to the value.<br />
+        /// 同步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual List<string> GetKeysByValue(float value)
+        {
+            lock (semaphore)
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Get one or more keys based on the value.<br />
+        /// 异步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(float value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual bool Set(string key, float value)
+        {
+            lock (semaphore)
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual async Task<bool> SetAsync(string key, float value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual bool RemoveByKey(string key)
+        {
+            lock (semaphore)
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual void Clear()
+        {
+            lock (semaphore)
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual async void ClearAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual Dictionary<string, float> GetAllCache()
+        {
+            lock (semaphore)
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, float>(keyValueDict);
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual async Task<Dictionary<string, float>> GetAllCacheAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, float>(keyValueDict);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlIntegerDictionary.cs b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlIntegerDictionary.cs
new file mode 100644
index 0000000..b2e458d
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlIntegerDictionary.cs
@@ -0,0 +1,291 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.SemaphoreThreadLock
+{
+    /// <summary>
+    /// Use semaphore based thread locks to achieve high concurrency stability.<br />
+    /// 使用基于信号量的线程锁来实现高并发的稳定性。
+    /// </summary>
+    public class StlIntegerDictionary
+    {
+        private readonly Dictionary<string, int> keyValueDict;   // 存储键->值映射
+        private readonly Dictionary<int, HashSet<string>> valueKeyDict; // 存储值->键的映射
+        private readonly SemaphoreSlim semaphore;  // 控制并发访问
+
+        /// <summary>
+        /// Use cached key-value pairs for fast reads and writes.<br />
+        /// 使用缓存的键值对来快速读写。
+        /// </summary>
+        public StlIntegerDictionary()
+        {
+            keyValueDict = new Dictionary<string, int>();
+            valueKeyDict = new Dictionary<int, HashSet<string>>();
+            semaphore = new SemaphoreSlim(1, 1);  // 使用信号量来同步
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual int GetByKey(string key)
+        {
+            lock (semaphore)
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtains the corresponding value based on the key.<br />
+        /// 异步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<int> GetByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtains one or more keys according to the value.<br />
+        /// 同步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual List<string> GetKeysByValue(int value)
+        {
+            lock (semaphore)
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Get one or more keys based on the value.<br />
+        /// 异步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(int value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual bool Set(string key, int value)
+        {
+            lock (semaphore)
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual async Task<bool> SetAsync(string key, int value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual bool RemoveByKey(string key)
+        {
+            lock (semaphore)
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual void Clear()
+        {
+            lock (semaphore)
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual async void ClearAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual Dictionary<string, int> GetAllCache()
+        {
+            lock (semaphore)
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, int>(keyValueDict);
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual async Task<Dictionary<string, int>> GetAllCacheAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, int>(keyValueDict);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlLongDictionary.cs b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlLongDictionary.cs
new file mode 100644
index 0000000..91e7572
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlLongDictionary.cs
@@ -0,0 +1,291 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.SemaphoreThreadLock
+{
+    /// <summary>
+    /// Use semaphore based thread locks to achieve high concurrency stability.<br />
+    /// 使用基于信号量的线程锁来实现高并发的稳定性。
+    /// </summary>
+    public class StlLongDictionary
+    {
+        private readonly Dictionary<string, long> keyValueDict;   // 存储键->值映射
+        private readonly Dictionary<long, HashSet<string>> valueKeyDict; // 存储值->键的映射
+        private readonly SemaphoreSlim semaphore;  // 控制并发访问
+
+        /// <summary>
+        /// Use cached key-value pairs for fast reads and writes.<br />
+        /// 使用缓存的键值对来快速读写。
+        /// </summary>
+        public StlLongDictionary()
+        {
+            keyValueDict = new Dictionary<string, long>();
+            valueKeyDict = new Dictionary<long, HashSet<string>>();
+            semaphore = new SemaphoreSlim(1, 1);  // 使用信号量来同步
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual long GetByKey(string key)
+        {
+            lock (semaphore)
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtains the corresponding value based on the key.<br />
+        /// 异步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<long> GetByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtains one or more keys according to the value.<br />
+        /// 同步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual List<string> GetKeysByValue(long value)
+        {
+            lock (semaphore)
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Get one or more keys based on the value.<br />
+        /// 异步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(long value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual bool Set(string key, long value)
+        {
+            lock (semaphore)
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual async Task<bool> SetAsync(string key, long value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual bool RemoveByKey(string key)
+        {
+            lock (semaphore)
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual void Clear()
+        {
+            lock (semaphore)
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual async void ClearAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual Dictionary<string, long> GetAllCache()
+        {
+            lock (semaphore)
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, long>(keyValueDict);
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual async Task<Dictionary<string, long>> GetAllCacheAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, long>(keyValueDict);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlShortDictionary.cs b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlShortDictionary.cs
new file mode 100644
index 0000000..0e74faf
--- /dev/null
+++ b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlShortDictionary.cs
@@ -0,0 +1,291 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace TYLDDB.Utils.FastCache.SemaphoreThreadLock
+{
+    /// <summary>
+    /// Use semaphore based thread locks to achieve high concurrency stability.<br />
+    /// 使用基于信号量的线程锁来实现高并发的稳定性。
+    /// </summary>
+    public class StlShortDictionary
+    {
+        private readonly Dictionary<string, short> keyValueDict;   // 存储键->值映射
+        private readonly Dictionary<short, HashSet<string>> valueKeyDict; // 存储值->键的映射
+        private readonly SemaphoreSlim semaphore;  // 控制并发访问
+
+        /// <summary>
+        /// Use cached key-value pairs for fast reads and writes.<br />
+        /// 使用缓存的键值对来快速读写。
+        /// </summary>
+        public StlShortDictionary()
+        {
+            keyValueDict = new Dictionary<string, short>();
+            valueKeyDict = new Dictionary<short, HashSet<string>>();
+            semaphore = new SemaphoreSlim(1, 1);  // 使用信号量来同步
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtain the corresponding value by key.<br />
+        /// 同步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual short GetByKey(string key)
+        {
+            lock (semaphore)
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Obtains the corresponding value based on the key.<br />
+        /// 异步方法：根据键获取对应的值。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Value<br />值</returns>
+        public virtual async Task<short> GetByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.TryGetValue(key, out var value);
+                return value;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Synchronization method: Obtains one or more keys according to the value.<br />
+        /// 同步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual List<string> GetKeysByValue(short value)
+        {
+            lock (semaphore)
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+        }
+
+        /// <summary>
+        /// Asynchronous method: Get one or more keys based on the value.<br />
+        /// 异步方法：根据值获取对应的一个或多个键。
+        /// </summary>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Key (List)<br />键 (List)</returns>
+        public virtual async Task<List<string>> GetKeysByValueAsync(short value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    return valueKeyDict[value].ToList();
+                }
+                return new List<string>();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual bool Set(string key, short value)
+        {
+            lock (semaphore)
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Set a key-value pair.<br />
+        /// 设置一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <param name="value">Value<br />值</param>
+        /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
+        public virtual async Task<bool> SetAsync(string key, short value)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (keyValueDict.ContainsKey(key))
+                {
+                    return false; // 键已存在，不允许重复的键
+                }
+
+                keyValueDict[key] = value;
+
+                if (!valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value] = new HashSet<string>();
+                }
+                valueKeyDict[value].Add(key);
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual bool RemoveByKey(string key)
+        {
+            lock (semaphore)
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
+        /// </summary>
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key)
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                if (!keyValueDict.ContainsKey(key))
+                {
+                    return false;
+                }
+                var value = keyValueDict[key];
+                keyValueDict.Remove(key);
+
+                if (valueKeyDict.ContainsKey(value))
+                {
+                    valueKeyDict[value].Remove(key);
+                    if (valueKeyDict[value].Count == 0)
+                    {
+                        valueKeyDict.Remove(value);
+                    }
+                }
+                return true;
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual void Clear()
+        {
+            lock (semaphore)
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Empty the cache.<br />
+        /// 清空缓存。
+        /// </summary>
+        public virtual async void ClearAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                keyValueDict.Clear();
+                valueKeyDict.Clear();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual Dictionary<string, short> GetAllCache()
+        {
+            lock (semaphore)
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, short>(keyValueDict);
+            }
+        }
+
+        /// <summary>
+        /// Gets all key-value pairs.<br />
+        /// 获取所有的键值对。
+        /// </summary>
+        /// <returns>Key-value pair<br />键值对</returns>
+        public virtual async Task<Dictionary<string, short>> GetAllCacheAsync()
+        {
+            await semaphore.WaitAsync();
+            try
+            {
+                // 返回完整的键值对字典
+                return new Dictionary<string, short>(keyValueDict);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        }
+    }
+}
diff --git a/TYLDDB/Utils/FastCache/SemaphoreThreadLock.cs b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlStringDictionary.cs
similarity index 84%
rename from TYLDDB/Utils/FastCache/SemaphoreThreadLock.cs
rename to TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlStringDictionary.cs
index c7ff0a5..09bc308 100644
--- a/TYLDDB/Utils/FastCache/SemaphoreThreadLock.cs
+++ b/TYLDDB/Utils/FastCache/SemaphoreThreadLock/StlStringDictionary.cs
@@ -3,13 +3,13 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace TYLDDB.Utils.FastCache
+namespace TYLDDB.Utils.FastCache.SemaphoreThreadLock
 {
     /// <summary>
     /// Use semaphore based thread locks to achieve high concurrency stability.<br />
     /// 使用基于信号量的线程锁来实现高并发的稳定性。
     /// </summary>
-    public class SemaphoreThreadLock : Cache
+    public class StlStringDictionary
     {
         private readonly Dictionary<string, string> keyValueDict;   // 存储键->值映射
         private readonly Dictionary<string, HashSet<string>> valueKeyDict; // 存储值->键的映射
@@ -19,7 +19,7 @@ public class SemaphoreThreadLock : Cache
         /// Use cached key-value pairs for fast reads and writes.<br />
         /// 使用缓存的键值对来快速读写。
         /// </summary>
-        public SemaphoreThreadLock()
+        public StlStringDictionary()
         {
             keyValueDict = new Dictionary<string, string>();
             valueKeyDict = new Dictionary<string, HashSet<string>>();
@@ -32,7 +32,7 @@ public SemaphoreThreadLock()
         /// </summary>
         /// <param name="key">Key<br />键</param>
         /// <returns>Value<br />值</returns>
-        public override string GetByKey(string key)
+        public virtual string GetByKey(string key)
         {
             lock (semaphore)
             {
@@ -47,7 +47,7 @@ public override string GetByKey(string key)
         /// </summary>
         /// <param name="key">Key<br />键</param>
         /// <returns>Value<br />值</returns>
-        public override async Task<string> GetByKeyAsync(string key)
+        public virtual async Task<string> GetByKeyAsync(string key)
         {
             await semaphore.WaitAsync();
             try
@@ -67,7 +67,7 @@ public override async Task<string> GetByKeyAsync(string key)
         /// </summary>
         /// <param name="value">Value<br />值</param>
         /// <returns>Key (List)<br />键 (List)</returns>
-        public override List<string> GetKeysByValue(string value)
+        public virtual List<string> GetKeysByValue(string value)
         {
             lock (semaphore)
             {
@@ -85,7 +85,7 @@ public override List<string> GetKeysByValue(string value)
         /// </summary>
         /// <param name="value">Value<br />值</param>
         /// <returns>Key (List)<br />键 (List)</returns>
-        public override async Task<List<string>> GetKeysByValueAsync(string value)
+        public virtual async Task<List<string>> GetKeysByValueAsync(string value)
         {
             await semaphore.WaitAsync();
             try
@@ -109,7 +109,7 @@ public override async Task<List<string>> GetKeysByValueAsync(string value)
         /// <param name="key">Key<br />键</param>
         /// <param name="value">Value<br />值</param>
         /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
-        public override bool Set(string key, string value)
+        public virtual bool Set(string key, string value)
         {
             lock (semaphore)
             {
@@ -136,7 +136,7 @@ public override bool Set(string key, string value)
         /// <param name="key">Key<br />键</param>
         /// <param name="value">Value<br />值</param>
         /// <returns>Whether the Settings are successful.<br />是否设置成功</returns>
-        public override async Task<bool> SetAsync(string key, string value)
+        public virtual async Task<bool> SetAsync(string key, string value)
         {
             await semaphore.WaitAsync();
             try
@@ -162,11 +162,12 @@ public override async Task<bool> SetAsync(string key, string value)
         }
 
         /// <summary>
-        /// 同步方法：移除一个键值对。
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
         /// </summary>
-        /// <param name="key"></param>
-        /// <returns></returns>
-        public override bool RemoveByKey(string key)
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual bool RemoveByKey(string key)
         {
             lock (semaphore)
             {
@@ -190,11 +191,12 @@ public override bool RemoveByKey(string key)
         }
 
         /// <summary>
-        /// 异步方法：移除一个键值对。
+        /// Remove a key-value pair.<br />
+        /// 移除一个键值对。
         /// </summary>
-        /// <param name="key"></param>
-        /// <returns></returns>
-        public override async Task<bool> RemoveByKeyAsync(string key)
+        /// <param name="key">Key<br />键</param>
+        /// <returns>Check whether the removal is successful.<br />是否移除成功。</returns>
+        public virtual async Task<bool> RemoveByKeyAsync(string key)
         {
             await semaphore.WaitAsync();
             try
@@ -223,9 +225,10 @@ public override async Task<bool> RemoveByKeyAsync(string key)
         }
 
         /// <summary>
-        /// 同步方法：清空缓存。
+        /// Empty the cache.<br />
+        /// 清空缓存。
         /// </summary>
-        public override void Clear()
+        public virtual void Clear()
         {
             lock (semaphore)
             {
@@ -235,10 +238,10 @@ public override void Clear()
         }
 
         /// <summary>
-        /// 异步方法：清空缓存。
+        /// Empty the cache.<br />
+        /// 清空缓存。
         /// </summary>
-        /// <returns></returns>
-        public override async Task ClearAsync()
+        public virtual async void ClearAsync()
         {
             await semaphore.WaitAsync();
             try
@@ -257,7 +260,7 @@ public override async Task ClearAsync()
         /// 获取所有的键值对。
         /// </summary>
         /// <returns>Key-value pair<br />键值对</returns>
-        public override Dictionary<string, string> GetAllCache()
+        public virtual Dictionary<string, string> GetAllCache()
         {
             lock (semaphore)
             {
@@ -271,7 +274,7 @@ public override Dictionary<string, string> GetAllCache()
         /// 获取所有的键值对。
         /// </summary>
         /// <returns>Key-value pair<br />键值对</returns>
-        public override async Task<Dictionary<string, string>> GetAllCacheAsync()
+        public virtual async Task<Dictionary<string, string>> GetAllCacheAsync()
         {
             await semaphore.WaitAsync();
             try
diff --git a/TimeRecord/TimeRecord.csproj b/TimeRecord/TimeRecord.csproj
index fa71b7a..58f574d 100644
--- a/TimeRecord/TimeRecord.csproj
+++ b/TimeRecord/TimeRecord.csproj
@@ -6,4 +6,12 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+<<<<<<<< HEAD:TimeRecord/TimeRecord.csproj
+========
+  <ItemGroup>
+    <ProjectReference Include="..\TimeRecord\TimeRecord.csproj" />
+    <ProjectReference Include="..\TYLDDB\TYLDDB.csproj" />
+  </ItemGroup>
+
+>>>>>>>> cdf9c1039cfeae32fce9aac87ceb4ce2409ec22d:TYLDDB.Utils.FastCache.Test/TYLDDB.Utils.FastCache.Test.csproj
 </Project>