Cache implements IEnumerable<KeyValuePair<K, V>> (#114)

* enumerator

* classic

Author: bitfaster

BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs

@@ -6,6 +6,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using Xunit;
+using System.Collections;
 
 namespace BitFaster.Caching.UnitTests.Lru
 {
@@ -65,6 +66,26 @@ public void WhenItemsAddedKeysContainsTheKeys()
             lru.Keys.Should().BeEquivalentTo(new[] { 1, 2 });
         }
 
+        [Fact]
+        public void WhenItemsAddedGenericEnumerateContainsKvps()
+        {
+            lru.Count.Should().Be(0);
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+            lru.Should().BeEquivalentTo(new[] { new KeyValuePair<int, string>(1, "1"), new KeyValuePair<int, string>(2, "2") });
+        }
+
+        [Fact]
+        public void WhenItemsAddedEnumerateContainsKvps()
+        {
+            lru.Count.Should().Be(0);
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+
+            var enumerable = (IEnumerable)lru;
+            enumerable.Should().BeEquivalentTo(new[] { new KeyValuePair<int, string>(1, "1"), new KeyValuePair<int, string>(2, "2") });
+        }
+
         [Fact]
         public void WhenItemExistsTryGetReturnsValueAndTrue()
         {

BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs

@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 using Xunit;
 using Xunit.Abstractions;
+using System.Collections;
 
 namespace BitFaster.Caching.UnitTests.Lru
 {
@@ -117,6 +118,26 @@ public void WhenItemsAddedKeysContainsTheKeys()
             lru.Keys.Should().BeEquivalentTo(new[] { 1, 2 });
         }
 
+        [Fact]
+        public void WhenItemsAddedGenericEnumerateContainsKvps()
+        {
+            lru.Count.Should().Be(0);
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+            lru.Should().BeEquivalentTo(new[] { new KeyValuePair<int, string>(1, "1"), new KeyValuePair<int, string>(2, "2") });
+        }
+
+        [Fact]
+        public void WhenItemsAddedEnumerateContainsKvps()
+        {
+            lru.Count.Should().Be(0);
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+
+            var enumerable = (IEnumerable)lru;
+            enumerable.Should().BeEquivalentTo(new[] { new KeyValuePair<int, string>(1, "1"), new KeyValuePair<int, string>(2, "2") });
+        }
+
         [Fact]
         public void WhenItemExistsTryGetReturnsValueAndTrue()
         {

BitFaster.Caching/Lru/ClassicLru.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
@@ -17,7 +18,7 @@ namespace BitFaster.Caching.Lru
     /// </remarks>
     /// <typeparam name="K">The type of the key</typeparam>
     /// <typeparam name="V">The type of the value</typeparam>
-    public sealed class ClassicLru<K, V> : ICache<K, V>
+    public sealed class ClassicLru<K, V> : ICache<K, V>, IEnumerable<KeyValuePair<K, V>>
     {
         private readonly int capacity;
         private readonly ConcurrentDictionary<K, LinkedListNode<LruItem>> dictionary;
@@ -59,6 +60,22 @@ public ClassicLru(int concurrencyLevel, int capacity, IEqualityComparer<K> compa
         /// </summary>
         public ICollection<K> Keys => this.dictionary.Keys;
 
+        /// <summary>Returns an enumerator that iterates through the cache.</summary>
+        /// <returns>An enumerator for the cache.</returns>
+        /// <remarks>
+        /// The enumerator returned from the cache is safe to use concurrently with
+        /// reads and writes, however it does not represent a moment-in-time snapshot.  
+        /// The contents exposed through the enumerator may contain modifications
+        /// made after <see cref="GetEnumerator"/> was called.
+        /// </remarks>
+        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
+        {
+            foreach (var kvp in this.dictionary)
+            {
+                yield return new KeyValuePair<K, V>(kvp.Key, kvp.Value.Value.Value);
+            }
+        }
+
         ///<inheritdoc/>
         public bool TryGet(K key, out V value)
         {
@@ -289,6 +306,19 @@ private void LockAndMoveToEnd(LinkedListNode<LruItem> node)
             }
         }
 
+        /// <summary>Returns an enumerator that iterates through the cache.</summary>
+        /// <returns>An enumerator for the cache.</returns>
+        /// <remarks>
+        /// The enumerator returned from the cache is safe to use concurrently with
+        /// reads and writes, however it does not represent a moment-in-time snapshot.  
+        /// The contents exposed through the enumerator may contain modifications
+        /// made after <see cref="GetEnumerator"/> was called.
+        /// </remarks>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((ClassicLru<K, V>)this).GetEnumerator();
+        }
+
         private class LruItem
         {
             public LruItem(K k, V v)

BitFaster.Caching/Lru/TemplateConcurrentLru.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
@@ -27,7 +28,7 @@ namespace BitFaster.Caching.Lru
     /// 5. When warm is full, warm tail is moved to warm head or cold depending on WasAccessed.
     /// 6. When cold is full, cold tail is moved to warm head or removed from dictionary on depending on WasAccessed.
     /// </remarks>
-    public class TemplateConcurrentLru<K, V, I, P, T> : ICache<K, V>
+    public class TemplateConcurrentLru<K, V, I, P, T> : ICache<K, V>, IEnumerable<KeyValuePair<K, V>>
         where I : LruItem<K, V>
         where P : struct, IItemPolicy<K, V, I>
         where T : struct, ITelemetryPolicy<K, V>
@@ -101,6 +102,23 @@ public TemplateConcurrentLru(
         /// </summary>
         public ICollection<K> Keys => this.dictionary.Keys;
 
+
+        /// <summary>Returns an enumerator that iterates through the cache.</summary>
+        /// <returns>An enumerator for the cache.</returns>
+        /// <remarks>
+        /// The enumerator returned from the cache is safe to use concurrently with
+        /// reads and writes, however it does not represent a moment-in-time snapshot.  
+        /// The contents exposed through the enumerator may contain modifications
+        /// made after <see cref="GetEnumerator"/> was called.
+        /// </remarks>
+        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
+        {
+            foreach (var kvp in this.dictionary)
+            {
+                yield return new KeyValuePair<K, V>(kvp.Key, kvp.Value.Value);
+            }
+        }
+
         ///<inheritdoc/>
         public bool TryGet(K key, out V value)
         {
@@ -464,5 +482,18 @@ private static (int hot, int warm, int cold) ComputeQueueCapacity(int capacity)
 
             return (hotCapacity, warmCapacity, coldCapacity);
         }
+
+        /// <summary>Returns an enumerator that iterates through the cache.</summary>
+        /// <returns>An enumerator for the cache.</returns>
+        /// <remarks>
+        /// The enumerator returned from the cache is safe to use concurrently with
+        /// reads and writes, however it does not represent a moment-in-time snapshot.  
+        /// The contents exposed through the enumerator may contain modifications
+        /// made after <see cref="GetEnumerator"/> was called.
+        /// </remarks>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((TemplateConcurrentLru<K, V, I, P, T>)this).GetEnumerator();
+        }
     }
 }