Implement TryUpdate (#61)

* TryUpdate

* cleanup

Author: bitfaster

BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs

@@ -257,5 +257,24 @@ public void WhenKeyDoesNotExistTryRemoveReturnsFalse()
 
             lru.TryRemove(2).Should().BeFalse();
         }
+
+        [Fact]
+        public void WhenKeyExistsTryUpdateUpdatesValueAndReturnsTrue()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryUpdate(1, "2").Should().BeTrue();
+
+            lru.TryGet(1, out var value);
+            value.Should().Be("2");
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryUpdateReturnsFalse()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryUpdate(2, "3").Should().BeFalse();
+        }
     }
 }

BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs

@@ -373,5 +373,24 @@ public void WhenRepeatedlyAddingAndRemovingSameValueLruRemainsInConsistentState(
                 lru.TryRemove(1);
             }
         }
+
+        [Fact]
+        public void WhenKeyExistsTryUpdateUpdatesValueAndReturnsTrue()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryUpdate(1, "2").Should().BeTrue();
+
+            lru.TryGet(1, out var value);
+            value.Should().Be("2");
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryUpdateReturnsFalse()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryUpdate(2, "3").Should().BeFalse();
+        }
     }
 }

BitFaster.Caching/ICache.cs

@@ -41,10 +41,18 @@ public interface ICache<K, V>
         Task<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory);
 
         /// <summary>
-        /// Attempts to remove and return the value that has the specified key from the cache.
+        /// Attempts to remove the value that has the specified key.
         /// </summary>
         /// <param name="key">The key of the element to remove.</param>
         /// <returns>true if the object was removed successfully; otherwise, false.</returns>
         bool TryRemove(K key);
+
+        /// <summary>
+        /// Attempts to update the value that has the specified key.
+        /// </summary>
+        /// <param name="key">The key of the element to update.</param>
+        /// <param name="value">The new value.</param>
+        /// <returns>true if the object was updated successfully; otherwise, false.</returns>
+        bool TryUpdate(K key, V value);
     }
 }

BitFaster.Caching/Lru/ClassicLru.cs

@@ -193,6 +193,19 @@ public bool TryRemove(K key)
             return false;
         }
 
+        ///<inheritdoc/>
+        ///<remarks>Note: Calling this method does not affect LRU order.</remarks>
+        public bool TryUpdate(K key, V value)
+        {
+            if (this.dictionary.TryGetValue(key, out var node))
+            {
+                node.Value.Value = value;
+                return true;
+            }
+
+            return false;
+        }
+
         // Thead A reads x from the dictionary. Thread B adds a new item. Thread A moves x to the end. Thread B now removes the new first Node (removal is atomic on both data structures).
         private void LockAndMoveToEnd(LinkedListNode<LruItem> node)
         {
@@ -226,7 +239,7 @@ public LruItem(K k, V v)
 
             public K Key { get; }
 
-            public V Value { get; }
+            public V Value { get; set; }
         }
     }
 }

BitFaster.Caching/Lru/LruItem.cs

@@ -19,7 +19,7 @@ public LruItem(K k, V v)
 
         public readonly K Key;
 
-        public readonly V Value;
+        public V Value { get; set; }
 
         public bool WasAccessed
         {

BitFaster.Caching/Lru/TemplateConcurrentLru.cs

@@ -223,6 +223,25 @@ public bool TryRemove(K key)
             return false;
         }
 
+        ///<inheritdoc/>
+        ///<remarks>Note: Calling this method does not affect LRU order.</remarks>
+        public bool TryUpdate(K key, V value)
+        {
+            if (this.dictionary.TryGetValue(key, out var existing))
+            {
+                lock (existing)
+                {
+                    if (!existing.WasRemoved)
+                    {
+                        existing.Value = value;
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
         private void Cycle()
         {
             // There will be races when queue count == queue capacity. Two threads may each dequeue items.