Replacing IExpirationTrigger with IChangeToken

Author: pranavkm

.gitignore

@@ -25,3 +25,4 @@ nuget.exe
 *.*sdf
 *.ipch
 project.lock.json
+.vs

samples/MemoryCacheSample/Program.cs

@@ -5,6 +5,7 @@
 using System.Threading;
 using Microsoft.Framework.Caching;
 using Microsoft.Framework.Caching.Memory;
+using Microsoft.Framework.Primitives;
 
 namespace MemoryCacheSample
 {
@@ -77,26 +78,26 @@ public void Main()
                 });
             result = cache.Set(key, new object(), options);
 
-            // Remove on trigger
+            // Remove on token expiration
             var cts = new CancellationTokenSource();
             options = new MemoryCacheEntryOptions()
-                .AddExpirationTrigger(new CancellationTokenTrigger(cts.Token))
+                .AddExpirationToken(new CancellationChangeToken(cts.Token))
                 .RegisterPostEvictionCallback(
                 (echoKey, value, reason, substate) =>
                 {
                     Console.WriteLine(echoKey + ": '" + value + "' was evicted due to " + reason);
                 });
             result = cache.Set(key, new object(), options);
 
-            // Fire the trigger to see the registered callback being invoked
+            // Fire the token to see the registered callback being invoked
             cts.Cancel();
 
             // Expire an entry if the dependent entry expires
             using (var link = cache.CreateLinkingScope())
             {
                 cts = new CancellationTokenSource();
                 cache.Set("key1", "value1", new MemoryCacheEntryOptions()
-                    .AddExpirationTrigger(new CancellationTokenTrigger(cts.Token)));
+                    .AddExpirationToken(new CancellationChangeToken(cts.Token)));
 
                 // expire this entry if the entry with key "key1" expires.
                 cache.Set("key2", "value2", new MemoryCacheEntryOptions()
@@ -108,7 +109,7 @@ public void Main()
                     }));
             }
 
-            // Fire the trigger to see the registered callback being invoked
+            // Fire the token to see the registered callback being invoked
             cts.Cancel();
         }
     }

src/Microsoft.Framework.Caching.Abstractions/CancellationTokenTrigger.cs

@@ -25,7 +25,7 @@ public enum EvictionReason
         /// <summary>
         /// Event
         /// </summary>
-        Triggered,
+        TokenExpired,
 
         /// <summary>
         /// GC, overflow

src/Microsoft.Framework.Caching.Abstractions/EvictionReason.cs

