Added parameter so cache is only used when refreshing the memory cache and we are retrieving a value we know hasn't been updated since the last request.

Author: AndyButland

src/Umbraco.PublishedCache.HybridCache/Persistence/DatabaseCacheRepository.cs

@@ -141,9 +141,14 @@ private void TruncateContent()
     }
 
     /// <inheritdoc/>
+    [Obsolete("Please use the method overload takng all parameters. Scheduled for removal in Umbraco 19.")]
     public async Task<ContentCacheNode?> GetContentSourceAsync(Guid key, bool preview = false)
+        => await GetContentSourceAsync(key, preview, false);
+
+    /// <inheritdoc/>
+    public async Task<ContentCacheNode?> GetContentSourceAsync(Guid key, bool preview = false, bool useCache = false)
     {
-        ContentSourceDto? dto = await GetContentSourceDto(key);
+        ContentSourceDto? dto = await GetContentSourceDto(key, useCache);
 
         if (dto == null)
         {
@@ -153,16 +158,18 @@ private void TruncateContent()
         return CreateContentCacheNode(dto, preview);
     }
 
-    private async Task<ContentSourceDto?> GetContentSourceDto(Guid key)
+    private async Task<ContentSourceDto?> GetContentSourceDto(Guid key, bool useRequestCache)
     {
-        // Requests for a single ContentSourceDto are only made in cache refreshing contexts, so it's
-        // reasonable to cache the result for the lifetime of the request.
         var cacheKey = $"{nameof(DatabaseCacheRepository)}_ContentSourceDto_{key}";
 
-        ContentSourceDto? dto = AppCaches.RequestCache.GetCacheItem<ContentSourceDto>(cacheKey);
-        if (dto is not null)
+        ContentSourceDto? dto;
+        if (useRequestCache)
         {
-            return dto;
+            dto = AppCaches.RequestCache.GetCacheItem<ContentSourceDto>(cacheKey);
+            if (dto is not null)
+            {
+                return dto;
+            }
         }
 
         Sql<ISqlContext>? sql = SqlContentSourcesSelect()
@@ -172,7 +179,7 @@ private void TruncateContent()
 
         dto = await Database.FirstOrDefaultAsync<ContentSourceDto>(sql);
 
-        if (dto is not null)
+        if (useRequestCache && dto is not null)
         {
             AppCaches.RequestCache.Set(cacheKey, dto);
         }

src/Umbraco.PublishedCache.HybridCache/Persistence/IDatabaseCacheRepository.cs

@@ -16,8 +16,14 @@ internal interface IDatabaseCacheRepository
     /// <summary>
     /// Gets a single cache node for a document key and preview status.
     /// </summary>
+    [Obsolete("Please use the method overload takng all parameters. Scheduled for removal in Umbraco 19.")]
     Task<ContentCacheNode?> GetContentSourceAsync(Guid key, bool preview = false);
 
+    /// <summary>
+    /// Gets a single cache node for a document key and preview status.
+    /// </summary>
+    Task<ContentCacheNode?> GetContentSourceAsync(Guid key, bool preview = false, bool useCache = false);
+
     /// <summary>
     /// Gets a collection of cache nodes for a collection of document keys.
     /// </summary>
@@ -27,7 +33,7 @@ async Task<IEnumerable<ContentCacheNode>> GetContentSourcesAsync(IEnumerable<Gui
         var contentCacheNodes = new List<ContentCacheNode>();
         foreach (Guid key in keys)
         {
-            ContentCacheNode? contentSource = await GetContentSourceAsync(key, preview);
+            ContentCacheNode? contentSource = await GetContentSourceAsync(key, preview, false);
             if (contentSource is not null)
             {
                 contentCacheNodes.Add(contentSource);

src/Umbraco.PublishedCache.HybridCache/Services/DocumentCacheService.cs

@@ -121,7 +121,7 @@ public DocumentCacheService(
             async cancel =>
             {
                 using ICoreScope scope = _scopeProvider.CreateCoreScope();
-                ContentCacheNode? contentCacheNode = await _databaseCacheRepository.GetContentSourceAsync(key, preview);
+                ContentCacheNode? contentCacheNode = await _databaseCacheRepository.GetContentSourceAsync(key, preview, false);
 
                 // If we can resolve the content cache node, we still need to check if the ancestor path is published.
                 // This does cost some performance, but it's necessary to ensure that the content is actually published.
@@ -180,13 +180,13 @@ public async Task RefreshMemoryCacheAsync(Guid key)
         using ICoreScope scope = _scopeProvider.CreateCoreScope();
         scope.ReadLock(Constants.Locks.ContentTree);
 
-        ContentCacheNode? draftNode = await _databaseCacheRepository.GetContentSourceAsync(key, true);
+        ContentCacheNode? draftNode = await _databaseCacheRepository.GetContentSourceAsync(key, true, true);
         if (draftNode is not null)
         {
             await _hybridCache.SetAsync(GetCacheKey(draftNode.Key, true), draftNode, GetEntryOptions(draftNode.Key, true), GenerateTags(key));
         }
 
-        ContentCacheNode? publishedNode = await _databaseCacheRepository.GetContentSourceAsync(key, false);
+        ContentCacheNode? publishedNode = await _databaseCacheRepository.GetContentSourceAsync(key, false, true);
         if (publishedNode is not null && _publishStatusQueryService.HasPublishedAncestorPath(publishedNode.Key))
         {
             var cacheKey = GetCacheKey(publishedNode.Key, false);