diff --git a/BitFaster.Caching.UnitTests/ScopedAsyncCacheTestBase.cs b/BitFaster.Caching.UnitTests/ScopedAsyncCacheTestBase.cs
index be7cdd7b..02cbd16a 100644
--- a/BitFaster.Caching.UnitTests/ScopedAsyncCacheTestBase.cs
+++ b/BitFaster.Caching.UnitTests/ScopedAsyncCacheTestBase.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -169,6 +170,52 @@ public void WhenKeyExistsTryUpdateReturnsTrue()
             this.cache.TryUpdate(1, new Disposable()).Should().BeTrue();
         }
 
+        [Fact]
+        public void WhenItemsAddedKeysContainsTheKeys()
+        {
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, new Disposable());
+            cache.AddOrUpdate(2, new Disposable());
+            cache.Keys.Should().BeEquivalentTo(new[] { 1, 2 });
+        }
+
+        [Fact]
+        public void WhenItemsAddedGenericEnumerateContainsKvps()
+        {
+            var d1 = new Disposable();
+            var d2 = new Disposable();
+
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, d1);
+            cache.AddOrUpdate(2, d2);
+            cache
+                .Select(kvp => new KeyValuePair<int, Disposable>(kvp.Key, kvp.Value.CreateLifetime().Value))
+                .Should().BeEquivalentTo(new[] { new KeyValuePair<int, Disposable>(1, d1), new KeyValuePair<int, Disposable>(2, d2) });
+        }
+
+        [Fact]
+        public void WhenItemsAddedEnumerateContainsKvps()
+        {
+            var d1 = new Disposable();
+            var d2 = new Disposable();
+
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, d1);
+            cache.AddOrUpdate(2, d2);
+
+            var enumerable = (IEnumerable)cache;
+
+            var list = new List<KeyValuePair<int, Disposable>>();
+
+            foreach (var i in enumerable)
+            {
+                var kvp = (KeyValuePair<int, Scoped<Disposable>>)i;
+                list.Add(new KeyValuePair<int, Disposable>(kvp.Key, kvp.Value.CreateLifetime().Value));
+            }
+
+            list.Should().BeEquivalentTo(new[] { new KeyValuePair<int, Disposable>(1, d1), new KeyValuePair<int, Disposable>(2, d2) });
+        }
+
         protected void OnItemRemoved(object sender, ItemRemovedEventArgs<int, Scoped<Disposable>> e)
         {
             this.removedItems.Add(e);
diff --git a/BitFaster.Caching.UnitTests/ScopedCacheTestBase.cs b/BitFaster.Caching.UnitTests/ScopedCacheTestBase.cs
index 539fa390..1ac22135 100644
--- a/BitFaster.Caching.UnitTests/ScopedCacheTestBase.cs
+++ b/BitFaster.Caching.UnitTests/ScopedCacheTestBase.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -169,6 +170,52 @@ public void WhenKeyExistsTryUpdateReturnsTrue()
             this.cache.TryUpdate(1, new Disposable()).Should().BeTrue();
         }
 
+        [Fact]
+        public void WhenItemsAddedKeysContainsTheKeys()
+        {
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, new Disposable());
+            cache.AddOrUpdate(2, new Disposable());
+            cache.Keys.Should().BeEquivalentTo(new[] { 1, 2 });
+        }
+
+        [Fact]
+        public void WhenItemsAddedGenericEnumerateContainsKvps()
+        {
+            var d1 = new Disposable();
+            var d2 = new Disposable();
+
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, d1);
+            cache.AddOrUpdate(2, d2);
+            cache
+                .Select(kvp => new KeyValuePair<int, Disposable>(kvp.Key, kvp.Value.CreateLifetime().Value))
+                .Should().BeEquivalentTo(new[] { new KeyValuePair<int, Disposable>(1, d1), new KeyValuePair<int, Disposable>(2, d2) });
+        }
+
+        [Fact]
+        public void WhenItemsAddedEnumerateContainsKvps()
+        {
+            var d1 = new Disposable();
+            var d2 = new Disposable();
+
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, d1);
+            cache.AddOrUpdate(2, d2);
+
+            var enumerable = (IEnumerable)cache;
+
+            var list = new List<KeyValuePair<int, Disposable>>();
+
+            foreach (var i in enumerable)
+            {
+                var kvp = (KeyValuePair<int, Scoped<Disposable>>)i;
+                list.Add(new KeyValuePair<int, Disposable>(kvp.Key, kvp.Value.CreateLifetime().Value));
+            }
+
+            list.Should().BeEquivalentTo(new[] { new KeyValuePair<int, Disposable>(1, d1), new KeyValuePair<int, Disposable>(2, d2) });
+        }
+
         protected void OnItemRemoved(object sender, ItemRemovedEventArgs<int, Scoped<Disposable>> e)
         {
             this.removedItems.Add(e);
diff --git a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryAsyncCacheTests.cs b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryAsyncCacheTests.cs
index c4793d1b..152b19d4 100644
--- a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryAsyncCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryAsyncCacheTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -147,6 +148,35 @@ public void WhenKeyExistsTryUpdateReturnsTrue()
             value.Should().Be(2);
         }
 
