Try to simplify it by grabbing the cachekey that is used in the base class CacheTagHelper from Microsoft

Track that rerference/key in our dictionary/list which we can remove from the IMemoryhCache on ContentPublished, Media & Dictionary with CacheRefresher notifications

Author: Warren Buckley

Our.Umbraco.TagHelpers/Composing/CacheTagHelperComposer.cs

@@ -1,4 +1,6 @@
-using Our.Umbraco.TagHelpers.Notifications;
+using Microsoft.Extensions.DependencyInjection;
+using Our.Umbraco.TagHelpers.Notifications;
+using Our.Umbraco.TagHelpers.Services;
 using Umbraco.Cms.Core.Composing;
 using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Notifications;
@@ -10,9 +12,11 @@ public class CacheTagHelperComposer : IComposer
         // handle refreshing of content/media/dictionary cache notification to clear the cache key used for the CacheTagHelper
         public void Compose(IUmbracoBuilder builder)
         {
-            builder.AddNotificationHandler<ContentCacheRefresherNotification, HandleContentCacheRefresherNotification>();
-            builder.AddNotificationHandler<MediaCacheRefresherNotification, HandleMediaCacheRefresherNotification>();
-            builder.AddNotificationHandler<DictionaryCacheRefresherNotification, HandleDictionaryCacheRefresherNotification>();
+            builder.Services.AddSingleton<IUmbracoTagHelperCacheKeys, UmbracoTagHelperCacheKeys>();
+
+            builder.AddNotificationHandler<ContentCacheRefresherNotification, CacheTagRefresherNotifications>();
+            builder.AddNotificationHandler<MediaCacheRefresherNotification, CacheTagRefresherNotifications>();
+            builder.AddNotificationHandler<DictionaryCacheRefresherNotification, CacheTagRefresherNotifications>();
         }
     }
 }

Our.Umbraco.TagHelpers/Notifications/CacheRefresherNotifications.cs

@@ -1,6 +1,6 @@
-using Our.Umbraco.TagHelpers.CacheKeys;
-using System;
-using Umbraco.Cms.Core.Cache;
+using Microsoft.AspNetCore.Mvc.TagHelpers;
+using Microsoft.Extensions.Caching.Memory;
+using Our.Umbraco.TagHelpers.Services;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Notifications;
 
@@ -10,64 +10,44 @@ namespace Our.Umbraco.TagHelpers.Notifications
 	// in the varyby key for the Cache TagHelper, to naively break the cache on publish.
 	// Used for ContentCacheRefresher (Load balanced scernarios not just Published event)
 	// Same for Dictionary Items and Media item
-	public class HandleContentCacheRefresherNotification : INotificationHandler<ContentCacheRefresherNotification>
-	{
-		private readonly IAppPolicyCache _runtimeCache;
+	public class CacheTagRefresherNotifications : 
+		INotificationHandler<ContentCacheRefresherNotification>,
+        INotificationHandler<DictionaryCacheRefresherNotification>,
+        INotificationHandler<MediaCacheRefresherNotification>
+    {
 
-		public HandleContentCacheRefresherNotification(AppCaches appCaches)
-		{
-			_runtimeCache = appCaches.RuntimeCache;
-
-		}
-
-		public void Handle(ContentCacheRefresherNotification notification)
-		{
-			// fired when content published
-			// store DateTime, as the cachekey
-			var lastCacheRefreshDate = DateTime.UtcNow.ToString("s");
-
-			// insert and override existing value in appcache
-			_runtimeCache.Insert(CacheKeyConstants.LastCacheRefreshDateKey, () => lastCacheRefreshDate, null, false, null);
-
-		}
-	}
+		private IMemoryCache _memoryCache;
 
-	public class HandleDictionaryCacheRefresherNotification : INotificationHandler<DictionaryCacheRefresherNotification>
-	{
-		private readonly IAppPolicyCache _runtimeCache;
-		public HandleDictionaryCacheRefresherNotification(AppCaches appCaches)
-		{
-			_runtimeCache = appCaches.RuntimeCache;
-		}
+		private IUmbracoTagHelperCacheKeys _cacheKeys;
 
-		public void Handle(DictionaryCacheRefresherNotification notification)
+		public CacheTagRefresherNotifications(CacheTagHelperMemoryCacheFactory cacheFactory, IUmbracoTagHelperCacheKeys cacheKeys)
 		{
-			// fired when Dictionary item updated
-			// store DateTime, as the cachekey
-			var lastCacheRefreshDate = DateTime.UtcNow.ToString("s");
+            _memoryCache = cacheFactory.Cache;
+			_cacheKeys = cacheKeys;
+        }
 
-			// insert and override existing value in appcache
-			_runtimeCache.Insert(CacheKeyConstants.LastCacheRefreshDateKey, () => lastCacheRefreshDate, null, false, null);
+		public void Handle(ContentCacheRefresherNotification notification) => ClearUmbracoTagHelperCache();
 
-		}
-	}
+		public void Handle(DictionaryCacheRefresherNotification notification) => ClearUmbracoTagHelperCache();
 