@@ -3,12 +3,13 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Framework.Primitives;
 
 namespace Microsoft.Framework.Caching.Memory
 {
     /// <summary>
-    /// Used to flow expiration information from one entry to another. Triggers and minimum absolute expiration will
-    /// be copied from the dependent entry to the parent entry. The parent entry will not expire if the
+    /// Used to flow expiration information from one entry to another. <see cref="IChangeToken"/> instances and minimum absolute
+    /// expiration will be copied from the dependent entry to the parent entry. The parent entry will not expire if the
     /// dependent entry is removed manually, removed due to memory pressure, or expires due to sliding expiration.
     /// </summary>
     public interface IEntryLink : IDisposable
@@ -19,15 +20,15 @@ public interface IEntryLink : IDisposable
         DateTimeOffset? AbsoluteExpiration { get; }
 
         /// <summary>
-        /// Gets all the triggers from the dependent entries.
+        /// Gets all the <see cref="IChangeToken"/> instances from the dependent entries.
         /// </summary>
-        IEnumerable<IExpirationTrigger> Triggers { get; }
+        IEnumerable<IChangeToken> ExpirationTokens { get; }
 
         /// <summary>
-        /// Adds triggers from a dependent entries.
+        /// Adds <see cref="IChangeToken"/> instances from a dependent entries.
         /// </summary>
-        /// <param name="triggers"></param>
-        void AddExpirationTriggers(IList<IExpirationTrigger> triggers);
+        /// <param name="expirationTokens"><see cref="IChangeToken"/> instances from dependent entries.</param>
+        void AddExpirationTokens(IList<IChangeToken> expirationTokens);
 
         /// <summary>
         /// Sets the absolute expiration for from a dependent entry. The minimum value across all dependent entries

src/Microsoft.Framework.Caching.Abstractions/IEntryLink.cs

@@ -2,13 +2,14 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using Microsoft.Framework.Primitives;
 
 namespace Microsoft.Framework.Caching.Memory
 {
     public static class MemoryCacheEntryExtensions
     {
         /// <summary>
-        /// Sets the priority for keeping the cache entry in the cache during a memory pressure triggered cleanup.
+        /// Sets the priority for keeping the cache entry in the cache during a memory pressure tokened cleanup.
         /// </summary>
         /// <param name="options"></param>
         /// <param name="priority"></param>
@@ -21,20 +22,20 @@ public static MemoryCacheEntryOptions SetPriority(
         }
 
         /// <summary>
-        /// Expire the cache entry if the given event occurs.
+        /// Expire the cache entry if the given <see cref="IChangeToken"/> expires.
         /// </summary>
-        /// <param name="options"></param>
-        /// <param name="trigger"></param>
-        public static MemoryCacheEntryOptions AddExpirationTrigger(
+        /// <param name="options">The <see cref="MemoryCacheEntryOptions"/>.</param>
+        /// <param name="expirationToken">The <see cref="IChangeToken"/> that causes the cache entry to expire.</param>
+        public static MemoryCacheEntryOptions AddExpirationToken(
             this MemoryCacheEntryOptions options,
-            IExpirationTrigger trigger)
+            IChangeToken expirationToken)
         {
-            if (trigger == null)
+            if (expirationToken == null)
             {
-                throw new ArgumentNullException(nameof(trigger));
+                throw new ArgumentNullException(nameof(expirationToken));
             }
 
-            options.Triggers.Add(trigger);
+            options.ExpirationTokens.Add(expirationToken);
             return options;
         }
 
@@ -121,14 +122,14 @@ public static MemoryCacheEntryOptions RegisterPostEvictionCallback(
         }
 
         /// <summary>
-        /// Adds inherited trigger and absolute expiration information.
+        /// Adds inherited token and absolute expiration information.
         /// </summary>
         /// <param name="link"></param>
         public static MemoryCacheEntryOptions AddEntryLink(this MemoryCacheEntryOptions options, IEntryLink link)
         {
-            foreach (var trigger in link.Triggers)
+            foreach (var expirationToken in link.ExpirationTokens)
             {
-                options.AddExpirationTrigger(trigger);
+                options.AddExpirationToken(expirationToken);
             }
 
             if (link.AbsoluteExpiration.HasValue)

src/Microsoft.Framework.Caching.Abstractions/IExpirationTrigger.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using Microsoft.Framework.Primitives;
 
 namespace Microsoft.Framework.Caching.Memory
 {
@@ -74,9 +75,9 @@ public TimeSpan? SlidingExpiration
         }
 
         /// <summary>
-        /// Gets or sets the events which are fired when the cache entry expires.
+        /// Gets the <see cref="IChangeToken"/> instances which cause the cache entry to expire.
         /// </summary>
-        public IList<IExpirationTrigger> Triggers { get; } = new List<IExpirationTrigger>();
+        public IList<IChangeToken> ExpirationTokens { get; } = new List<IChangeToken>();
 
         /// <summary>
         /// Gets or sets the callbacks will be fired after the cache entry is evicted from the cache.

src/Microsoft.Framework.Caching.Abstractions/MemoryCacheEntryExtensions.cs

@@ -3,13 +3,15 @@
         "warningsAsErrors": true
     },
     "description": "ASP.NET 5 caching abstractions.",
+    "dependencies": {
+        "Microsoft.Framework.Primitives": "1.0.0-*"
+    },
     "frameworks": {
         "net45": { },
         "dnx451": { },
         "dotnet": {
             "dependencies": {
                 "System.Collections": "4.0.11-beta-*",
-                "System.Resources.ResourceManager": "4.0.1-beta-*",
                 "System.Threading": "4.0.11-beta-*",
                 "System.Threading.Tasks": "4.0.11-beta-*"
             }

src/Microsoft.Framework.Caching.Abstractions/MemoryCacheEntryOptions.cs

@@ -10,7 +10,7 @@ namespace Microsoft.Framework.Caching.Memory
 {
     internal class CacheEntry
     {
-        private static readonly Action<object> ExpirationCallback = TriggerExpired;
+        private static readonly Action<object> ExpirationCallback = ExpirationTokensExpired;
 
         private readonly Action<CacheEntry> _notifyCacheOfExpiration;
 
@@ -43,15 +43,15 @@ internal CacheEntry(
 
         internal EvictionReason EvictionReason { get; private set; }
 
-        internal IList<IDisposable> TriggerRegistrations { get; set; }
+        internal IList<IDisposable> ExpirationTokenRegistrations { get; set; }
 
         internal IList<PostEvictionCallbackRegistration> PostEvictionCallbacks { get; set; }
 
         internal DateTimeOffset LastAccessed { get; set; }
 
         internal bool CheckExpired(DateTimeOffset now)
         {
-            return IsExpired || CheckForExpiredTime(now) || CheckForExpiredTriggers();
+            return IsExpired || CheckForExpiredTime(now) || CheckForExpiredTokens();
         }
 
         internal void SetExpired(EvictionReason reason)
@@ -61,7 +61,7 @@ internal void SetExpired(EvictionReason reason)
             {
                 EvictionReason = reason;
             }
-            DetachTriggers();
+            DetachTokens();
         }
 
         private bool CheckForExpiredTime(DateTimeOffset now)
@@ -82,61 +82,61 @@ private bool CheckForExpiredTime(DateTimeOffset now)
             return false;
         }
 
-        internal bool CheckForExpiredTriggers()
+        internal bool CheckForExpiredTokens()
         {
-            var triggers = Options.Triggers;
-            if (triggers != null)
+            var expiredTokens = Options.ExpirationTokens;
+            if (expiredTokens != null)
             {
-                for (int i = 0; i < triggers.Count; i++)
+                for (int i = 0; i < expiredTokens.Count; i++)
                 {
-                    var trigger = triggers[i];
-                    if (trigger.IsExpired)
+                    var expiredToken = expiredTokens[i];
+                    if (expiredToken.HasChanged)
                     {
-                        SetExpired(EvictionReason.Triggered);
+                        SetExpired(EvictionReason.TokenExpired);
                         return true;
                     }
                 }
             }
             return false;
         }
 
-        // TODO: There's a possible race between AttachTriggers and DetachTriggers if a trigger fires almost immediately.
+        // TODO: There's a possible race between AttachTokens and DetachTokens if a token fires almost immediately.
         // This may result in some registrations not getting disposed.
-        internal void AttachTriggers()
+        internal void AttachTokens()
         {
-            var triggers = Options.Triggers;
-            if (triggers != null)
+            var expirationTokens = Options.ExpirationTokens;
+            if (expirationTokens != null)
             {
-                for (int i = 0; i < triggers.Count; i++)
+                for (int i = 0; i < expirationTokens.Count; i++)
                 {
-                    var trigger = triggers[i];
-                    if (trigger.ActiveExpirationCallbacks)
+                    var expirationToken = expirationTokens[i];
+                    if (expirationToken.ActiveChangeCallbacks)
                     {
-                        if (TriggerRegistrations == null)
+                        if (ExpirationTokenRegistrations == null)
                         {
-                            TriggerRegistrations = new List<IDisposable>(1);
+                            ExpirationTokenRegistrations = new List<IDisposable>(1);
                         }
-                        var registration = trigger.RegisterExpirationCallback(ExpirationCallback, this);
-                        TriggerRegistrations.Add(registration);
+                        var registration = expirationToken.RegisterChangeCallback(ExpirationCallback, this);
+                        ExpirationTokenRegistrations.Add(registration);
                     }
                 }
             }
         }
 
-        private static void TriggerExpired(object obj)
+        private static void ExpirationTokensExpired(object obj)
         {
             var entry = (CacheEntry)obj;
-            entry.SetExpired(EvictionReason.Triggered);
+            entry.SetExpired(EvictionReason.TokenExpired);
             entry._notifyCacheOfExpiration(entry);
         }
 
         // TODO: Thread safety
-        private void DetachTriggers()
+        private void DetachTokens()
         {
-            var registrations = TriggerRegistrations;
+            var registrations = ExpirationTokenRegistrations;
             if (registrations != null)
             {
-                TriggerRegistrations = null;
+                ExpirationTokenRegistrations = null;
                 for (int i = 0; i < registrations.Count; i++)
                 {
                     var registration = registrations[i];