+        [Fact]
+        public void WhenItemsAddedKeysContainsTheKeys()
+        {
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, 1);
+            cache.AddOrUpdate(2, 2);
+            cache.Keys.Should().BeEquivalentTo(new[] { 1, 2 });
+        }
+
+        [Fact]
+        public void WhenItemsAddedGenericEnumerateContainsKvps()
+        {
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, 1);
+            cache.AddOrUpdate(2, 2);
+            cache.Should().BeEquivalentTo(new[] { new KeyValuePair<int, int>(1, 1), new KeyValuePair<int, int>(2, 2) });
+        }
+
+        [Fact]
+        public void WhenItemsAddedEnumerateContainsKvps()
+        {
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, 1);
+            cache.AddOrUpdate(2, 2);
+
+            var enumerable = (IEnumerable)cache;
+            enumerable.Should().BeEquivalentTo(new[] { new KeyValuePair<int, int>(1, 1), new KeyValuePair<int, int>(2, 2) });
+        }
+
         private void OnItemRemoved(object sender, ItemRemovedEventArgs<int, int> e)
         {
             this.removedItems.Add(e);
diff --git a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryCacheTests.cs b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryCacheTests.cs
index 722882d1..10dc7611 100644
--- a/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/Synchronized/AtomicFactoryCacheTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -147,6 +148,35 @@ public void WhenKeyExistsTryUpdateReturnsTrue()
             value.Should().Be(2);
         }
 
