This section describes what ICacheRefresher and ICacheRefresher<T> are and how to use them to invalidate your cache correctly including load balanced environments

What is an ICacheRefresher

This interface has been in the Umbraco core for a significant period. However, it has really only been used to ensure that content cache is refreshed among all server nodes participating in a load balanced scenario.

An ICacheRefresher is the primary method that invalidates any cache needing refreshment or removal. This applies regardless of a load balanced environment.

There are now a few different types of ICacheRefreshers in the Umbraco core. It is important to understand the differences between them and how cache invalidation works across multiple server nodes.

You should always be doing this consistently with the best practices listed below. You shouldn't be using HttpRuntime.Cache or HttpContext.Current.Cache directly. Instead, you should always be accessing it via the AppCaches cache helper (Umbraco.Cms.Core.Cache).

Cache types

The AppCaches which can be found in namespace Umbraco.Cms.Core.Cache contains types of cache: Runtime Cache, Request Cache and Isolated Caches.

This section describes the IMemberPartialViewCacheInvalidator interface, what it's default implementation does and how to customize it.

What is an IMemberPartialViewCacheInvalidator?

This interface is used to isolate the logic that invalidates parts of the partial view cache when a member is updated.

Why do we need to partially invalidate the partial view cache?

Razor templates may show data that is retrieved from a member object. Those templates might be cached by using the partial caching mechanism (for example, @await Html.CachedPartialAsync("member",Model,TimeSpan.FromDays(1), cacheByMember:true)). When a member is updated, these cached partials must be invalidated to ensure updated data is shown.

Where is it used?

This interface is called from the member cache refresher (MemberCacheRefresher), which is invoked every time a member is updated.

Details of the default implementation

Razor template partials are cached through a call to Html.CachedPartialAsync with cacheByMember set to true. This will append the ID of the currently logged-in member with a marker to the partial view cache key. For example, -m1015-.

When the ClearPartialViewCacheItems method is called it will clear all cache items that match the marker for the updated members.

If no member is logged in during caching, items with an empty member marker (for example, -m-) are also cleared.

Customizing the implementation

You can replace the default implementation by removing it and registering your own in a composer.

This section refers to how to implement caching features in the Umbraco application in a consistent way that will work in both single server environments and load balanced (multi-server) environments. The caching described in this section relates to application caching in the context of a web application only.

• .

Broadcasts distributed cache notifications to all servers of a load balanced environment. Also ensures that the notification is processed on the local environment.

For a specified , the implemented methods will:

• Notify the distributed cache

• Invalidate specified items

This article will show you how to insert and delete from the runtime cache.

Scenario

For this example we're working with tags. On my site I have two tag properties:

1. One on every page using the tag group default

2. One on my blog posts using the tag group blog

We're going to expose an endpoint that allows us to get the tags from each group.

The tags from the default should be cached for a minute. The blog tags will be cached until site restart or if you publish a blog post node in the Backoffice.

Example

Why work with tags? Because they're not cached by default.. which makes them ideal for demo purposes :)

TagService

First we want to create our CacheTagService. In this example it's a basic class with one method (GetAll) that wraps Umbraco's TagQuery.GetAllTags().

As you can see we inherit from the ICacheTagService interface. All that has is:

The interface was created to better register it so we can use dependency injection. You can register your own classes like so:

Now you can inject ICacheTagService in any constructor in your project - wohooo!

API

Now that we have our service it's time to create an endpoint where we can fetch the (cached) tags.

/umbraco/api/tags/getblogtags:

/umbraco/api/tags/getdefaulttags:

Everything should now work as expected when it comes to getting tags. However, if I go to my Backoffice and add a new tag to the blog group the changes aren't shown on the endpoint. Let's fix that.

Clearing cache on publish

To clear the cache we need a notification handler in which we register to the ContentPublishedNotification event on the ContentService. This allows us to run a piece of code whenever you publish a node.

Now that we have our notification we also need to register it. Add builder.AddNotificationHandler<ContentPublishedNotification, Notification>(); to the Compose method in the Composer class so it becomes:

Awesome! Now we have set up caching on our tags - making the site a bit faster. :)

This section describes how you should be getting/adding/updating/inserting items in the cache.

Adding and retrieving items in the cache

The recommended way to put data in and get data out is to use one of the many overloaded methods of: GetCacheItem. The GetCacheItem methods (all except one) are designed to "Get or Add" to the cache. The following retrieves an item from the cache and adds it if it doesn't already exist:

where _appCaches is injected as type AppCaches.

Notice 2 things:

• The GetCacheItem method is strongly typed and

• We are supplying a callback method which is used to populate the cache if it doesn't exist.

The example above will retrieve a strongly typed object of MyObject from the cache with the key of "MyCacheKey". If the object doesn't exist in the cache, a new instance of MyObject MyObject be added to it with the same key.

There are a couple of overloads of GetCacheItem allowing you to customize how your object is cached from cache dependencies to expiration times.

To use this generic implementation, add the Umbraco.Extensions namespace to your code.

Retrieving an item from the cache without a callback

One of the overloads of GetCacheItem doesn't specify a callback. This allows you to retrieve an item from the cache without populating it if it doesn't exist.

An example of usage:

where _appCaches is injected as type AppCaches.

Inserting an item into the cache without retrieval

Sometimes you might want to put something in the cache without retrieving it. In this case there is an InsertCacheItem<T> method. This method will add or update the cache item specified by the key. If the item already exists in the cache, it will be replaced.