refactor: 使用抽象类来过渡接口与实现

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>

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));
     }
 }