Add some sort of implementation of a CacheTagHelper that's automatically aware of Preview and Debug

Author: marcemarc

Our.Umbraco.TagHelpers/CacheKeys/CacheKeyConstants.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Our.Umbraco.TagHelpers.CacheKeys
+{
+    public static class CacheKeyConstants
+    {
+        public const string LastCacheRefreshDateKey = "LastCacheRefreshDate";
+    }
+}

Our.Umbraco.TagHelpers/Composing/CacheTagHelperComposer.cs

@@ -0,0 +1,23 @@
+using Our.Umbraco.TagHelpers.Notifications;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Umbraco.Cms.Core.Composing;
+using Umbraco.Cms.Core.DependencyInjection;
+using Umbraco.Cms.Core.Notifications;
+
+namespace Our.Umbraco.TagHelpers.Composing
+{
+    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>();
+        }
+    }
+}

Our.Umbraco.TagHelpers/Notifications/CacheRefresherNotifications.cs

@@ -0,0 +1,71 @@
+using Our.Umbraco.TagHelpers.CacheKeys;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Umbraco.Cms.Core.Cache;
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.Notifications;
+
+namespace Our.Umbraco.TagHelpers.Notifications
+{
+	// For Use with the Our Cache TagHelper - to store a last cache updated datetime to use in the varyby key for the Cache TagHelper, to naively break the cache on publish
+	public class HandleContentCacheRefresherNotification : INotificationHandler<ContentCacheRefresherNotification>
+	{
+		private readonly IAppPolicyCache _runtimeCache;
+
+		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);
+
+		}
+	}
+	public class HandleDictionaryCacheRefresherNotification : INotificationHandler<DictionaryCacheRefresherNotification>
+	{
+		private readonly IAppPolicyCache _runtimeCache;
+		public HandleDictionaryCacheRefresherNotification(AppCaches appCaches)
+		{
+			_runtimeCache = appCaches.RuntimeCache;
+		}
+		public void Handle(DictionaryCacheRefresherNotification notification)
+		{
+			// fired when Dictionary item 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);
+
+		}
+	}
+	public class HandleMediaCacheRefresherNotification : INotificationHandler<MediaCacheRefresherNotification>
+	{
+		private readonly IAppPolicyCache _runtimeCache;
+		public HandleMediaCacheRefresherNotification(AppCaches appCaches)
+		{
+			_runtimeCache = appCaches.RuntimeCache;
+		}
+		public void Handle(MediaCacheRefresherNotification notification)
+		{
+			// 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);
+
+		}
+	}
+
+}

Our.Umbraco.TagHelpers/UmbracoCacheTagHelper.cs

@@ -0,0 +1,98 @@
+using Microsoft.AspNetCore.Mvc.TagHelpers;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+using Our.Umbraco.TagHelpers.CacheKeys;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+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
+{
+	/// <summary>
+	/// A wrapper around .net core CacheTagHelper so you remember not to cache in preview or Umbraco debug mode
+	/// Also can create a new variance of the cache when anything is published in Umbraco if that is desirable
+	/// </summary>
+	[HtmlTargetElement("our-cache")]
+	public class UmbracoCacheTagHelper : CacheTagHelper
+    {
+		private readonly IUmbracoContextFactory _umbracoContextFactory;
+		private readonly IAppPolicyCache _runtimeCache;
+		// default to true, a very 'Umbraco' convention.
+		private bool _updateCacheKeyOnPublish = true;
+
+		/// <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 UmbracoCacheTagHelper(CacheTagHelperMemoryCacheFactory factory, HtmlEncoder htmlEncoder, AppCaches appCaches, IUmbracoContextFactory umbracoContextFactory) : base(factory, htmlEncoder)
+		{
+			_umbracoContextFactory = umbracoContextFactory;
+			_runtimeCache = appCaches.RuntimeCache;
+		}
+		public override async Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
+		{
+			using (UmbracoContextReference umbracoContextReference = _umbracoContextFactory.EnsureUmbracoContext())
+			{
+				var umbracoContext = umbracoContextReference.UmbracoContext;
+				// we don't want to enable the cache tag helper if Umbraco is in Preview, or in Debug mode
+				if (umbracoContext.InPreviewMode || umbracoContext.IsDebug)
+				{
+					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)
+					{
+						// 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);
+                        }
+					}
+
+					await base.ProcessAsync(context, output);
+				}
+			}
+
+		}
+		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");
+
+		}
+
+	}
+}

README.md

@@ -339,6 +339,37 @@ Alternatively if you use the `<our-link>` without child DOM elements then it wil
 
 With this tag helper the child DOM elements inside the `<our-link>` is wrapped with the `<a>` tag
 
+## `<our-cache>`
+This tag helper element `<our-cache>` is a wrapper around the [DotNet CacheTagHelper](https://docs.microsoft.com/en-us/aspnet/core/mvc/views/tag-helpers/built-in/cache-tag-helper?view=aspnetcore-6.0) - it operates in exactly the same way, with the same options as the DotNet CacheTagHelper, except, it is automatically 'not enabled', when you are in Umbraco Preview or Umbraco Debug mode.
+
+### Without this tag helper
+
+Essentially this is a convenience for setting 
+
+'''cshtml
+<cache enabled="!UmbracoContext.IsDebug && !UmbracoContext.InPreviewMode">[Your Long Running Expensive Code Here]</cache>
+'''
+
+### With this tag helper
+
+'''cshtml
+<our-cache>[Your Long Running Expensive Code Here]</our-cache>
+'''
+
+### Clearing the Cache 'on publish'
+The DotNet CacheTagHelper really isn't designed to make it easy to clear the cache 'on command' it's designed to vary and then fall out of cache after a period of time, but what if you want your cache instantly refreshed when a publish takes place? This tag helper has the possibility to 'vary' the cache by the last Content/Media/Dictionary Cache Refresh date.
+
+'''cshtml
+<our-cache update-cache-key-on-publish="true">[Your Long Running Expensive Code Here]</our-cache>
+'''
+
+With this set to true any publish will trigger a new 'cache key' and therefore a fresh version of the TagOutput will be displayed, with this set, and if no ExpiresAfter is set on the Tag, we default to 24hrs as the lifetime of the Tag's cache.
+
+This is set to True by default, how opinionated of us. 
+
+(NB if you had a thousand tag helpers on your site, all caching large amounts of content, and new publishes to the site occurring every second - this might be detrimental to performance, so do think of the context of your site before setting this value)  
+
+
 ## Video 📺
 [![How to create ASP.NET TagHelpers for Umbraco](https://user-images.githubusercontent.com/1389894/138666925-15475216-239f-439d-b989-c67995e5df71.png)](https://www.youtube.com/watch?v=3fkDs0NwIE8)