+        [Fact]
+        public void WhenItemsAddedKeysContainsTheKeys()
+        {
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, 1);
+            cache.AddOrUpdate(2, 2);
+            cache.Keys.Should().BeEquivalentTo(new[] { 1, 2 });
+        }
+
+        [Fact]
+        public void WhenItemsAddedGenericEnumerateContainsKvps()
+        {
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, 1);
+            cache.AddOrUpdate(2, 2);
+            cache.Should().BeEquivalentTo(new[] { new KeyValuePair<int, int>(1, 1), new KeyValuePair<int, int>(2, 2) });
+        }
+
+        [Fact]
+        public void WhenItemsAddedEnumerateContainsKvps()
+        {
+            cache.Count.Should().Be(0);
+            cache.AddOrUpdate(1, 1);
+            cache.AddOrUpdate(2, 2);
+
+            var enumerable = (IEnumerable)cache;
+            enumerable.Should().BeEquivalentTo(new[] { new KeyValuePair<int, int>(1, 1), new KeyValuePair<int, int>(2, 2) });
+        }
+
         private void OnItemRemoved(object sender, ItemRemovedEventArgs<int, int> e)
         {
             this.removedItems.Add(e);
diff --git a/BitFaster.Caching/IAsyncCache.cs b/BitFaster.Caching/IAsyncCache.cs
index 7f837876..a5d46ecc 100644
--- a/BitFaster.Caching/IAsyncCache.cs
+++ b/BitFaster.Caching/IAsyncCache.cs
@@ -11,7 +11,7 @@ namespace BitFaster.Caching
     /// </summary>
     /// <typeparam name="K">The type of keys in the cache.</typeparam>
     /// <typeparam name="V">The type of values in the cache.</typeparam>
-    public interface IAsyncCache<K, V>
+    public interface IAsyncCache<K, V> : IEnumerable<KeyValuePair<K, V>>
     {
         /// <summary>
         /// Gets the total number of items that can be stored in the cache.
@@ -33,6 +33,11 @@ public interface IAsyncCache<K, V>
         /// </summary>
         ICacheEvents<K, V> Events { get; }
 
+        /// <summary>
+        /// Gets a collection containing the keys in the cache.
+        /// </summary>
+        ICollection<K> Keys { get; }
+
         /// <summary>
         /// Attempts to get the value associated with the specified key from the cache.
         /// </summary>
diff --git a/BitFaster.Caching/ICache.cs b/BitFaster.Caching/ICache.cs
index dbb9e892..5ecb804e 100644
--- a/BitFaster.Caching/ICache.cs
+++ b/BitFaster.Caching/ICache.cs
@@ -11,7 +11,7 @@ namespace BitFaster.Caching
     /// </summary>
     /// <typeparam name="K">The type of keys in the cache.</typeparam>
     /// <typeparam name="V">The type of values in the cache.</typeparam>
-    public interface ICache<K, V>
+    public interface ICache<K, V> : IEnumerable<KeyValuePair<K, V>>
     {
         /// <summary>
         /// Gets the total number of items that can be stored in the cache.
@@ -33,6 +33,11 @@ public interface ICache<K, V>
         /// </summary>
         ICacheEvents<K, V> Events { get; }
 
+        /// <summary>
+        /// Gets a collection containing the keys in the cache.
+        /// </summary>
+        ICollection<K> Keys { get; }
+
         /// <summary>
         /// Attempts to get the value associated with the specified key from the cache.
         /// </summary>
diff --git a/BitFaster.Caching/IScopedAsyncCache.cs b/BitFaster.Caching/IScopedAsyncCache.cs
index 32ba7150..ae5e08cd 100644
--- a/BitFaster.Caching/IScopedAsyncCache.cs
+++ b/BitFaster.Caching/IScopedAsyncCache.cs
@@ -11,7 +11,7 @@ namespace BitFaster.Caching
     /// </summary>
     /// <typeparam name="K">The type of keys in the cache.</typeparam>
     /// <typeparam name="V">The type of values in the cache.</typeparam>
-    public interface IScopedAsyncCache<K, V> where V : IDisposable
+    public interface IScopedAsyncCache<K, V> : IEnumerable<KeyValuePair<K, Scoped<V>>> where V : IDisposable
     {
         /// <summary>
         /// Gets the total number of items that can be stored in the cache.
@@ -37,6 +37,11 @@ public interface IScopedAsyncCache<K, V> where V : IDisposable
         /// </remarks>
         ICacheEvents<K, Scoped<V>> Events { get; }
 
+        /// <summary>
+        /// Gets a collection containing the keys in the cache.
+        /// </summary>
+        ICollection<K> Keys { get; }
+
         /// <summary>
         /// Attempts to create a lifetime for the value associated with the specified key from the cache
         /// </summary>
diff --git a/BitFaster.Caching/IScopedCache.cs b/BitFaster.Caching/IScopedCache.cs
index e06f11c1..7c3687d0 100644
--- a/BitFaster.Caching/IScopedCache.cs
+++ b/BitFaster.Caching/IScopedCache.cs
@@ -11,7 +11,7 @@ namespace BitFaster.Caching
     /// </summary>
     /// <typeparam name="K">The type of keys in the cache.</typeparam>
     /// <typeparam name="V">The type of values in the cache.</typeparam>
-    public interface IScopedCache<K, V> where V : IDisposable
+    public interface IScopedCache<K, V> : IEnumerable<KeyValuePair<K, Scoped<V>>> where V : IDisposable
     {
         /// <summary>
         /// Gets the total number of items that can be stored in the cache.
@@ -37,6 +37,11 @@ public interface IScopedCache<K, V> where V : IDisposable
         /// </remarks>
         ICacheEvents<K, Scoped<V>> Events { get; }
 
+        /// <summary>
+        /// Gets a collection containing the keys in the cache.
+        /// </summary>
+        ICollection<K> Keys { get; }
+
         /// <summary>
         /// Attempts to create a lifetime for the value associated with the specified key from the cache
         /// </summary>
diff --git a/BitFaster.Caching/ScopedAsyncCache.cs b/BitFaster.Caching/ScopedAsyncCache.cs
index f15dbe53..1fd00183 100644
--- a/BitFaster.Caching/ScopedAsyncCache.cs
+++ b/BitFaster.Caching/ScopedAsyncCache.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -40,6 +41,9 @@ public ScopedAsyncCache(IAsyncCache<K, Scoped<V>> cache)
         ///<inheritdoc/>
         public ICacheEvents<K, Scoped<V>> Events => this.cache.Events;
 
+        ///<inheritdoc/>
+        public ICollection<K> Keys => this.cache.Keys;
+
         ///<inheritdoc/>
         public void AddOrUpdate(K key, V value)
         {
@@ -107,5 +111,18 @@ public bool TryUpdate(K key, V value)
         {
             return this.cache.TryUpdate(key, new Scoped<V>(value));
         }
+
+        public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
+        {
+            foreach (var kvp in this.cache)
+            {
+                yield return kvp;
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((ScopedAsyncCache<K, V>)this).GetEnumerator();
+        }
     }
 }
diff --git a/BitFaster.Caching/ScopedCache.cs b/BitFaster.Caching/ScopedCache.cs
index 8d34e229..2c8476c0 100644
--- a/BitFaster.Caching/ScopedCache.cs
+++ b/BitFaster.Caching/ScopedCache.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -40,6 +41,9 @@ public ScopedCache(ICache<K, Scoped<V>> cache)
         ///<inheritdoc/>
         public ICacheEvents<K, Scoped<V>> Events => this.cache.Events;
 
+        ///<inheritdoc/>
+        public ICollection<K> Keys => this.cache.Keys;
+
         ///<inheritdoc/>
         public void AddOrUpdate(K key, V value)
         {
@@ -107,5 +111,18 @@ public bool TryUpdate(K key, V value)
         {
             return this.cache.TryUpdate(key, new Scoped<V>(value));
         }
+
+        public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
+        {
+            foreach (var kvp in this.cache)
+            {
+                yield return kvp;
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((ScopedCache<K, V>)this).GetEnumerator();
+        }
     }
 }
diff --git a/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs b/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs
index 467d7f6b..1c8d0cd3 100644
--- a/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs
+++ b/BitFaster.Caching/Synchronized/AtomicFactoryAsyncCache.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -30,6 +31,8 @@ public AtomicFactoryAsyncCache(ICache<K, AsyncAtomicFactory<K, V>> cache)
 
         public ICacheEvents<K, V> Events => this.eventProxy;
 
+        public ICollection<K> Keys => this.cache.Keys;
+
         public void AddOrUpdate(K key, V value)
         {
             cache.AddOrUpdate(key, new AsyncAtomicFactory<K, V>(value));
@@ -76,6 +79,19 @@ public bool TryUpdate(K key, V value)
             return cache.TryUpdate(key, new AsyncAtomicFactory<K, V>(value));
         }
 
+        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
+        {
+            foreach (var kvp in this.cache)
+            {
+                yield return new KeyValuePair<K, V>(kvp.Key, kvp.Value.ValueIfCreated);
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((AtomicFactoryAsyncCache<K, V>)this).GetEnumerator();
+        }
+
         private class EventProxy : CacheEventProxyBase<K, AsyncAtomicFactory<K, V>, V>
         {
             public EventProxy(ICacheEvents<K, AsyncAtomicFactory<K, V>> inner)
diff --git a/BitFaster.Caching/Synchronized/AtomicFactoryCache.cs b/BitFaster.Caching/Synchronized/AtomicFactoryCache.cs
index e84a74c3..1883dd6b 100644
--- a/BitFaster.Caching/Synchronized/AtomicFactoryCache.cs
+++ b/BitFaster.Caching/Synchronized/AtomicFactoryCache.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -30,6 +31,8 @@ public AtomicFactoryCache(ICache<K, AtomicFactory<K, V>> cache)
 
         public ICacheEvents<K, V> Events => this.eventProxy;
 
+        public ICollection<K> Keys => this.cache.Keys;
+
         public void AddOrUpdate(K key, V value)
         {
             this.cache.AddOrUpdate(key, new AtomicFactory<K, V>(value));
@@ -76,6 +79,19 @@ public bool TryUpdate(K key, V value)
             return cache.TryUpdate(key, new AtomicFactory<K, V>(value));
         }
 
+        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
+        {
+            foreach (var kvp in this.cache)
+            {
+                yield return new KeyValuePair<K, V>(kvp.Key, kvp.Value.ValueIfCreated);
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((AtomicFactoryCache<K, V>)this).GetEnumerator();
+        }
+
         private class EventProxy : CacheEventProxyBase<K, AtomicFactory<K, V>, V>
         {
             public EventProxy(ICacheEvents<K, AtomicFactory<K, V>> inner)
diff --git a/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs b/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs
index 9ce1ecc8..ffc802ce 100644
--- a/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs
+++ b/BitFaster.Caching/Synchronized/AtomicFactoryScopedAsyncCache.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -31,6 +32,9 @@ public AtomicFactoryScopedAsyncCache(ICache<K, ScopedAsyncAtomicFactory<K, V>> c
 
         public ICacheEvents<K, Scoped<V>> Events => this.eventProxy;
 
+        ///<inheritdoc/>
+        public ICollection<K> Keys => this.cache.Keys;
+
         public void AddOrUpdate(K key, V value)
         {
             this.cache.AddOrUpdate(key, new ScopedAsyncAtomicFactory<K, V>(value));
@@ -94,6 +98,19 @@ public bool TryUpdate(K key, V value)
             return this.cache.TryUpdate(key, new ScopedAsyncAtomicFactory<K, V>(value));
         }
 
+        public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
+        {
+            foreach (var kvp in this.cache)
+            {
+                yield return new KeyValuePair<K, Scoped<V>>(kvp.Key, kvp.Value.ScopeIfCreated);
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((AtomicFactoryScopedAsyncCache<K, V>)this).GetEnumerator();
+        }
+
         private class EventProxy : CacheEventProxyBase<K, ScopedAsyncAtomicFactory<K, V>, Scoped<V>>
         {
             public EventProxy(ICacheEvents<K, ScopedAsyncAtomicFactory<K, V>> inner)
diff --git a/BitFaster.Caching/Synchronized/AtomicFactoryScopedCache.cs b/BitFaster.Caching/Synchronized/AtomicFactoryScopedCache.cs
index 746d7670..309cf56f 100644
--- a/BitFaster.Caching/Synchronized/AtomicFactoryScopedCache.cs
+++ b/BitFaster.Caching/Synchronized/AtomicFactoryScopedCache.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -31,6 +32,9 @@ public AtomicFactoryScopedCache(ICache<K, ScopedAtomicFactory<K, V>> cache)
 
         public ICacheEvents<K, Scoped<V>> Events => this.eventProxy;
 
+        ///<inheritdoc/>
+        public ICollection<K> Keys => this.cache.Keys;
+
         public void AddOrUpdate(K key, V value)
         {
             this.cache.AddOrUpdate(key, new ScopedAtomicFactory<K, V>(value));
@@ -92,6 +96,19 @@ public bool TryUpdate(K key, V value)
             return this.cache.TryUpdate(key, new ScopedAtomicFactory<K, V>(value));
         }
 
+        public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
+        {
+            foreach (var kvp in this.cache)
+            {
+                yield return new KeyValuePair<K, Scoped<V>>(kvp.Key, kvp.Value.ScopeIfCreated);
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((AtomicFactoryScopedCache<K, V>)this).GetEnumerator();
+        }
+
         private class EventProxy : CacheEventProxyBase<K, ScopedAtomicFactory<K, V>, Scoped<V>>
         {
             public EventProxy(ICacheEvents<K, ScopedAtomicFactory<K, V>> inner)