I've now moved to using the CacheManager instance and it's still not working. Here is my example code, it's build to allow a dictionary of objects cached against a content item.

    public class EpiServerContentCacheManager : ICacheManager
    {
        /// <summary>
        /// Inserts an item in to the cache based upon the content reference.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="contentReference">The content reference.</param>
        /// <param name="objectKey">The object key which differentiates different items against an item.</param>
        /// <param name="item">The item.</param>
        public void Insert<T>(ContentReference contentReference, string objectKey, T item) where T : class, ICacheableItem
        {
            var dictionary = GetCacheDictionary(contentReference);

            if (dictionary != null)
            {
                var existingItem = dictionary[objectKey];

                if (existingItem == null)
                {
                    dictionary.Add(objectKey, item);
                }
                else
                {
                    dictionary[objectKey] = item;
                }
            }
            else
            {
                dictionary = new Dictionary<string, object> {{objectKey, item}};
            }

            Insert(contentReference, dictionary);
        }

        /// <summary>
        /// Gets an item from the cache based upon it's content reference.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="contentReference">The content reference.</param>
        /// <param name="objectKey">The object key which differentiates different items against an item.</param>
        /// <returns>T.</returns>
        public T Get<T>(ContentReference contentReference, string objectKey) where T : class, ICacheableItem
        {
            var dictionary = GetCacheDictionary(contentReference);

            if (dictionary != null && dictionary.ContainsKey(objectKey))
            {
                return (T) dictionary[objectKey];
            }

            return null;
        }

        /// <summary>
        /// Removes the specified content reference.
        /// </summary>
        /// <param name="contentReference">The content reference.</param>
        public void Remove(ContentReference contentReference)
        {
            var key = GetCacheKey(contentReference);
            CacheManager.Remove(key);
        }

        /// <summary>
        /// Gets the cache key.
        /// </summary>
        /// <param name="contentReference">The content reference.</param>
        /// <returns>System.String.</returns>
        private string GetCacheKey(ContentReference contentReference)
        {
            return $"ContentDependency:{contentReference.ID}";
        }

        private Dictionary<string, object> GetCacheDictionary(ContentReference contentReference)
        {
            var key = GetCacheKey(contentReference);
            return (Dictionary<string, object>)CacheManager.Get(key);
        }

        /// <summary>
        /// Inserts the specified content reference.
        /// </summary>
        /// <param name="contentReference">The content reference.</param>
        /// <param name="dictionary">The dictionary.</param>
        private void Insert(ContentReference contentReference, Dictionary<string, object> dictionary)
        {
            var key = GetCacheKey(contentReference);
            CacheManager.Insert(
                    key,
                    dictionary,
                    new CacheEvictionPolicy(
                        new List<string> { DataFactoryCache.PageCommonCacheKey(contentReference) }
                    )
                );
        }
    }

Hi,

Have you configured remote events? Please see http://world.episerver.com/documentation/Items/Developers-Guide/Episerver-CMS/9/Event-management/Event-management/

It's only the CacheManager/ISynchronizedObjectInstanceCache that isn't working, all the standard eventing and load balancing is working with content that isn't being cached through these mechanisms. 

Just to clarify, what exactly isn't working? "Syncing" is kinda broad description of what the event system is doing. What it does is to invalidate the cache. So if you add stuff to the cache, it's not added to all nodes automatically.

As far as I am aware from examples around and the code comments the use of the CacheManager when adding in objects that have a cache eviction policy based upon a ContentReference should store the object in memory as long as the IContent item of that ContentReference hasn't changed. If the item does change the object would be evicted from the cache accross all load balanced servers which should be the next time the item is requested it will be re-inserted in to the cache.

Then we're on the same page :)

Are you sure this is related to load balancing? Is the item evicted from the server where the item was changed?

Yes, For our QA process we have a CMS and a WEB box that the code is deployed to. If I change the content that this is all linked to (which is a container page used for some configuration data) I see the item appearing on the front end of the CMS box but the content is not being updated on the WEB box. As I've said non cached items items are showing up so the Events system is definately working (also this using a base build that's not changed events wise and has been working on multiple projects).

Thanks for your help on this, it turns out the changes I made to use CacheManager as shown above are working. We've recently had some changes to out TeamCity setup to use GitVersion for semantic versioning which has caused a problem with Octopus. Long story short the deployment had redeployed the non updated code. Typical, thanks for the help.