Improves the performance of publishing pages that contain Archetype properties: umbraco/Umbraco.Cloud.Issues#35

Does this by adding caching (that replenishes every 30 seconds). The plumbing for the caching mechanism is also included.

Author: Nicholas-Westby

src/Umbraco.Deploy.Contrib.Connectors/Caching/Comparers/StringArrayComparer.cs

@@ -0,0 +1,82 @@
+namespace Umbraco.Deploy.Contrib.Connectors.Caching.Comparers
+{
+
+    // Namespaces.
+    using System.Collections.Generic;
+    using System.Linq;
+
+    /// <summary>
+    /// Compares an array of strings.
+    /// </summary>
+    /// <remarks>
+    /// Based on: https://github.com/rhythmagency/rhythm.caching.core/blob/master/src/Rhythm.Caching.Core/Comparers/StringArrayComparer.cs
+    /// </remarks>
+    public class StringArrayComparer : IEqualityComparer<string[]>
+    {
+
+        #region Methods
+
+        /// <summary>
+        /// Check if the arrays are equal.
+        /// </summary>
+        /// <param name="x">
+        /// The first array.
+        /// </param>
+        /// <param name="y">
+        /// The second array.
+        /// </param>
+        /// <returns>
+        /// True, if the arrays are both null, are both empty, or both have
+        /// the same strings in the same order; otherwise, false.
+        /// </returns>
+        public bool Equals(string[] x, string[] y)
+        {
+            if (x == null || y == null)
+            {
+                return x == null && y == null;
+            }
+            if (x.Length != y.Length)
+            {
+                return false;
+            }
+            for (var i = 0; i < x.Length; i++)
+            {
+                if (x[i] != y[i])
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Generates a hash code by combining all of the hash codes for the strings in the array.
+        /// </summary>
+        /// <param name="items">
+        /// The array of strings.
+        /// </param>
+        /// <returns>
+        /// The combined hash code.
+        /// </returns>
+        public int GetHashCode(string[] items)
+        {
+            if (items == null || !items.Any())
+            {
+                return 0;
+            }
+            else
+            {
+                var hashCode = default(int);
+                foreach (var item in items)
+                {
+                    hashCode ^= (item ?? string.Empty).GetHashCode();
+                }
+                return hashCode;
+            }
+        }
+
+        #endregion
+
+    }
+
+}

src/Umbraco.Deploy.Contrib.Connectors/Caching/InstanceByKeyCache.cs

@@ -0,0 +1,265 @@
+namespace Umbraco.Deploy.Contrib.Connectors.Caching
+{
+
+    // Namespaces.
+    using Comparers;
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Caches instance variables by key in a dictionary-like structure.
+    /// </summary>
+    /// <typeparam name="T">
+    /// The type of value to cache.
+    /// </typeparam>
+    /// <typeparam name="TKey">
+    /// The key to use when access values in the dictionary.
+    /// </typeparam>
+    /// <remarks>
+    /// Adapted from: https://github.com/rhythmagency/rhythm.caching.core/blob/master/src/Rhythm.Caching.Core/Caches/InstanceByKeyCache.cs
+    /// </remarks>
+    public class InstanceByKeyCache<T, TKey>
+    {
+
+        #region Static Variables
+
+        private static string[] EmptyArray = new string[] { };
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// The instances stored by their key, then again by a contextual key.
+        /// </summary>
+        private Dictionary<TKey, Tuple<Dictionary<string[], T>, DateTime>> Instances { get; set; }
+
+        /// <summary>
+        /// Object to perform locks for cross-thread safety.
+        /// </summary>
+        private object InstancesLock { get; set; }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Default constructor.
+        /// </summary>
+        public InstanceByKeyCache()
+        {
+            InstancesLock = new object();
+            Instances = new Dictionary<TKey, Tuple<Dictionary<string[], T>, DateTime>>();
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Gets the instance variable (either from the cache or from the specified function).
+        /// </summary>
+        /// <param name="key">
+        /// The key to use when fetching the variable.
+        /// </param>
+        /// <param name="replenisher">
+        /// The function that replenishes the cache.
+        /// </param>
+        /// <param name="duration">
+        /// The duration to cache for.
+        /// </param>
+        /// <param name="method">
+        /// Optional. The cache method to use when retrieving the value.
+        /// </param>
+        /// <param name="keys">
+        /// Optional. The keys to store/retrieve a value by. Each key combination will
+        /// be treated as a separate cache.
+        /// </param>
+        /// <returns>
+        /// The value.
+        /// </returns>
+        public T Get(TKey key, Func<TKey, T> replenisher, TimeSpan duration, params string[] keys)
+        {
+            lock (InstancesLock)
+            {
+
+                // Variables.
+                var tempInstance = default(T);
+                var now = DateTime.Now;
+
+                // Value already cached?
+                var tempTuple = default(Tuple<Dictionary<string[], T>, DateTime>);
+                if (Instances.TryGetValue(key, out tempTuple)
+                    && tempTuple.Item1.ContainsKey(keys))
+                {
+                    if (now.Subtract(Instances[key].Item2) >= duration)
+                    {
+
+                        // Cache expired. Replenish the cache.
+                        tempInstance = replenisher(key);
+                        UpdateValueByKeys(keys, key, tempInstance, now, false);
+
+                    }
+                    else
+                    {
+
+                        // Cache still valid. Use cached value.
+                        tempInstance = TryGetByKeys(keys, key);
+
+                    }
+                }
+                else
+                {
+
+                    // No cached value. Replenish the cache.
+                    tempInstance = replenisher(key);
+                    UpdateValueByKeys(keys, key, tempInstance, now, false);
+
+                }
+
+                // Return the instance.
+                return tempInstance;
+
+            }
+        }
+
+        /// <summary>
+        /// Clears the cache.
+        /// </summary>
+        public void Clear()
+        {
+            lock (InstancesLock)
+            {
+                Instances.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Clears the cache of the specified keys.
+        /// </summary>
+        /// <param name="keys">
+        /// The keys to clear the cache of.
+        /// </param>
+        public void ClearKeys(IEnumerable<TKey> keys)
+        {
+            lock (InstancesLock)
+            {
+                foreach (var key in keys)
+                {
+                    Instances.Remove(key);
+                }
+            }
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        /// <summary>
+        /// Trys to get the value by the specified keys.
+        /// </summary>
+        /// <param name="keys">
+        /// The keys.
+        /// </param>
+        /// <param name="accessKey">
+        /// The key to use to access the value.
+        /// </param>
+        /// <returns>
+        /// The value, or the default for the type.
+        /// </returns>
+        private T TryGetByKeys(string[] keys, TKey accessKey)
+        {
+            var chosenKeys = keys ?? EmptyArray;
+            var value = default(T);
+            lock (InstancesLock)
+            {
+                var valueDictionary = default(Tuple<Dictionary<string[], T>, DateTime>);
+                if (Instances.TryGetValue(accessKey, out valueDictionary))
+                {
+                    if (valueDictionary.Item1.TryGetValue(chosenKeys, out value))
+                    {
+                        return value;
+                    }
+                }
+            }
+            return default(T);
+        }
+
+        /// <summary>
+        /// Updates the cache value by the specified keys.
+        /// </summary>
+        /// <param name="keys">
+        /// The keys to cache by.
+        /// </param>
+        /// <param name="accessKey">
+        /// The key to use to access the value.
+        /// </param>
+        /// <param name="value">
+        /// The value to update the cache with.
+        /// </param>
+        /// <param name="lastCache">
+        /// The date/time to mark the cache as last updated.
+        /// </param>
+        /// <param name="doLock">
+        /// Lock the instance cache during the update?
+        /// </param>
+        private void UpdateValueByKeys(string[] keys, TKey accessKey, T value,
+            DateTime lastCache, bool doLock = true)
+        {
+            if (doLock)
+            {
+                lock (InstancesLock)
+                {
+                    UpdateValueByKeysWithoutLock(keys, accessKey, value, lastCache);
+                }
+            }
+            else
+            {
+                UpdateValueByKeysWithoutLock(keys, accessKey, value, lastCache);
+            }
+        }
+
+        /// <summary>
+        /// Updates the cache with the specified value.
+        /// </summary>
+        /// <param name="keys">
+        /// The keys to cache by.
+        /// </param>
+        /// <param name="accessKey">
+        /// The key to use to access the value.
+        /// </param>
+        /// <param name="value">
+        /// The value to update the cache with.
+        /// </param>
+        private void UpdateValueByKeysWithoutLock(string[] keys, TKey accessKey,
+            T value, DateTime lastCache)
+        {
+
+            // Variables.
+            var instanceTuple = default(Tuple<Dictionary<string[], T>, DateTime>);
+            var instanceDictionary = default(Dictionary<string[], T>);
+
+            // Get or create the dictionary.
+            if (Instances.TryGetValue(accessKey, out instanceTuple))
+            {
+                instanceDictionary = instanceTuple.Item1;
+            }
+            else
+            {
+                instanceDictionary = new Dictionary<string[], T>(new StringArrayComparer());
+            }
+
+            // Update the value in the dictionary.
+            instanceDictionary[keys] = value;
+
+            // Update the last cache date.
+            Instances[accessKey] = new Tuple<Dictionary<string[], T>, DateTime>(
+                instanceDictionary, lastCache);
+
+        }
+
+        #endregion
+
+    }
+
+}

src/Umbraco.Deploy.Contrib.Connectors/Umbraco.Deploy.Contrib.Connectors.csproj

@@ -66,6 +66,8 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Caching\Comparers\StringArrayComparer.cs" />
+    <Compile Include="Caching\InstanceByKeyCache.cs" />
     <Compile Include="GridCellValueConnectors\DocTypeGridEditorCellValueConnector.cs" />
     <Compile Include="GridCellValueConnectors\LeBlenderGridCellValueConnector.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />