From 05626e014c1696624223b364853b14d4308a69dd Mon Sep 17 00:00:00 2001 From: billhong Date: Mon, 11 Sep 2023 18:02:40 +0800 Subject: [PATCH 1/4] fix: LockMs/SleepMs only for TiSvc --- build/version.props | 8 +-- .../DefaultCSRedisCachingProvider.Async.cs | 4 ++ .../EasyCachingAbstractProvider.cs | 61 ++++++++++++++++ .../IEasyCachingProviderBase.cs | 11 +++ .../DefaultDiskCachingProvider.Async.cs | 6 +- .../DefaultFasterKvCachingProvider.Async.cs | 4 ++ .../HybridCachingProvider.cs | 69 +++++++++---------- .../DefaultInMemoryCachingProvider.Async.cs | 55 +++++++++++++++ .../DefaultLiteDBCachingProvider.Async.cs | 4 ++ .../DefaultMemcachedCachingProvider.Async.cs | 4 ++ .../DefaultRedisCachingProvider.Async.cs | 47 +++++++++++++ .../DefaultSQLiteCachingProvider.Async.cs | 4 ++ .../Diagnostics/MyCachingProvider.cs | 5 ++ .../Fake/FakeDistributedCachingProvider.cs | 5 ++ .../Fake/FakeLocalCachingProvider.cs | 5 ++ 15 files changed, 252 insertions(+), 40 deletions(-) diff --git a/build/version.props b/build/version.props index 5dc47ec6..05918071 100644 --- a/build/version.props +++ b/build/version.props @@ -1,11 +1,11 @@ - 1.9.1 + 1.9.2 1.9.1 - 1.9.1 + 1.9.2 1.9.1 - 1.9.1 - 1.9.1 + 1.9.2 + 1.9.2 1.9.1 1.9.1 1.9.1 diff --git a/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs b/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs index b3c2ad34..0ed0ebdb 100644 --- a/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs +++ b/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs @@ -10,6 +10,10 @@ public partial class DefaultCSRedisCachingProvider : EasyCachingAbstractProvider { + public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } /// /// Existses the async. /// diff --git a/src/EasyCaching.Core/EasyCachingAbstractProvider.cs b/src/EasyCaching.Core/EasyCachingAbstractProvider.cs index b4985128..ae678b31 100644 --- a/src/EasyCaching.Core/EasyCachingAbstractProvider.cs +++ b/src/EasyCaching.Core/EasyCachingAbstractProvider.cs @@ -54,6 +54,7 @@ protected EasyCachingAbstractProvider(IDistributedLockFactory lockFactory, BaseP public abstract IDictionary> BaseGetAll(IEnumerable cacheKeys); public abstract Task>> BaseGetAllAsync(IEnumerable cacheKeys, CancellationToken cancellationToken = default); public abstract Task> BaseGetAsync(string cacheKey, Func> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default); + public abstract Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default); public abstract Task BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default); public abstract Task> BaseGetAsync(string cacheKey, CancellationToken cancellationToken = default); public abstract IDictionary> BaseGetByPrefix(string prefix); @@ -363,6 +364,66 @@ public async Task>> GetAllAsync(IEnumerable } } + public async Task> GetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(GetAsync), new[] { cacheKey })); + Exception e = null; + try + { + if (_lockFactory == null) return await BaseGetAsync(cacheKey, dataRetriever, expirationRetriever, cancellationToken); + + var value = await BaseGetAsync(cacheKey, cancellationToken); + if (value.HasValue) return value; + + var @lock = _lockFactory.CreateLock(Name, $"{cacheKey}_Lock"); + try + { + if (!await @lock.LockAsync(_options.SleepMs, cancellationToken)) throw new TimeoutException(); + + value = await BaseGetAsync(cacheKey, cancellationToken); + if (value.HasValue) return value; + + var task = dataRetriever(); + if (!task.IsCompleted && + await Task.WhenAny(task, Task.Delay(_options.LockMs, cancellationToken)) != task) + throw new TimeoutException(); + + var item = await task; + if (item != null || _options.CacheNulls) + { + TimeSpan expiration = await expirationRetriever(); + await BaseSetAsync(cacheKey, item, expiration, cancellationToken); + + return new CacheValue(item, true); + } + else + { + return CacheValue.NoValue; + } + } + finally + { + await @lock.DisposeAsync(); + } + } + catch (Exception ex) + { + e = ex; + throw; + } + finally + { + if (e != null) + { + s_diagnosticListener.WriteGetCacheError(operationId, e); + } + else + { + s_diagnosticListener.WriteGetCacheAfter(operationId); + } + } + } + public async Task> GetAsync(string cacheKey, Func> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default) { var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(GetAsync), new[] { cacheKey }, expiration)); diff --git a/src/EasyCaching.Core/IEasyCachingProviderBase.cs b/src/EasyCaching.Core/IEasyCachingProviderBase.cs index 3c431f21..a311dfa4 100644 --- a/src/EasyCaching.Core/IEasyCachingProviderBase.cs +++ b/src/EasyCaching.Core/IEasyCachingProviderBase.cs @@ -153,6 +153,17 @@ public interface IEasyCachingProviderBase /// The 1st type parameter. Task> GetAsync(string cacheKey, Func> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default); + /// + /// Gets the specified cacheKey, dataRetriever and expirationRetriever async. + /// + /// The async. + /// Cache key. + /// Data retriever. + /// Expiration retriever. + /// + /// The 1st type parameter. + Task> GetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default); + /// /// Removes cached item by cachekey's prefix. /// diff --git a/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs b/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs index b7908e83..7c1ca908 100644 --- a/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs +++ b/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs @@ -10,7 +10,11 @@ using Microsoft.Extensions.Logging; public partial class DefaultDiskCachingProvider : EasyCachingAbstractProvider - { + { + public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } public override async Task BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default) { ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); diff --git a/src/EasyCaching.FasterKv/DefaultFasterKvCachingProvider.Async.cs b/src/EasyCaching.FasterKv/DefaultFasterKvCachingProvider.Async.cs index c3b04e37..309c188d 100644 --- a/src/EasyCaching.FasterKv/DefaultFasterKvCachingProvider.Async.cs +++ b/src/EasyCaching.FasterKv/DefaultFasterKvCachingProvider.Async.cs @@ -9,6 +9,10 @@ namespace EasyCaching.FasterKv { public partial class DefaultFasterKvCachingProvider { + public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } public override async Task BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default) { ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); diff --git a/src/EasyCaching.HybridCache/HybridCachingProvider.cs b/src/EasyCaching.HybridCache/HybridCachingProvider.cs index 0d63644a..a0614f3d 100644 --- a/src/EasyCaching.HybridCache/HybridCachingProvider.cs +++ b/src/EasyCaching.HybridCache/HybridCachingProvider.cs @@ -304,42 +304,26 @@ public CacheValue Get(string cacheKey) public async Task> GetAsync(string cacheKey, CancellationToken cancellationToken = default) { ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); - - var cacheValue = await _localCache.GetAsync(cacheKey, cancellationToken); - - if (cacheValue.HasValue) - { - return cacheValue; - } - - LogMessage($"local cache can not get the value of {cacheKey}"); - - try - { - cacheValue = await _distributedCache.GetAsync(cacheKey, cancellationToken); - } - catch (Exception ex) - { - LogMessage($"distributed cache get error, [{cacheKey}]", ex); - - if (_options.ThrowIfDistributedCacheError) + var result = await _localCache.GetAsync( + cacheKey, + async () => { - throw; - } - } - - if (cacheValue.HasValue) - { - TimeSpan ts = await GetExpirationAsync(cacheKey, cancellationToken); - - await _localCache.SetAsync(cacheKey, cacheValue.Value, ts, cancellationToken); - - return cacheValue; - } - - LogMessage($"distributed cache can not get the value of {cacheKey}"); - - return CacheValue.NoValue; + var value = default(T); + try + { + value = (await _distributedCache.GetAsync(cacheKey, cancellationToken)).Value; + } + catch (Exception ex) + { + LogMessage($"distributed cache get error, [{cacheKey}]", ex); + if (_options.ThrowIfDistributedCacheError) + throw; + } + return value; + }, + () => GetExpirationAsync(cacheKey, cancellationToken), + cancellationToken); + return result; } /// @@ -780,6 +764,21 @@ public async Task> GetAsync(string cacheKey, Func> data return CacheValue.NoValue; } + /// + /// Gets the specified cacheKey, dataRetriever and expirationRetriever async. + /// + /// The async. + /// Cache key. + /// Data retriever. + /// Expiration retriever. + /// + /// The 1st type parameter. + public async Task> GetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + // TiSvc 沒用到，不實作 + throw new NotImplementedException(); + } + /// /// Removes the by prefix. /// diff --git a/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs b/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs index 96b7050e..a18a12b4 100644 --- a/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs +++ b/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs @@ -76,6 +76,61 @@ public override async Task> BaseGetAsync(string cacheKey, Func< } } + public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + + var result = _cache.Get(cacheKey); + if (result.HasValue) + { + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}"); + + CacheStats.OnHit(); + + return result; + } + + CacheStats.OnMiss(); + + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}"); + + if (!_cache.Add($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs))) + { + //wait for some ms + await Task.Delay(_options.SleepMs, cancellationToken); + return await GetAsync(cacheKey, dataRetriever, expirationRetriever, cancellationToken); + } + + try + { + var res = await dataRetriever(); + + if (res != null || _options.CacheNulls) + { + TimeSpan expiration = await expirationRetriever(); + await SetAsync(cacheKey, res, expiration, cancellationToken); + //remove mutex key + _cache.Remove($"{cacheKey}_Lock"); + + return new CacheValue(res, true); + } + else + { + //remove mutex key + _cache.Remove($"{cacheKey}_Lock"); + return CacheValue.NoValue; + } + } + catch + { + //remove mutex key + _cache.Remove($"{cacheKey}_Lock"); + throw; + } + } + /// /// Gets the specified cacheKey async. /// diff --git a/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs b/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs index 466c95fb..97e35905 100644 --- a/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs +++ b/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs @@ -12,6 +12,10 @@ /// public partial class DefaultLiteDBCachingProvider : EasyCachingAbstractProvider { + public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } /// /// Existses the specified cacheKey async. /// diff --git a/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs b/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs index 1d96f1d5..145028b4 100644 --- a/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs +++ b/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs @@ -13,6 +13,10 @@ /// public partial class DefaultMemcachedCachingProvider : EasyCachingAbstractProvider { + public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } /// /// Gets the specified cacheKey, dataRetriever and expiration async. /// diff --git a/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs b/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs index 3604b5df..edd4d50f 100644 --- a/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs +++ b/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs @@ -103,6 +103,53 @@ public override async Task> BaseGetAsync(string cacheKey, Func< } } + public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); + + var result = await _cache.StringGetAsync(cacheKey); + if (!result.IsNull) + { + CacheStats.OnHit(); + + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}"); + + var value = _serializer.Deserialize(result); + return new CacheValue(value, true); + } + + CacheStats.OnMiss(); + + if (_options.EnableLogging) + _logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}"); + + var flag = await _cache.StringSetAsync($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs), When.NotExists); + + if (!flag) + { + await Task.Delay(_options.SleepMs, cancellationToken); + return await GetAsync(cacheKey, dataRetriever, expirationRetriever, cancellationToken); + } + + var item = await dataRetriever(); + if (item != null || _options.CacheNulls) + { + TimeSpan expiration = await expirationRetriever(); + await SetAsync(cacheKey, item, expiration, cancellationToken); + + //remove mutex key + await _cache.KeyDeleteAsync($"{cacheKey}_Lock"); + return new CacheValue(item, true); + } + else + { + //remove mutex key + await _cache.KeyDeleteAsync($"{cacheKey}_Lock"); + return CacheValue.NoValue; + } + } + /// /// Gets the specified cacheKey async. /// diff --git a/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs b/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs index 5463aec2..a4d09f6b 100644 --- a/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs +++ b/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs @@ -14,6 +14,10 @@ /// public partial class DefaultSQLiteCachingProvider : EasyCachingAbstractProvider { + public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } /// /// Existses the specified cacheKey async. /// diff --git a/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs b/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs index 81257398..3efc185c 100644 --- a/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs +++ b/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs @@ -18,6 +18,11 @@ public MyCachingProvider() this.IsDistributedProvider = false; } + public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } + public override bool BaseExists(string cacheKey) { return true; diff --git a/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs b/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs index 67b750dc..820b2412 100644 --- a/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs +++ b/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs @@ -205,5 +205,10 @@ public virtual Task TrySetAsync(string cacheKey, T cacheValue, TimeSpan { return Task.FromResult(true); } + + public Task> GetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } } } diff --git a/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs b/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs index 9638084f..c7cc7606 100644 --- a/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs +++ b/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs @@ -205,5 +205,10 @@ public Task TrySetAsync(string cacheKey, T cacheValue, TimeSpan expirat { return Task.FromResult(true); } + + public Task> GetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) + { + throw new NotImplementedException(); + } } } From acd9eb697cd0d675e73a76e16abae66a0b19103f Mon Sep 17 00:00:00 2001 From: billhong Date: Tue, 12 Sep 2023 17:43:33 +0800 Subject: [PATCH 2/4] =?UTF-8?q?refactor:=20=E9=87=8D=E6=A7=8B=20`BaseGetAs?= =?UTF-8?q?ync`=EF=BC=8C=E9=81=BF=E5=85=8D=20recursive=20=E9=80=A0?= =?UTF-8?q?=E6=88=90=E5=A4=AA=E5=A4=9A=20call=20stack=20=E5=A0=86=E7=96=8A?= =?UTF-8?q?=EF=BC=8C=E6=87=89=E8=A9=B2=E5=8F=AF=E4=BB=A5=E5=84=AA=E5=8C=96?= =?UTF-8?q?=20memory=20=E4=BD=BF=E7=94=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../DefaultInMemoryCachingProvider.Async.cs | 31 ++++++------------- 1 file changed, 9 insertions(+), 22 deletions(-) diff --git a/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs b/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs index a18a12b4..cb8e9367 100644 --- a/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs +++ b/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs @@ -79,30 +79,17 @@ public override async Task> BaseGetAsync(string cacheKey, Func< public override async Task> BaseGetAsync(string cacheKey, Func> dataRetriever, Func> expirationRetriever, CancellationToken cancellationToken = default) { ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey)); - - var result = _cache.Get(cacheKey); - if (result.HasValue) + bool getLock = false; + do { - if (_options.EnableLogging) - _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}"); - - CacheStats.OnHit(); - - return result; + var result = _cache.Get(cacheKey); + if (result.HasValue) + return result; + getLock = _cache.Add($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs)); + if (!getLock) + await Task.Delay(_options.SleepMs, cancellationToken); } - - CacheStats.OnMiss(); - - if (_options.EnableLogging) - _logger?.LogInformation($"Cache Missed : cachekey = {cacheKey}"); - - if (!_cache.Add($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs))) - { - //wait for some ms - await Task.Delay(_options.SleepMs, cancellationToken); - return await GetAsync(cacheKey, dataRetriever, expirationRetriever, cancellationToken); - } - + while (!getLock); try { var res = await dataRetriever(); From 4dac572b0ff4b01abffc15f3e836fa265db2388b Mon Sep 17 00:00:00 2001 From: billhong Date: Wed, 13 Sep 2023 14:34:51 +0800 Subject: [PATCH 3/4] =?UTF-8?q?=E9=87=8D=E5=91=BD=E5=90=8D=20package=20id?= =?UTF-8?q?=EF=BC=8C=E9=81=BF=E5=85=8D=E7=99=BC=E4=BD=88=E5=88=B0=20public?= =?UTF-8?q?=20nuget=20server=20=E6=9C=83=E5=9B=A0=E7=82=BA=E5=92=8C?= =?UTF-8?q?=E5=8E=9F=E6=9C=AC=E7=9A=84=20package=20id=20=E7=9B=B8=E5=90=8C?= =?UTF-8?q?=E8=80=8C=E7=84=A1=E6=B3=95=E7=99=BC=E5=B8=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/EasyCaching.Core/EasyCaching.Core.csproj | 1 + src/EasyCaching.HybridCache/EasyCaching.HybridCache.csproj | 1 + src/EasyCaching.InMemory/EasyCaching.InMemory.csproj | 1 + src/EasyCaching.Redis/EasyCaching.Redis.csproj | 1 + 4 files changed, 4 insertions(+) diff --git a/src/EasyCaching.Core/EasyCaching.Core.csproj b/src/EasyCaching.Core/EasyCaching.Core.csproj index 4e348f6b..d0456da0 100644 --- a/src/EasyCaching.Core/EasyCaching.Core.csproj +++ b/src/EasyCaching.Core/EasyCaching.Core.csproj @@ -24,6 +24,7 @@ true $(NoWarn);1591 + Just.$(MSBuildProjectName) diff --git a/src/EasyCaching.HybridCache/EasyCaching.HybridCache.csproj b/src/EasyCaching.HybridCache/EasyCaching.HybridCache.csproj index 6b6d4436..ea3cdc6f 100644 --- a/src/EasyCaching.HybridCache/EasyCaching.HybridCache.csproj +++ b/src/EasyCaching.HybridCache/EasyCaching.HybridCache.csproj @@ -24,6 +24,7 @@ true $(NoWarn);1591 + Just.$(MSBuildProjectName) diff --git a/src/EasyCaching.InMemory/EasyCaching.InMemory.csproj b/src/EasyCaching.InMemory/EasyCaching.InMemory.csproj index 2d1dd05d..ed91f3cb 100644 --- a/src/EasyCaching.InMemory/EasyCaching.InMemory.csproj +++ b/src/EasyCaching.InMemory/EasyCaching.InMemory.csproj @@ -24,6 +24,7 @@ true $(NoWarn);1591 + Just.$(MSBuildProjectName) diff --git a/src/EasyCaching.Redis/EasyCaching.Redis.csproj b/src/EasyCaching.Redis/EasyCaching.Redis.csproj index 3c526a83..cff76390 100644 --- a/src/EasyCaching.Redis/EasyCaching.Redis.csproj +++ b/src/EasyCaching.Redis/EasyCaching.Redis.csproj @@ -25,6 +25,7 @@ true $(NoWarn);1591 + Just.$(MSBuildProjectName) From 12159e90a00efaf91e465bcc60a6e9d419f04e04 Mon Sep 17 00:00:00 2001 From: billhong Date: Wed, 13 Sep 2023 15:23:10 +0800 Subject: [PATCH 4/4] =?UTF-8?q?=E9=87=8D=E5=91=BD=E5=90=8D=E7=9B=B8?= =?UTF-8?q?=E4=BE=9D=20package=20id=EF=BC=8C=E9=81=BF=E5=85=8D=E5=92=8C?= =?UTF-8?q?=E5=8E=9F=E6=9C=AC=E7=9A=84=20package=20conflict?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bus/EasyCaching.Bus.Redis/EasyCaching.Bus.Redis.csproj | 1 + .../EasyCaching.Serialization.MessagePack.csproj | 1 + 2 files changed, 2 insertions(+) diff --git a/bus/EasyCaching.Bus.Redis/EasyCaching.Bus.Redis.csproj b/bus/EasyCaching.Bus.Redis/EasyCaching.Bus.Redis.csproj index f6f506e2..ee21b19a 100644 --- a/bus/EasyCaching.Bus.Redis/EasyCaching.Bus.Redis.csproj +++ b/bus/EasyCaching.Bus.Redis/EasyCaching.Bus.Redis.csproj @@ -24,6 +24,7 @@ true $(NoWarn);1591 + Just.$(MSBuildProjectName) diff --git a/serialization/EasyCaching.Serialization.MessagePack/EasyCaching.Serialization.MessagePack.csproj b/serialization/EasyCaching.Serialization.MessagePack/EasyCaching.Serialization.MessagePack.csproj index 4584dc3e..0aef35db 100644 --- a/serialization/EasyCaching.Serialization.MessagePack/EasyCaching.Serialization.MessagePack.csproj +++ b/serialization/EasyCaching.Serialization.MessagePack/EasyCaching.Serialization.MessagePack.csproj @@ -24,6 +24,7 @@ true $(NoWarn);1591 + Just.$(MSBuildProjectName)