-	public class HandleMediaCacheRefresherNotification : INotificationHandler<MediaCacheRefresherNotification>
-	{
-		private readonly IAppPolicyCache _runtimeCache;
-		public HandleMediaCacheRefresherNotification(AppCaches appCaches)
-		{
-			_runtimeCache = appCaches.RuntimeCache;
-		}
+		public void Handle(MediaCacheRefresherNotification notification) => ClearUmbracoTagHelperCache();
 
-		public void Handle(MediaCacheRefresherNotification notification)
+		private void ClearUmbracoTagHelperCache()
 		{
-			// fired when media updated
-			// store DateTime, as the cachekey
-			var lastCacheRefreshDate = DateTime.UtcNow.ToString("s");
-
-			// insert and override existing value in appcache
-			_runtimeCache.Insert(CacheKeyConstants.LastCacheRefreshDateKey, () => lastCacheRefreshDate, null, false, null);
+			// Loop over items in dictionary
+			foreach (var item in _cacheKeys.CacheKeys)
+			{
+				// The value stores the CacheTagKey object
+				// Looking at src code from MS TagHelper that use this object itself as the key
+
+				// Remove item from IMemoryCache
+				_memoryCache.Remove(item.Value);
+			}
+
+			// Once all items cleared from IMemoryCache that we are tracking
+			// Clear the dictionary out
+			// It will fill back up once an <our-cache> TagHelper is called/used on a page
+			_cacheKeys.CacheKeys.Clear();
 		}
 	}
 }

Our.Umbraco.TagHelpers/UmbracoCacheTagHelper.cs

@@ -1,13 +1,11 @@
 using Microsoft.AspNetCore.Mvc.TagHelpers;
+using Microsoft.AspNetCore.Mvc.TagHelpers.Cache;
 using Microsoft.AspNetCore.Razor.TagHelpers;
-using Our.Umbraco.TagHelpers.CacheKeys;
-using System;
+using Our.Umbraco.TagHelpers.Services;
 using System.Text.Encodings.Web;
 using System.Threading.Tasks;
 using Umbraco.Cms.Core;
-using Umbraco.Cms.Core.Cache;
 using Umbraco.Cms.Core.Web;
