diff --git a/TYLDDB/TYLDDB.csproj b/TYLDDB/TYLDDB.csproj
index 7a9222e..cd2e836 100644
--- a/TYLDDB/TYLDDB.csproj
+++ b/TYLDDB/TYLDDB.csproj
@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;net6.0;net8.0;net9.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.1;net6.0;net8.0;net9.0</TargetFrameworks>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
-    <Title>TTYPDB.NET</Title>
-    <Version>1.0.0-alpha.2</Version>
+    <Title>TYLDDB.NET</Title>
+    <Version>1.0.0-alpha.2r</Version>
     <Authors>TYLDDB-Project</Authors>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
@@ -19,6 +19,8 @@
     <PackageTags>DataBase</PackageTags>
     <Company>QingYi-Studio</Company>
     <PackageReadmeFile>README.md</PackageReadmeFile>
+    <PackageReleaseNotes>Remove support for .netstandard 2.0.
+Remove direct inheritance/derivation of the ICache interface and instead use abstract class relays, using virtual methods to trim asynchronous code in part of the concurrent dictionary.</PackageReleaseNotes>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/TYLDDB/Utils/FastCache/Cache.cs b/TYLDDB/Utils/FastCache/Cache.cs
index 3551198..dc06ba2 100644
--- a/TYLDDB/Utils/FastCache/Cache.cs
+++ b/TYLDDB/Utils/FastCache/Cache.cs
@@ -1,286 +1,39 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
+using System;
+using System.Collections.Generic;
+using System.Text;
 using System.Threading.Tasks;
 
 namespace TYLDDB.Utils.FastCache
 {
     /// <summary>
-    /// Use cached key-value pairs for fast reads and writes.<br />
-    /// 使用缓存的键值对来快速读写。
+    /// For cached abstract classes, you need to inherit the class to do concrete implementation.<br />
+    /// 对于缓存的抽象类，需要继承该类来做具体实现。
     /// </summary>
-    public class Cache
+    public abstract class Cache : ICache
     {
-        private readonly Dictionary<string, string> keyValueDict;   // 存储键->值映射
-        private readonly Dictionary<string, HashSet<string>> valueKeyDict; // 存储值->键的映射
-        private readonly SemaphoreSlim semaphore;  // 控制并发访问
-
-        /// <summary>
-        /// Use cached key-value pairs for fast reads and writes.<br />
-        /// 使用缓存的键值对来快速读写。
-        /// </summary>
-        public Cache()
-        {
-            keyValueDict = new Dictionary<string, string>();
-            valueKeyDict = new Dictionary<string, 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 string 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 async Task<string> 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 List<string> GetKeysByValue(string 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 async Task<List<string>> GetKeysByValueAsync(string value)
-        {
-            await semaphore.WaitAsync();
-            try
-            {
-                if (valueKeyDict.ContainsKey(value))
-                {
-                    return valueKeyDict[value].ToList();
-                }
-                return new List<string>();
-            }
-            finally
-            {
-                semaphore.Release();
-            }
-        }
-
-        /// <summary>
-        /// 同步方法：设置一个键值对。
-        /// </summary>
-        /// <param name="key"></param>
-        /// <param name="value"></param>
-        /// <returns></returns>
-        public bool Set(string key, string 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>
-        /// 异步方法：设置一个键值对。
-        /// </summary>
-        /// <param name="key"></param>
-        /// <param name="value"></param>
-        /// <returns></returns>
-        public async Task<bool> SetAsync(string key, string 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>
-        /// 同步方法：移除一个键值对。
-        /// </summary>
-        /// <param name="key"></param>
-        /// <returns></returns>
-        public bool RemoveByKey(string key)
-        {
-            lock (semaphore)
-            {
-                if (keyValueDict.ContainsKey(key))
-                {
-                    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;
-                }
-                return false;
-            }
-        }
-
-        /// <summary>
-        /// 异步方法：移除一个键值对。
-        /// </summary>
-        /// <param name="key"></param>
-        /// <returns></returns>
-        public async Task<bool> RemoveByKeyAsync(string key)
-        {
-            await semaphore.WaitAsync();
-            try
-            {
-                if (keyValueDict.ContainsKey(key))
-                {
-                    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;
-                }
-                return false;
-            }
-            finally
-            {
-                semaphore.Release();
-            }
-        }
-
-        /// <summary>
-        /// 同步方法：清空缓存。
-        /// </summary>
-        public void Clear()
-        {
-            lock (semaphore)
-            {
-                keyValueDict.Clear();
-                valueKeyDict.Clear();
-            }
-        }
-
-        /// <summary>
-        /// 异步方法：清空缓存。
-        /// </summary>
-        /// <returns></returns>
-        public async Task 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 Dictionary<string, string> GetAllCache()
-        {
-            lock (semaphore)
-            {
-                // 返回完整的键值对字典
-                return new Dictionary<string, string>(keyValueDict);
-            }
-        }
-
-        /// <summary>
-        /// Gets all key-value pairs.<br />
-        /// 获取所有的键值对。
-        /// </summary>
-        /// <returns>Key-value pair<br />键值对</returns>
-        public async Task<Dictionary<string, string>> GetAllCacheAsync()
-        {
-            await semaphore.WaitAsync();
-            try
-            {
-                // 返回完整的键值对字典
-                return new Dictionary<string, string>(keyValueDict);
-            }
-            finally
-            {
-                semaphore.Release();
-            }
-        }
+        /// <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.cs b/TYLDDB/Utils/FastCache/ConcurrentDictionary.cs
index 55a4d5f..ba98a93 100644
--- a/TYLDDB/Utils/FastCache/ConcurrentDictionary.cs
+++ b/TYLDDB/Utils/FastCache/ConcurrentDictionary.cs
@@ -1,6 +1,5 @@
-using System.Collections.Concurrent;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Threading.Tasks;
 
 namespace TYLDDB.Utils.FastCache
 {
@@ -8,7 +7,7 @@ namespace TYLDDB.Utils.FastCache
     /// Use thread locks based on concurrent dictionaries to achieve high concurrency stability.<br />
     /// 使用基于信号量的线程锁来实现高并发的稳定性。
     /// </summary>
-    public class ConcurrentDictionary : ICache
+    public class ConcurrentDictionary : Cache
     {
         /// <summary>
         /// Thread-safe dictionary to store cache data.<br />
@@ -22,30 +21,19 @@ public class ConcurrentDictionary : ICache
         /// </summary>
         /// <param name="key">Key<br />键</param>
         /// <returns>Value<br />值</returns>
-        public string GetByKey(string key)
+        public override string GetByKey(string key)
         {
             _cache.TryGetValue(key, out var value);
             return value;
         }
 
-        /// <summary>
-        /// Asynchronous method to get the corresponding value by key.<br />
-        /// 异步方法：根据键获取对应的值。
-        /// </summary>
-        /// <param name="key">Key<br />键</param>
-        /// <returns>Value<br />值</returns>
-        public async Task<string> GetByKeyAsync(string key)
-        {
-            return 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 List<string> GetKeysByValue(string value)
+        public override List<string> GetKeysByValue(string value)
         {
             var keys = new List<string>();
             foreach (var kvp in _cache)
@@ -58,17 +46,6 @@ public List<string> GetKeysByValue(string value)
             return keys;
         }
 
-        /// <summary>
-        /// Asynchronous method to 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 async Task<List<string>> GetKeysByValueAsync(string value)
-        {
-            return await Task.FromResult(GetKeysByValue(value));
-        }
-
         /// <summary>
         /// Set a cache entry for a specified key.<br />
         /// 为指定键设置缓存项。
@@ -76,84 +53,35 @@ public async Task<List<string>> GetKeysByValueAsync(string value)
         /// <param name="key">Key<br />键</param>
         /// <param name="value">Value<br />值</param>
         /// <returns>Whether the operation is successful.<br />操作是否成功。</returns>
-        public bool Set(string key, string value)
+        public override 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>
-        /// Asynchronous method to 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 async Task<bool> SetAsync(string key, string value)
-        {
-            return 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 bool RemoveByKey(string key)
+        public override bool RemoveByKey(string key)
         {
             return _cache.TryRemove(key, out _);
         }
 
-        /// <summary>
-        /// Asynchronous method to remove a cache entry by its key.<br />
-        /// 异步方法：根据键移除缓存项。
-        /// </summary>
-        /// <param name="key">Key<br />键</param>
-        /// <returns>Whether the removal is successful.<br />移除操作是否成功。</returns>
-        public async Task<bool> RemoveByKeyAsync(string key)
-        {
-            return await Task.FromResult(RemoveByKey(key));
-        }
-
         /// <summary>
         /// Clear all cache entries.<br />
         /// 清空所有缓存项。
         /// </summary>
-        public void Clear()
-        {
-            _cache.Clear();
-        }
-
-        /// <summary>
-        /// Asynchronous method to clear all cache entries.<br />
-        /// 异步方法：清空所有缓存项。
-        /// </summary>
-        /// <returns>Asynchronous task for clearing.<br />清空操作的异步任务。</returns>
-        public async Task ClearAsync()
-        {
-            await Task.Run(() => Clear());
-        }
+        public override void Clear() => _cache.Clear();
 
         /// <summary>
         /// Get all cache entries as a dictionary.<br />
         /// 获取所有缓存项，返回字典。
         /// </summary>
         /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
-        public Dictionary<string, string> GetAllCache()
-        {
-            return new Dictionary<string, string>(_cache);
-        }
-
-        /// <summary>
-        /// Asynchronous method to get all cache entries as a dictionary.<br />
-        /// 异步方法：获取所有缓存项，返回字典。
-        /// </summary>
-        /// <returns>All cache entries as a dictionary.<br />所有缓存项的字典。</returns>
-        public async Task<Dictionary<string, string>> GetAllCacheAsync()
-        {
-            return await Task.FromResult(GetAllCache());
-        }
+        public override Dictionary<string, string> GetAllCache() => new Dictionary<string, string>(_cache);
     }
 }
diff --git a/TYLDDB/Utils/FastCache/SemaphoreThreadLock.cs b/TYLDDB/Utils/FastCache/SemaphoreThreadLock.cs
index ff661cd..20c9e8f 100644
--- a/TYLDDB/Utils/FastCache/SemaphoreThreadLock.cs
+++ b/TYLDDB/Utils/FastCache/SemaphoreThreadLock.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,7 +9,7 @@ namespace TYLDDB.Utils.FastCache
     /// Use semaphore based thread locks to achieve high concurrency stability.<br />
     /// 使用基于信号量的线程锁来实现高并发的稳定性。
     /// </summary>
-    public class SemaphoreThreadLock : ICache
+    public class SemaphoreThreadLock : Cache
     {
         private readonly Dictionary<string, string> keyValueDict;   // 存储键->值映射
         private readonly Dictionary<string, HashSet<string>> valueKeyDict; // 存储值->键的映射
@@ -32,7 +32,7 @@ public SemaphoreThreadLock()
         /// </summary>
         /// <param name="key">Key<br />键</param>
         /// <returns>Value<br />值</returns>
-        public string GetByKey(string key)
+        public override string GetByKey(string key)
         {
             lock (semaphore)
             {
@@ -47,7 +47,7 @@ public string GetByKey(string key)
         /// </summary>
         /// <param name="key">Key<br />键</param>
         /// <returns>Value<br />值</returns>
-        public async Task<string> GetByKeyAsync(string key)
+        public override async Task<string> GetByKeyAsync(string key)
         {
             await semaphore.WaitAsync();
             try
@@ -67,7 +67,7 @@ public async Task<string> GetByKeyAsync(string key)
         /// </summary>
         /// <param name="value">Value<br />值</param>
         /// <returns>Key (List)<br />键 (List)</returns>
-        public List<string> GetKeysByValue(string value)
+        public override List<string> GetKeysByValue(string value)
         {
             lock (semaphore)
             {
@@ -85,7 +85,7 @@ public List<string> GetKeysByValue(string value)
         /// </summary>
         /// <param name="value">Value<br />值</param>
         /// <returns>Key (List)<br />键 (List)</returns>
-        public async Task<List<string>> GetKeysByValueAsync(string value)
+        public override async Task<List<string>> GetKeysByValueAsync(string value)
         {
             await semaphore.WaitAsync();
             try
@@ -108,7 +108,7 @@ public async Task<List<string>> GetKeysByValueAsync(string value)
         /// <param name="key"></param>
         /// <param name="value"></param>
         /// <returns></returns>
-        public bool Set(string key, string value)
+        public override bool Set(string key, string value)
         {
             lock (semaphore)
             {
@@ -134,7 +134,7 @@ public bool Set(string key, string value)
         /// <param name="key"></param>
         /// <param name="value"></param>
         /// <returns></returns>
-        public async Task<bool> SetAsync(string key, string value)
+        public override async Task<bool> SetAsync(string key, string value)
         {
             await semaphore.WaitAsync();
             try
@@ -164,7 +164,7 @@ public async Task<bool> SetAsync(string key, string value)
         /// </summary>
         /// <param name="key"></param>
         /// <returns></returns>
-        public bool RemoveByKey(string key)
+        public override bool RemoveByKey(string key)
         {
             lock (semaphore)
             {
@@ -192,7 +192,7 @@ public bool RemoveByKey(string key)
         /// </summary>
         /// <param name="key"></param>
         /// <returns></returns>
-        public async Task<bool> RemoveByKeyAsync(string key)
+        public override async Task<bool> RemoveByKeyAsync(string key)
         {
             await semaphore.WaitAsync();
             try
@@ -223,7 +223,7 @@ public async Task<bool> RemoveByKeyAsync(string key)
         /// <summary>
         /// 同步方法：清空缓存。
         /// </summary>
-        public void Clear()
+        public override void Clear()
         {
             lock (semaphore)
             {
@@ -236,7 +236,7 @@ public void Clear()
         /// 异步方法：清空缓存。
         /// </summary>
         /// <returns></returns>
-        public async Task ClearAsync()
+        public override async Task ClearAsync()
         {
             await semaphore.WaitAsync();
             try
@@ -255,7 +255,7 @@ public async Task ClearAsync()
         /// 获取所有的键值对。
         /// </summary>
         /// <returns>Key-value pair<br />键值对</returns>
-        public Dictionary<string, string> GetAllCache()
+        public override Dictionary<string, string> GetAllCache()
         {
             lock (semaphore)
             {
@@ -269,7 +269,7 @@ public Dictionary<string, string> GetAllCache()
         /// 获取所有的键值对。
         /// </summary>
         /// <returns>Key-value pair<br />键值对</returns>
-        public async Task<Dictionary<string, string>> GetAllCacheAsync()
+        public override async Task<Dictionary<string, string>> GetAllCacheAsync()
         {
             await semaphore.WaitAsync();
             try