-using Umbraco.Extensions;
 
 namespace Our.Umbraco.TagHelpers
 {
@@ -19,23 +17,21 @@ namespace Our.Umbraco.TagHelpers
 	public class UmbracoCacheTagHelper : CacheTagHelper
     {
 		private readonly IUmbracoContextFactory _umbracoContextFactory;
-		private readonly IAppPolicyCache _runtimeCache;
-		// default to true, a very 'Umbraco' convention.
-		private bool _updateCacheKeyOnPublish = true;
+		private readonly IUmbracoTagHelperCacheKeys _cacheKeys;
 
 		/// <summary>
 		/// Whether to update the cache key when any content, media, dictionary item is published in Umbraco.
 		/// </summary>
-		public bool UpdateCacheKeyOnPublish
-		{
-			get { return _updateCacheKeyOnPublish; }
-			set { _updateCacheKeyOnPublish = value; }
-		}
+		public bool UpdateCacheKeyOnPublish { get; set; } = true;
 
-		public UmbracoCacheTagHelper(CacheTagHelperMemoryCacheFactory factory, HtmlEncoder htmlEncoder, AppCaches appCaches, IUmbracoContextFactory umbracoContextFactory) : base(factory, htmlEncoder)
+		public UmbracoCacheTagHelper(CacheTagHelperMemoryCacheFactory factory, 
+			HtmlEncoder htmlEncoder, 
+			IUmbracoContextFactory umbracoContextFactory,
+            IUmbracoTagHelperCacheKeys cacheKeys) 
+			: base(factory, htmlEncoder)
 		{
 			_umbracoContextFactory = umbracoContextFactory;
-			_runtimeCache = appCaches.RuntimeCache;
+			_cacheKeys = cacheKeys;
 		}
 
 		public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
@@ -47,52 +43,28 @@ public override async Task ProcessAsync(TagHelperContext context, TagHelperOutpu
 				// we don't want to enable the cache tag helper if Umbraco is in Preview, or in Debug mode
 				if (umbracoContext.InPreviewMode || umbracoContext.IsDebug)
 				{
+					// Set the endabled flag to false & lest base class
+					// of the cache tag helper do the same stuff as before
 					this.Enabled = false;
-					await output.GetChildContentAsync();
 				}
 				else
 				{
-					// with the CacheTagHelper we are wrapping here it's really difficult to clear the cache of the Tag Helper output 'on demand'
-					// eg when a page is published, with Umbraco's CachedPartial that's what happens, so if you change the name of a page, and the site navigation
-					// is cached with a cached partial, the cache is automatically cleared.
-					// it seems for CacheTagHelper the .net core advice when you want to break the cache is to update the varyby key, the previous key in the cache will be forgotten
-					// and fall out of the cache naturally... (but I did later on find this article: https://www.umbrajobs.com/blog/posts/2021/june/umbraco-9-net-core-caching-part-1-cashing-shared-partial-views/
-					// where it talks about being able to clear the actual cache tag using reflection.. - it won't work on loadbalanced servers - using wrong notifications!
-					// ... so maybe that's the way people will ultimately prefer to go...
-					// but for this tag helper we just track the last time a peace of content, dictionary item or media was published, and use that datetime in the varyby cachekey
-					// so everytime something is published in Umbraco, the cache tag helper will have a different cache key and this will produce a new cached result
-					// this might be a bad thing?
-					// so we have a setting to turn this off, so the tag helper is still usable as the existing .net core cache tag helper, without caching in preview or umbraco debug
-					// which is still handyish
-					if (_updateCacheKeyOnPublish)
+					// Defaults to true - have to explicitly opt out with attribute set to false in Razor
+					if (UpdateCacheKeyOnPublish)
 					{
-						// ironically read the last cache refresh date from runtime cache, and set it to now if it's not there...
-						var umbLastCacheRefreshCacheKey = _runtimeCache.GetCacheItem(CacheKeyConstants.LastCacheRefreshDateKey, () => GetFallbackCacheRefreshDate()).ToString();
-						
-						// append to VaryBy key incase VaryBy key is set to some other parameter too
-						this.VaryBy = umbLastCacheRefreshCacheKey + "|" + this.VaryBy;
-						
-						// if an expiry date isn't set when using the CacheTagHelper, let's add one to be 24hrs, so when mulitple publishes occur, the versions of this taghelper don't hang around forever
-						if (this.ExpiresAfter == null)
-                        {
-							this.ExpiresAfter = new TimeSpan(24, 0, 0);
-                        }
-					}
+                        // So before we go into our base class
+                        // Grab the cache key so we can keep track of it & put into some dictionary or collection
+                        // and clear all items out in that collection with our notifications on publish
 
-					await base.ProcessAsync(context, output);
+                        var cacheKey = new CacheTagKey(this, context);
+                        var key = cacheKey.GenerateKey();
+                        var hashedKey = cacheKey.GenerateHashedKey();
+						_cacheKeys.CacheKeys.TryAdd(key, cacheKey);
+                    }
 				}
-			}
 
-		}
-
-		private string GetFallbackCacheRefreshDate()
-		{
-			// this fires if the 'appcache' doesn't have a LastCacheRefreshDate set by a publish
-			// eg after an app pool recycle
-			// it doesn't really matter that this isn't the last datetime that something was actually published
-			// because time tends to always move forwards
-			// the next publish will set a new future LastCacheRefreshDate...
-			return DateTime.UtcNow.ToString("s");
+                await base.ProcessAsync(context, output);
+            }
 		}
 	}
 }