diff --git a/BitFaster.Caching.UnitTests/Atomic/AsyncAtomicFactoryTests.cs b/BitFaster.Caching.UnitTests/Atomic/AsyncAtomicFactoryTests.cs
index 08f3c297..fdb8a6f8 100644
--- a/BitFaster.Caching.UnitTests/Atomic/AsyncAtomicFactoryTests.cs
+++ b/BitFaster.Caching.UnitTests/Atomic/AsyncAtomicFactoryTests.cs
@@ -1,169 +1,169 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using BitFaster.Caching.Atomic;
-using FluentAssertions;
-using Xunit;
-
-namespace BitFaster.Caching.UnitTests.Atomic
-{
-    public class AsyncAtomicFactoryTests
-    {
-        [Fact]
-        public void DefaultCtorValueIsNotCreated()
-        {
-            var a = new AsyncAtomicFactory<int, int>();
-
-            a.IsValueCreated.Should().BeFalse();
-            a.ValueIfCreated.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenValuePassedToCtorValueIsStored()
-        {
-            var a = new AsyncAtomicFactory<int, int>(1);
-
-            a.ValueIfCreated.Should().Be(1);
-            a.IsValueCreated.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task WhenValueCreatedValueReturned()
-        {
-            var a = new AsyncAtomicFactory<int, int>();
-            (await a.GetValueAsync(1, k => Task.FromResult(2))).Should().Be(2);
-
-            a.ValueIfCreated.Should().Be(2);
-            a.IsValueCreated.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task WhenValueCreatedWithArgValueReturned()
-        {
-            var a = new AsyncAtomicFactory<int, int>();
-            (await a.GetValueAsync(1, (k, a) => Task.FromResult(k + a), 7)).Should().Be(8);
-
-            a.ValueIfCreated.Should().Be(8);
-            a.IsValueCreated.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task WhenValueCreatedGetValueReturnsOriginalValue()
-        {
-            var a = new AsyncAtomicFactory<int, int>();
-            await a.GetValueAsync(1, k => Task.FromResult(2));
-            (await a.GetValueAsync(1, k => Task.FromResult(3))).Should().Be(2);
-        }
-
-        [Fact]
-        public async Task WhenValueCreatedArgGetValueReturnsOriginalValue()
-        {
-            var a = new AsyncAtomicFactory<int, int>();
-            await a.GetValueAsync(1, (k, a) => Task.FromResult(k + a), 7);
-            (await a.GetValueAsync(1, (k, a) => Task.FromResult(k + a), 9)).Should().Be(8);
-        }
-
-        [Fact]
-        public async Task WhenValueCreateThrowsValueIsNotStored()
-        {
-            var a = new AsyncAtomicFactory<int, int>();
-
-            Func<Task> getOrAdd = async () => { await a.GetValueAsync(1, k => throw new ArithmeticException()); };
-
-            await getOrAdd.Should().ThrowAsync<ArithmeticException>();
-
-            (await a.GetValueAsync(1, k => Task.FromResult(3))).Should().Be(3);
-        }
-
-        [Fact]
-        public async Task WhenCallersRunConcurrentlyResultIsFromWinner()
-        {
-            var enter = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-            var resume = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-            var atomicFactory = new AsyncAtomicFactory<int, int>();
-            var result = 0;
-            var winnerCount = 0;
-
-            var first = atomicFactory.GetValueAsync(1, async k =>
-            {
-                enter.SetResult(true);
-                await resume.Task;
-
-                result = 1;
-                Interlocked.Increment(ref winnerCount);
-                return 1;
-            });
-
-            var second = atomicFactory.GetValueAsync(1, async k =>
-            {
-                enter.SetResult(true);
-                await resume.Task;
-
-                result = 2;
-                Interlocked.Increment(ref winnerCount);
-                return 2;
-            });
-
-            await enter.Task;
-            resume.SetResult(true);
-
-            (await first).Should().Be(result);
-            (await second).Should().Be(result);
-
-            winnerCount.Should().Be(1);
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using BitFaster.Caching.Atomic;
+using FluentAssertions;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests.Atomic
+{
+    public class AsyncAtomicFactoryTests
+    {
+        [Fact]
+        public void DefaultCtorValueIsNotCreated()
+        {
+            var a = new AsyncAtomicFactory<int, int>();
+
+            a.IsValueCreated.Should().BeFalse();
+            a.ValueIfCreated.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenValuePassedToCtorValueIsStored()
+        {
+            var a = new AsyncAtomicFactory<int, int>(1);
+
+            a.ValueIfCreated.Should().Be(1);
+            a.IsValueCreated.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task WhenValueCreatedValueReturned()
+        {
+            var a = new AsyncAtomicFactory<int, int>();
+            (await a.GetValueAsync(1, k => Task.FromResult(2))).Should().Be(2);
+
+            a.ValueIfCreated.Should().Be(2);
+            a.IsValueCreated.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task WhenValueCreatedWithArgValueReturned()
+        {
+            var a = new AsyncAtomicFactory<int, int>();
+            (await a.GetValueAsync(1, (k, a) => Task.FromResult(k + a), 7)).Should().Be(8);
+
+            a.ValueIfCreated.Should().Be(8);
+            a.IsValueCreated.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task WhenValueCreatedGetValueReturnsOriginalValue()
+        {
+            var a = new AsyncAtomicFactory<int, int>();
+            await a.GetValueAsync(1, k => Task.FromResult(2));
+            (await a.GetValueAsync(1, k => Task.FromResult(3))).Should().Be(2);
+        }
+
+        [Fact]
+        public async Task WhenValueCreatedArgGetValueReturnsOriginalValue()
+        {
+            var a = new AsyncAtomicFactory<int, int>();
+            await a.GetValueAsync(1, (k, a) => Task.FromResult(k + a), 7);
+            (await a.GetValueAsync(1, (k, a) => Task.FromResult(k + a), 9)).Should().Be(8);
+        }
+
+        [Fact]
+        public async Task WhenValueCreateThrowsValueIsNotStored()
+        {
+            var a = new AsyncAtomicFactory<int, int>();
+
+            Func<Task> getOrAdd = async () => { await a.GetValueAsync(1, k => throw new ArithmeticException()); };
+
+            await getOrAdd.Should().ThrowAsync<ArithmeticException>();
+
+            (await a.GetValueAsync(1, k => Task.FromResult(3))).Should().Be(3);
+        }
+
+        [Fact]
+        public async Task WhenCallersRunConcurrentlyResultIsFromWinner()
+        {
+            var enter = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+            var resume = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            var atomicFactory = new AsyncAtomicFactory<int, int>();
+            var result = 0;
+            var winnerCount = 0;
+
+            var first = atomicFactory.GetValueAsync(1, async k =>
+            {
+                enter.SetResult(true);
+                await resume.Task;
+
+                result = 1;
+                Interlocked.Increment(ref winnerCount);
+                return 1;
+            });
+
+            var second = atomicFactory.GetValueAsync(1, async k =>
+            {
+                enter.SetResult(true);
+                await resume.Task;
+
+                result = 2;
+                Interlocked.Increment(ref winnerCount);
+                return 2;
+            });
+
+            await enter.Task;
+            resume.SetResult(true);
+
+            (await first).Should().Be(result);
+            (await second).Should().Be(result);
+
+            winnerCount.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenValueNotCreatedHashCodeIsZero()
+        {
+            new AsyncAtomicFactory<int, int>()
+                .GetHashCode()
+                .Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenValueCreatedHashCodeIsValueHashCode()
+        {
+            new AsyncAtomicFactory<int, int>(1)
+                .GetHashCode()
+                .Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenValueNotCreatedEqualsFalse()
+        {
+            var a = new AsyncAtomicFactory<int, int>();
+            var b = new AsyncAtomicFactory<int, int>();
+
+            a.Equals(b).Should().BeFalse();
         }
 
-        [Fact]
-        public void WhenValueNotCreatedHashCodeIsZero()
-        {
-            new AsyncAtomicFactory<int, int>()
-                .GetHashCode()
-                .Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenValueCreatedHashCodeIsValueHashCode()
-        {
-            new AsyncAtomicFactory<int, int>(1)
-                .GetHashCode()
-                .Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenValueNotCreatedEqualsFalse()
-        {
-            var a = new AsyncAtomicFactory<int, int>();
-            var b = new AsyncAtomicFactory<int, int>();
-
-            a.Equals(b).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenOtherValueNotCreatedEqualsFalse()
-        {
-            var a = new AsyncAtomicFactory<int, int>(1);
-            var b = new AsyncAtomicFactory<int, int>();
-
-            a.Equals(b).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenArgNullEqualsFalse()
-        {
-            new AsyncAtomicFactory<int, int>(1)
-                .Equals(null)
-                .Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenArgObjectValuesAreSameEqualsTrue()
-        {
-            object other = new AsyncAtomicFactory<int, int>(1);
-
-            new AsyncAtomicFactory<int, int>(1)
-                .Equals(other)
-                .Should().BeTrue();
-        }
-    }
-}
+        [Fact]
+        public void WhenOtherValueNotCreatedEqualsFalse()
+        {
+            var a = new AsyncAtomicFactory<int, int>(1);
+            var b = new AsyncAtomicFactory<int, int>();
+
+            a.Equals(b).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenArgNullEqualsFalse()
+        {
+            new AsyncAtomicFactory<int, int>(1)
+                .Equals(null)
+                .Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenArgObjectValuesAreSameEqualsTrue()
+        {
+            object other = new AsyncAtomicFactory<int, int>(1);
+
+            new AsyncAtomicFactory<int, int>(1)
+                .Equals(other)
+                .Should().BeTrue();
+        }
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryAsyncCacheTests.cs b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryAsyncCacheTests.cs
index d2b58d96..4dca7fbe 100644
--- a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryAsyncCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryAsyncCacheTests.cs
@@ -1,316 +1,316 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using BitFaster.Caching.Lru;
-using BitFaster.Caching.Atomic;
-using FluentAssertions;
-using Xunit;
-using Moq;
-
-namespace BitFaster.Caching.UnitTests.Atomic
-{
-    public class AtomicFactoryAsyncCacheTests
-    {
-        private const int capacity = 6;
-        private readonly ConcurrentLru<int, AsyncAtomicFactory<int, int>> innerCache = new(capacity);
-        private readonly AtomicFactoryAsyncCache<int, int> cache;
-
-        private List<ItemRemovedEventArgs<int, int>> removedItems = new();
-        private List<ItemUpdatedEventArgs<int, int>> updatedItems = new();
-
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using BitFaster.Caching.Lru;
+using BitFaster.Caching.Atomic;
+using FluentAssertions;
+using Xunit;
+using Moq;
+
+namespace BitFaster.Caching.UnitTests.Atomic
+{
+    public class AtomicFactoryAsyncCacheTests
+    {
+        private const int capacity = 6;
+        private readonly ConcurrentLru<int, AsyncAtomicFactory<int, int>> innerCache = new(capacity);
+        private readonly AtomicFactoryAsyncCache<int, int> cache;
+
+        private List<ItemRemovedEventArgs<int, int>> removedItems = new();
+        private List<ItemUpdatedEventArgs<int, int>> updatedItems = new();
+
         public AtomicFactoryAsyncCacheTests()
         {
-            cache = new(innerCache);
-        }
-
-        [Fact]
-        public void WhenInnerCacheIsNullCtorThrows()
-        {
-            Action constructor = () => { var x = new AtomicFactoryAsyncCache<int, int>(null); };
-
-            constructor.Should().Throw<ArgumentNullException>();
-        }
-
-        [Fact]
-        public void WhenCreatedCapacityPropertyWrapsInnerCache()
-        {
-            this.cache.Policy.Eviction.Value.Capacity.Should().Be(capacity);
-        }
-
-        [Fact]
-        public void WhenItemIsAddedCountIsCorrect()
-        {
-            this.cache.Count.Should().Be(0);
-
-            this.cache.AddOrUpdate(2, 2);
-
-            this.cache.Count.Should().Be(1);
-        }
-
-        [Fact]
-        public async Task WhenItemIsAddedThenLookedUpMetricsAreCorrect()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            await this.cache.GetOrAddAsync(1, k => Task.FromResult(k));
-
-            this.cache.Metrics.Value.Misses.Should().Be(0);
-            this.cache.Metrics.Value.Hits.Should().Be(1);
-        }
-
-        [Fact]
-        public async Task WhenItemIsAddedWithArgValueIsCorrect()
-        {
-            await this.cache.GetOrAddAsync(1, (k, a) => Task.FromResult(k + a), 2);
-
-            this.cache.TryGet(1, out var value).Should().BeTrue();
-            value.Should().Be(3);
-        }
-
-        [Fact]
-        public void WhenNoInnerEventsNoOuterEvents()
-        {
-            var inner = new Mock<ICache<int, AsyncAtomicFactory<int, int>>>();
-            inner.SetupGet(c => c.Events).Returns(Optional<ICacheEvents<int, AsyncAtomicFactory<int, int>>>.None);
-
-            var cache = new AtomicFactoryAsyncCache<int, int>(inner.Object);
-
-            cache.Events.HasValue.Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenRemovedEventHandlerIsRegisteredItIsFired()
-        {
-            this.cache.Events.Value.ItemRemoved += OnItemRemoved;
-
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(1);
-
-            this.removedItems.First().Key.Should().Be(1);
-        }
-
-// backcompat: remove conditional compile
-#if NETCOREAPP3_0_OR_GREATER
-        [Fact]
-        public void WhenUpdatedEventHandlerIsRegisteredItIsFired()
-        {
-            this.cache.Events.Value.ItemUpdated += OnItemUpdated;
-
-            this.cache.AddOrUpdate(1, 2);
-            this.cache.AddOrUpdate(1, 3);
-
-            this.updatedItems.First().Key.Should().Be(1);
-            this.updatedItems.First().OldValue.Should().Be(2);
-            this.updatedItems.First().NewValue.Should().Be(3);
-        }
-#endif
-
-        [Fact]
-        public void WhenKeyDoesNotExistAddOrUpdateAddsNewItem()
-        {
-            this.cache.AddOrUpdate(1, 1);
-
-            this.cache.TryGet(1, out var value).Should().BeTrue();
-            value.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenKeyExistsAddOrUpdateUpdatesExistingItem()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.AddOrUpdate(1, 2);
-
-            this.cache.TryGet(1, out var value).Should().BeTrue();
-            value.Should().Be(2);
-        }
-
-        [Fact]
-        public void WhenClearedItemsAreRemoved()
-        {
-            this.cache.AddOrUpdate(1, 1);
-
-            this.cache.Clear();
-
-            this.cache.Count.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenItemDoesNotExistTryGetReturnsFalse()
-        {
-            this.cache.TryGet(1, out var value).Should().BeFalse();
-        }
-
-        [Fact]
-        public async Task WhenKeyDoesNotExistGetOrAddAsyncAddsValue()
-        {
-            await this.cache.GetOrAddAsync(1, k => Task.FromResult(k));
-
-            this.cache.TryGet(1, out var value).Should().BeTrue();
-            value.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenCacheContainsValuesTrim1RemovesColdestValue()
-        {
-            this.cache.AddOrUpdate(0, 0);
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.AddOrUpdate(2, 2);
-
-            this.cache.Policy.Eviction.Value.Trim(1);
-
-            this.cache.TryGet(0, out var value).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenKeyDoesNotExistTryRemoveReturnsFalse()
-        {
-            this.cache.TryRemove(1).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenKeyExistsTryRemoveReturnsTrue()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(1).Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenKeyDoesNotExistTryUpdateReturnsFalse()
-        {
-            this.cache.TryUpdate(1, 1).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenKeyExistsTryUpdateReturnsTrue()
-        {
-            this.cache.AddOrUpdate(1, 1);
-
-            this.cache.TryUpdate(1, 2).Should().BeTrue();
-            this.cache.TryGet(1, out var value);
-            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) });
-        }
-
-        [Fact]
-        public async Task WhenFactoryThrowsEmptyValueIsNotCounted()
-        {
-            try
-            {
-                await cache.GetOrAddAsync(1, k => throw new ArithmeticException());
-            }
-            catch { }
-
-            cache.Count.Should().Be(0);
-        }
-
-        [Fact]
-        public async Task WhenFactoryThrowsEmptyValueIsNotEnumerable()
-        {
-            try
-            {
-                await cache.GetOrAddAsync(1, k => throw new ArithmeticException());
-            }
-            catch { }
-
-            // IEnumerable.Count() instead of Count property
-            cache.Count().Should().Be(0);
-        }
-
-        [Fact]
-        public async Task WhenFactoryThrowsEmptyKeyIsNotEnumerable()
-        {
-            try
-            {
-                await cache.GetOrAddAsync(1, k => throw new ArithmeticException());
-            }
-            catch { }
-
-            cache.Keys.Count().Should().Be(0);
+            cache = new(innerCache);
+        }
+
+        [Fact]
+        public void WhenInnerCacheIsNullCtorThrows()
+        {
+            Action constructor = () => { var x = new AtomicFactoryAsyncCache<int, int>(null); };
+
+            constructor.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WhenCreatedCapacityPropertyWrapsInnerCache()
+        {
+            this.cache.Policy.Eviction.Value.Capacity.Should().Be(capacity);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedCountIsCorrect()
+        {
+            this.cache.Count.Should().Be(0);
+
+            this.cache.AddOrUpdate(2, 2);
+
+            this.cache.Count.Should().Be(1);
+        }
+
+        [Fact]
+        public async Task WhenItemIsAddedThenLookedUpMetricsAreCorrect()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            await this.cache.GetOrAddAsync(1, k => Task.FromResult(k));
+
+            this.cache.Metrics.Value.Misses.Should().Be(0);
+            this.cache.Metrics.Value.Hits.Should().Be(1);
+        }
+
+        [Fact]
+        public async Task WhenItemIsAddedWithArgValueIsCorrect()
+        {
+            await this.cache.GetOrAddAsync(1, (k, a) => Task.FromResult(k + a), 2);
+
+            this.cache.TryGet(1, out var value).Should().BeTrue();
+            value.Should().Be(3);
+        }
+
+        [Fact]
+        public void WhenNoInnerEventsNoOuterEvents()
+        {
+            var inner = new Mock<ICache<int, AsyncAtomicFactory<int, int>>>();
+            inner.SetupGet(c => c.Events).Returns(Optional<ICacheEvents<int, AsyncAtomicFactory<int, int>>>.None);
+
+            var cache = new AtomicFactoryAsyncCache<int, int>(inner.Object);
+
+            cache.Events.HasValue.Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenRemovedEventHandlerIsRegisteredItIsFired()
+        {
+            this.cache.Events.Value.ItemRemoved += OnItemRemoved;
+
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(1);
+
+            this.removedItems.First().Key.Should().Be(1);
+        }
+
+// backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        [Fact]
+        public void WhenUpdatedEventHandlerIsRegisteredItIsFired()
+        {
+            this.cache.Events.Value.ItemUpdated += OnItemUpdated;
+
+            this.cache.AddOrUpdate(1, 2);
+            this.cache.AddOrUpdate(1, 3);
+
+            this.updatedItems.First().Key.Should().Be(1);
+            this.updatedItems.First().OldValue.Should().Be(2);
+            this.updatedItems.First().NewValue.Should().Be(3);
+        }
+#endif
+
+        [Fact]
+        public void WhenKeyDoesNotExistAddOrUpdateAddsNewItem()
+        {
+            this.cache.AddOrUpdate(1, 1);
+
+            this.cache.TryGet(1, out var value).Should().BeTrue();
+            value.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenKeyExistsAddOrUpdateUpdatesExistingItem()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.AddOrUpdate(1, 2);
+
+            this.cache.TryGet(1, out var value).Should().BeTrue();
+            value.Should().Be(2);
+        }
+
+        [Fact]
+        public void WhenClearedItemsAreRemoved()
+        {
+            this.cache.AddOrUpdate(1, 1);
+
+            this.cache.Clear();
+
+            this.cache.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenItemDoesNotExistTryGetReturnsFalse()
+        {
+            this.cache.TryGet(1, out var value).Should().BeFalse();
+        }
+
+        [Fact]
+        public async Task WhenKeyDoesNotExistGetOrAddAsyncAddsValue()
+        {
+            await this.cache.GetOrAddAsync(1, k => Task.FromResult(k));
+
+            this.cache.TryGet(1, out var value).Should().BeTrue();
+            value.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenCacheContainsValuesTrim1RemovesColdestValue()
+        {
+            this.cache.AddOrUpdate(0, 0);
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.AddOrUpdate(2, 2);
+
+            this.cache.Policy.Eviction.Value.Trim(1);
+
+            this.cache.TryGet(0, out var value).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryRemoveReturnsFalse()
+        {
+            this.cache.TryRemove(1).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyExistsTryRemoveReturnsTrue()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(1).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryUpdateReturnsFalse()
+        {
+            this.cache.TryUpdate(1, 1).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyExistsTryUpdateReturnsTrue()
+        {
+            this.cache.AddOrUpdate(1, 1);
+
+            this.cache.TryUpdate(1, 2).Should().BeTrue();
+            this.cache.TryGet(1, out var value);
+            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) });
+        }
+
+        [Fact]
+        public async Task WhenFactoryThrowsEmptyValueIsNotCounted()
+        {
+            try
+            {
+                await cache.GetOrAddAsync(1, k => throw new ArithmeticException());
+            }
+            catch { }
+
+            cache.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public async Task WhenFactoryThrowsEmptyValueIsNotEnumerable()
+        {
+            try
+            {
+                await cache.GetOrAddAsync(1, k => throw new ArithmeticException());
+            }
+            catch { }
+
+            // IEnumerable.Count() instead of Count property
+            cache.Count().Should().Be(0);
+        }
+
+        [Fact]
+        public async Task WhenFactoryThrowsEmptyKeyIsNotEnumerable()
+        {
+            try
+            {
+                await cache.GetOrAddAsync(1, k => throw new ArithmeticException());
+            }
+            catch { }
+
+            cache.Keys.Count().Should().Be(0);
         }
 
        // backcompat: remove conditional compile
-#if NETCOREAPP3_0_OR_GREATER
-        [Fact]
-        public void WhenRemovedValueIsReturned()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(1, out var value);
-
-            value.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenNotRemovedValueIsDefault()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(2, out var value);
-
-            value.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenRemoveKeyValueAndValueDoesntMatchDontRemove()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(new KeyValuePair<int, int>(1, 2)).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenRemoveKeyValueAndValueDoesMatchThenRemove()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(new KeyValuePair<int, int>(1, 1)).Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenRemoveKeyValueAndValueIsNotCreatedDoesNotRemove()
-        {
-            // seed the inner cache with an not yet created value
-            this.innerCache.AddOrUpdate(1, new AsyncAtomicFactory<int, int>());
-
-            // try to remove with the default value (0)
-            this.cache.TryRemove(new KeyValuePair<int, int>(1, 0)).Should().BeFalse();
-        }
-#endif
-
-        private void OnItemRemoved(object sender, ItemRemovedEventArgs<int, int> e)
-        {
-            this.removedItems.Add(e);
-        }
-
-        private void OnItemUpdated(object sender, ItemUpdatedEventArgs<int, int> e)
-        {
-            this.updatedItems.Add(e);
-        }
-    }
-}
+#if NETCOREAPP3_0_OR_GREATER
+        [Fact]
+        public void WhenRemovedValueIsReturned()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(1, out var value);
+
+            value.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenNotRemovedValueIsDefault()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(2, out var value);
+
+            value.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenRemoveKeyValueAndValueDoesntMatchDontRemove()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(new KeyValuePair<int, int>(1, 2)).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenRemoveKeyValueAndValueDoesMatchThenRemove()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(new KeyValuePair<int, int>(1, 1)).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenRemoveKeyValueAndValueIsNotCreatedDoesNotRemove()
+        {
+            // seed the inner cache with an not yet created value
+            this.innerCache.AddOrUpdate(1, new AsyncAtomicFactory<int, int>());
+
+            // try to remove with the default value (0)
+            this.cache.TryRemove(new KeyValuePair<int, int>(1, 0)).Should().BeFalse();
+        }
+#endif
+
+        private void OnItemRemoved(object sender, ItemRemovedEventArgs<int, int> e)
+        {
+            this.removedItems.Add(e);
+        }
+
+        private void OnItemUpdated(object sender, ItemUpdatedEventArgs<int, int> e)
+        {
+            this.updatedItems.Add(e);
+        }
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryCacheTests.cs b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryCacheTests.cs
index 8c047ec6..0c8bd66c 100644
--- a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryCacheTests.cs
@@ -1,311 +1,311 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using BitFaster.Caching.Lru;
-using BitFaster.Caching.Atomic;
-using FluentAssertions;
-using Xunit;
-using Moq;
-
-namespace BitFaster.Caching.UnitTests.Atomic
-{
-    public class AtomicFactoryCacheTests
-    {
-        private const int capacity = 6;
-        private readonly ConcurrentLru<int, AtomicFactory<int, int>> innerCache;
-        private readonly AtomicFactoryCache<int, int> cache;
-
-        private List<ItemRemovedEventArgs<int, int>> removedItems = new();
-        private List<ItemUpdatedEventArgs<int, int>> updatedItems = new();
-
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using BitFaster.Caching.Lru;
+using BitFaster.Caching.Atomic;
+using FluentAssertions;
+using Xunit;
+using Moq;
+
+namespace BitFaster.Caching.UnitTests.Atomic
+{
+    public class AtomicFactoryCacheTests
+    {
+        private const int capacity = 6;
+        private readonly ConcurrentLru<int, AtomicFactory<int, int>> innerCache;
+        private readonly AtomicFactoryCache<int, int> cache;
+
+        private List<ItemRemovedEventArgs<int, int>> removedItems = new();
+        private List<ItemUpdatedEventArgs<int, int>> updatedItems = new();
+
         public AtomicFactoryCacheTests()
         {
             innerCache = new ConcurrentLru<int, AtomicFactory<int, int>>(capacity);
-            cache = new(innerCache);
-        }
-
-        [Fact]
-        public void WhenInnerCacheIsNullCtorThrows()
-        {
-            Action constructor = () => { var x = new AtomicFactoryCache<int, int>(null); };
-
-            constructor.Should().Throw<ArgumentNullException>();
-        }
-
-        [Fact]
-        public void WhenCreatedCapacityPropertyWrapsInnerCache()
-        {
-            this.cache.Policy.Eviction.Value.Capacity.Should().Be(capacity);
-        }
-
-        [Fact]
-        public void WhenItemIsAddedCountIsCorrect()
-        {
-            this.cache.Count.Should().Be(0);
-
-            this.cache.AddOrUpdate(2, 2);
-
-            this.cache.Count.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenItemIsAddedThenLookedUpMetricsAreCorrect()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.GetOrAdd(1, k => k);
-
-            this.cache.Metrics.Value.Misses.Should().Be(0);
-            this.cache.Metrics.Value.Hits.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenItemIsAddedWithArgValueIsCorrect()
-        {
-            this.cache.GetOrAdd(1, (k, a) => k + a, 2);
-
-            this.cache.TryGet(1, out var value).Should().BeTrue();
-            value.Should().Be(3);
-        }
-
-        [Fact]
-        public void WhenRemovedEventHandlerIsRegisteredItIsFired()
-        {
-            this.cache.Events.Value.ItemRemoved += OnItemRemoved;
-
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(1);
-
-            this.removedItems.First().Key.Should().Be(1);
+            cache = new(innerCache);
+        }
+
+        [Fact]
+        public void WhenInnerCacheIsNullCtorThrows()
+        {
+            Action constructor = () => { var x = new AtomicFactoryCache<int, int>(null); };
+
+            constructor.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WhenCreatedCapacityPropertyWrapsInnerCache()
+        {
+            this.cache.Policy.Eviction.Value.Capacity.Should().Be(capacity);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedCountIsCorrect()
+        {
+            this.cache.Count.Should().Be(0);
+
+            this.cache.AddOrUpdate(2, 2);
+
+            this.cache.Count.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedThenLookedUpMetricsAreCorrect()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.GetOrAdd(1, k => k);
+
+            this.cache.Metrics.Value.Misses.Should().Be(0);
+            this.cache.Metrics.Value.Hits.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedWithArgValueIsCorrect()
+        {
+            this.cache.GetOrAdd(1, (k, a) => k + a, 2);
+
+            this.cache.TryGet(1, out var value).Should().BeTrue();
+            value.Should().Be(3);
+        }
+
+        [Fact]
+        public void WhenRemovedEventHandlerIsRegisteredItIsFired()
+        {
+            this.cache.Events.Value.ItemRemoved += OnItemRemoved;
+
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(1);
+
+            this.removedItems.First().Key.Should().Be(1);
         }
 
         // backcompat: remove conditional compile
-#if NETCOREAPP3_0_OR_GREATER
-        [Fact]
-        public void WhenRemovedValueIsReturned()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(1, out var value);
-
-            value.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenNotRemovedValueIsDefault()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(2, out var value);
-
-            value.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenRemoveKeyValueAndValueDoesntMatchDontRemove()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(new KeyValuePair<int, int>(1, 2)).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenRemoveKeyValueAndValueDoesMatchThenRemove()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(new KeyValuePair<int, int>(1, 1)).Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenRemoveKeyValueAndValueIsNotCreatedDoesNotRemove()
-        {
-            // seed the inner cache with an not yet created value
-            this.innerCache.AddOrUpdate(1, new AtomicFactory<int, int>());
-
-            // try to remove with the default value (0)
-            this.cache.TryRemove(new KeyValuePair<int, int>(1, 0)).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenUpdatedEventHandlerIsRegisteredItIsFired()
-        {
-            this.cache.Events.Value.ItemUpdated += OnItemUpdated;
-
-            this.cache.AddOrUpdate(1, 2);
-            this.cache.AddOrUpdate(1, 3);
-
-            this.updatedItems.First().Key.Should().Be(1);
-            this.updatedItems.First().OldValue.Should().Be(2);
-            this.updatedItems.First().NewValue.Should().Be(3);
-        }
-#endif
-        [Fact]
-        public void WhenNoInnerEventsNoOuterEvents()
-        {
-            var inner = new Mock<ICache<int, AtomicFactory<int, int>>>();
-            inner.SetupGet(c => c.Events).Returns(Optional<ICacheEvents<int, AtomicFactory<int, int>>>.None);
-
-            var cache = new AtomicFactoryCache<int, int>(inner.Object);
-
-            cache.Events.HasValue.Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenKeyDoesNotExistAddOrUpdateAddsNewItem()
-        {
-            this.cache.AddOrUpdate(1, 1);
-
-            this.cache.TryGet(1, out var value).Should().BeTrue();
-            value.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenKeyExistsAddOrUpdateUpdatesExistingItem()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.AddOrUpdate(1, 2);
-
-            this.cache.TryGet(1, out var value).Should().BeTrue();
-            value.Should().Be(2);
-        }
-
-        [Fact]
-        public void WhenClearedItemsAreRemoved()
-        {
-            this.cache.AddOrUpdate(1, 1);
-
-            this.cache.Clear();
-
-            this.cache.Count.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenItemDoesNotExistTryGetReturnsFalse()
-        {
-            this.cache.TryGet(1, out var value).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenKeyDoesNotExistGetOrAddAddsValue()
-        {
-            this.cache.GetOrAdd(1, k => k);
-
-            this.cache.TryGet(1, out var value).Should().BeTrue();
-            value.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenCacheContainsValuesTrim1RemovesColdestValue()
-        {
-            this.cache.AddOrUpdate(0, 0);
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.AddOrUpdate(2, 2);
-
-            this.cache.Policy.Eviction.Value.Trim(1);
-
-            this.cache.TryGet(0, out var value).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenKeyDoesNotExistTryRemoveReturnsFalse()
-        {
-            this.cache.TryRemove(1).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenKeyExistsTryRemoveReturnsTrue()
-        {
-            this.cache.AddOrUpdate(1, 1);
-            this.cache.TryRemove(1).Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenKeyDoesNotExistTryUpdateReturnsFalse()
-        {
-            this.cache.TryUpdate(1, 1).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenKeyExistsTryUpdateReturnsTrue()
-        {
-            this.cache.AddOrUpdate(1, 1);
-
-            this.cache.TryUpdate(1, 2).Should().BeTrue();
-            this.cache.TryGet(1, out var value);
-            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) });
-        }
-
-        [Fact]
-        public void WhenFactoryThrowsEmptyValueIsNotCounted()
-        {
-            try
-            {
-                cache.GetOrAdd(1, _ => throw new Exception());
-            }
-            catch { }
-
-            cache.Count.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenFactoryThrowsEmptyValueIsNotEnumerable()
-        {
-            try
-            {
-                cache.GetOrAdd(1, k => throw new Exception());
-            }
-            catch { }
-
-            // IEnumerable.Count() instead of Count property
-            cache.Count().Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenFactoryThrowsEmptyKeyIsNotEnumerable()
-        {
-            try
-            {
-                cache.GetOrAdd(1, k => throw new Exception());
-            }
-            catch { }
-
-            cache.Keys.Count().Should().Be(0);
-        }
-
-        private void OnItemRemoved(object sender, ItemRemovedEventArgs<int, int> e)
-        {
-            this.removedItems.Add(e);
-        }
-
-        private void OnItemUpdated(object sender, ItemUpdatedEventArgs<int, int> e)
-        {
-            this.updatedItems.Add(e);
-        }
-    }
-}
+#if NETCOREAPP3_0_OR_GREATER
+        [Fact]
+        public void WhenRemovedValueIsReturned()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(1, out var value);
+
+            value.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenNotRemovedValueIsDefault()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(2, out var value);
+
+            value.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenRemoveKeyValueAndValueDoesntMatchDontRemove()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(new KeyValuePair<int, int>(1, 2)).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenRemoveKeyValueAndValueDoesMatchThenRemove()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(new KeyValuePair<int, int>(1, 1)).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenRemoveKeyValueAndValueIsNotCreatedDoesNotRemove()
+        {
+            // seed the inner cache with an not yet created value
+            this.innerCache.AddOrUpdate(1, new AtomicFactory<int, int>());
+
+            // try to remove with the default value (0)
+            this.cache.TryRemove(new KeyValuePair<int, int>(1, 0)).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenUpdatedEventHandlerIsRegisteredItIsFired()
+        {
+            this.cache.Events.Value.ItemUpdated += OnItemUpdated;
+
+            this.cache.AddOrUpdate(1, 2);
+            this.cache.AddOrUpdate(1, 3);
+
+            this.updatedItems.First().Key.Should().Be(1);
+            this.updatedItems.First().OldValue.Should().Be(2);
+            this.updatedItems.First().NewValue.Should().Be(3);
+        }
+#endif
+        [Fact]
+        public void WhenNoInnerEventsNoOuterEvents()
+        {
+            var inner = new Mock<ICache<int, AtomicFactory<int, int>>>();
+            inner.SetupGet(c => c.Events).Returns(Optional<ICacheEvents<int, AtomicFactory<int, int>>>.None);
+
+            var cache = new AtomicFactoryCache<int, int>(inner.Object);
+
+            cache.Events.HasValue.Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistAddOrUpdateAddsNewItem()
+        {
+            this.cache.AddOrUpdate(1, 1);
+
+            this.cache.TryGet(1, out var value).Should().BeTrue();
+            value.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenKeyExistsAddOrUpdateUpdatesExistingItem()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.AddOrUpdate(1, 2);
+
+            this.cache.TryGet(1, out var value).Should().BeTrue();
+            value.Should().Be(2);
+        }
+
+        [Fact]
+        public void WhenClearedItemsAreRemoved()
+        {
+            this.cache.AddOrUpdate(1, 1);
+
+            this.cache.Clear();
+
+            this.cache.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenItemDoesNotExistTryGetReturnsFalse()
+        {
+            this.cache.TryGet(1, out var value).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistGetOrAddAddsValue()
+        {
+            this.cache.GetOrAdd(1, k => k);
+
+            this.cache.TryGet(1, out var value).Should().BeTrue();
+            value.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenCacheContainsValuesTrim1RemovesColdestValue()
+        {
+            this.cache.AddOrUpdate(0, 0);
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.AddOrUpdate(2, 2);
+
+            this.cache.Policy.Eviction.Value.Trim(1);
+
+            this.cache.TryGet(0, out var value).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryRemoveReturnsFalse()
+        {
+            this.cache.TryRemove(1).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyExistsTryRemoveReturnsTrue()
+        {
+            this.cache.AddOrUpdate(1, 1);
+            this.cache.TryRemove(1).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryUpdateReturnsFalse()
+        {
+            this.cache.TryUpdate(1, 1).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyExistsTryUpdateReturnsTrue()
+        {
+            this.cache.AddOrUpdate(1, 1);
+
+            this.cache.TryUpdate(1, 2).Should().BeTrue();
+            this.cache.TryGet(1, out var value);
+            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) });
+        }
+
+        [Fact]
+        public void WhenFactoryThrowsEmptyValueIsNotCounted()
+        {
+            try
+            {
+                cache.GetOrAdd(1, _ => throw new Exception());
+            }
+            catch { }
+
+            cache.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenFactoryThrowsEmptyValueIsNotEnumerable()
+        {
+            try
+            {
+                cache.GetOrAdd(1, k => throw new Exception());
+            }
+            catch { }
+
+            // IEnumerable.Count() instead of Count property
+            cache.Count().Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenFactoryThrowsEmptyKeyIsNotEnumerable()
+        {
+            try
+            {
+                cache.GetOrAdd(1, k => throw new Exception());
+            }
+            catch { }
+
+            cache.Keys.Count().Should().Be(0);
+        }
+
+        private void OnItemRemoved(object sender, ItemRemovedEventArgs<int, int> e)
+        {
+            this.removedItems.Add(e);
+        }
+
+        private void OnItemUpdated(object sender, ItemUpdatedEventArgs<int, int> e)
+        {
+            this.updatedItems.Add(e);
+        }
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryTests.cs b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryTests.cs
index 85987dfe..eae14265 100644
--- a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryTests.cs
+++ b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryTests.cs
@@ -1,163 +1,163 @@
-
-using System.Threading;
-using System.Threading.Tasks;
-using BitFaster.Caching.Atomic;
-using FluentAssertions;
-using Xunit;
-
-namespace BitFaster.Caching.UnitTests.Atomic
-{
-    public class AtomicFactoryTests
-    {
-        [Fact]
-        public void DefaultCtorValueIsNotCreated()
-        {
-            var a = new AtomicFactory<int, int>();
-
-            a.IsValueCreated.Should().BeFalse();
-            a.ValueIfCreated.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenValuePassedToCtorValueIsStored()
-        {
-            var a = new AtomicFactory<int, int>(1);
-
-            a.ValueIfCreated.Should().Be(1);
-            a.IsValueCreated.Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenValueCreatedValueReturned()
-        {
-            var a = new AtomicFactory<int, int>();
-            a.GetValue(1, k => 2).Should().Be(2);
-
-            a.ValueIfCreated.Should().Be(2);
-            a.IsValueCreated.Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenValueCreatedWithArgValueReturned()
-        {
-            var a = new AtomicFactory<int, int>();
-            a.GetValue(1, (k, a) => k + a, 7).Should().Be(8);
-
-            a.ValueIfCreated.Should().Be(8);
-            a.IsValueCreated.Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenValueCreatedGetValueReturnsOriginalValue()
-        {
-            var a = new AtomicFactory<int, int>();
-            a.GetValue(1, k => 2);
-            a.GetValue(1, k => 3).Should().Be(2);
-        }
-
-        [Fact]
-        public void WhenValueCreatedArgGetValueReturnsOriginalValue()
-        {
-            var a = new AtomicFactory<int, int>();
-            a.GetValue(1, (k, a) => k + a, 7);
-            a.GetValue(1, (k, a) => k + a, 9).Should().Be(8);
-        }
-
-        [Fact]
+
+using System.Threading;
+using System.Threading.Tasks;
+using BitFaster.Caching.Atomic;
+using FluentAssertions;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests.Atomic
+{
+    public class AtomicFactoryTests
+    {
+        [Fact]
+        public void DefaultCtorValueIsNotCreated()
+        {
+            var a = new AtomicFactory<int, int>();
+
+            a.IsValueCreated.Should().BeFalse();
+            a.ValueIfCreated.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenValuePassedToCtorValueIsStored()
+        {
+            var a = new AtomicFactory<int, int>(1);
+
+            a.ValueIfCreated.Should().Be(1);
+            a.IsValueCreated.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenValueCreatedValueReturned()
+        {
+            var a = new AtomicFactory<int, int>();
+            a.GetValue(1, k => 2).Should().Be(2);
+
+            a.ValueIfCreated.Should().Be(2);
+            a.IsValueCreated.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenValueCreatedWithArgValueReturned()
+        {
+            var a = new AtomicFactory<int, int>();
+            a.GetValue(1, (k, a) => k + a, 7).Should().Be(8);
+
+            a.ValueIfCreated.Should().Be(8);
+            a.IsValueCreated.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenValueCreatedGetValueReturnsOriginalValue()
+        {
+            var a = new AtomicFactory<int, int>();
+            a.GetValue(1, k => 2);
+            a.GetValue(1, k => 3).Should().Be(2);
+        }
+
+        [Fact]
+        public void WhenValueCreatedArgGetValueReturnsOriginalValue()
+        {
+            var a = new AtomicFactory<int, int>();
+            a.GetValue(1, (k, a) => k + a, 7);
+            a.GetValue(1, (k, a) => k + a, 9).Should().Be(8);
+        }
+
+        [Fact]
         public void WhenValueNotCreatedHashCodeIsZero()
         {
-            new AtomicFactory<int, int>()
-                .GetHashCode()
-                .Should().Be(0);
+            new AtomicFactory<int, int>()
+                .GetHashCode()
+                .Should().Be(0);
         }
 
-        [Fact]
+        [Fact]
         public void WhenValueCreatedHashCodeIsValueHashCode()
         {
-            new AtomicFactory<int, int>(1)
-                .GetHashCode()
-                .Should().Be(1);
+            new AtomicFactory<int, int>(1)
+                .GetHashCode()
+                .Should().Be(1);
         }
 
-        [Fact]
+        [Fact]
         public void WhenValueNotCreatedEqualsFalse()
         {
-            var a = new AtomicFactory<int, int>();
-            var b = new AtomicFactory<int, int>();
-
-            a.Equals(b).Should().BeFalse();
+            var a = new AtomicFactory<int, int>();
+            var b = new AtomicFactory<int, int>();
+
+            a.Equals(b).Should().BeFalse();
         }
 
-        [Fact]
+        [Fact]
         public void WhenOtherValueNotCreatedEqualsFalse()
         {
-            var a = new AtomicFactory<int, int>(1);
-            var b = new AtomicFactory<int, int>();
-
-            a.Equals(b).Should().BeFalse();
+            var a = new AtomicFactory<int, int>(1);
+            var b = new AtomicFactory<int, int>();
+
+            a.Equals(b).Should().BeFalse();
         }
 
-        [Fact]
+        [Fact]
         public void WhenArgNullEqualsFalse()
         {
-            new AtomicFactory<int, int>(1)
-                .Equals(null)
-                .Should().BeFalse();
+            new AtomicFactory<int, int>(1)
+                .Equals(null)
+                .Should().BeFalse();
         }
 
-        [Fact]
+        [Fact]
         public void WhenArgObjectValuesAreSameEqualsTrue()
         {
             object other = new AtomicFactory<int, int>(1);
 
-            new AtomicFactory<int, int>(1)
-                .Equals(other)
-                .Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task WhenCallersRunConcurrentlyResultIsFromWinner()
-        {
-            var enter = new ManualResetEvent(false);
-            var resume = new ManualResetEvent(false);
-
-            var atomicFactory = new AtomicFactory<int, int>();
-            var result = 0;
-            var winnerCount = 0;
-
-            Task<int> first = Task.Run(() =>
-            {
-                return atomicFactory.GetValue(1, k =>
-                {
-                    enter.Set();
-                    resume.WaitOne();
-
-                    result = 1;
-                    Interlocked.Increment(ref winnerCount);
-                    return 1;
-                });
-            });
-
-            Task<int> second = Task.Run(() =>
-            {
-                return atomicFactory.GetValue(1, k =>
-                {
-                    enter.Set();
-                    resume.WaitOne();
-
-                    result = 2;
-                    Interlocked.Increment(ref winnerCount);
-                    return 2;
-                });
-            });
-
-            enter.WaitOne();
-            resume.Set();
-
-            (await first).Should().Be(result);
-            (await second).Should().Be(result);
-
-            winnerCount.Should().Be(1);
-        }
-    }
-}
+            new AtomicFactory<int, int>(1)
+                .Equals(other)
+                .Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task WhenCallersRunConcurrentlyResultIsFromWinner()
+        {
+            var enter = new ManualResetEvent(false);
+            var resume = new ManualResetEvent(false);
+
+            var atomicFactory = new AtomicFactory<int, int>();
+            var result = 0;
+            var winnerCount = 0;
+
+            Task<int> first = Task.Run(() =>
+            {
+                return atomicFactory.GetValue(1, k =>
+                {
+                    enter.Set();
+                    resume.WaitOne();
+
+                    result = 1;
+                    Interlocked.Increment(ref winnerCount);
+                    return 1;
+                });
+            });
+
+            Task<int> second = Task.Run(() =>
+            {
+                return atomicFactory.GetValue(1, k =>
+                {
+                    enter.Set();
+                    resume.WaitOne();
+
+                    result = 2;
+                    Interlocked.Increment(ref winnerCount);
+                    return 2;
+                });
+            });
+
+            enter.WaitOne();
+            resume.Set();
+
+            (await first).Should().Be(result);
+            (await second).Should().Be(result);
+
+            winnerCount.Should().Be(1);
+        }
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/Atomic/ConcurrentDictionaryExtensionTests.cs b/BitFaster.Caching.UnitTests/Atomic/ConcurrentDictionaryExtensionTests.cs
index f5076a20..bec9a5f7 100644
--- a/BitFaster.Caching.UnitTests/Atomic/ConcurrentDictionaryExtensionTests.cs
+++ b/BitFaster.Caching.UnitTests/Atomic/ConcurrentDictionaryExtensionTests.cs
@@ -1,62 +1,62 @@
-
-using System.Collections.Concurrent;
+
+using System.Collections.Concurrent;
 using System.Collections.Generic;
-using BitFaster.Caching.Atomic;
-using FluentAssertions;
-using Xunit;
-
-namespace BitFaster.Caching.UnitTests.Atomic
-{
-    public class ConcurrentDictionaryExtensionTests
-    {
-        private ConcurrentDictionary<int, AtomicFactory<int, int>> dictionary = new ConcurrentDictionary<int, AtomicFactory<int, int>>();
-
-        [Fact]
-        public void WhenItemIsAddedItCanBeRetrieved()
-        {
-            dictionary.GetOrAdd(1, k => k);
-
-            dictionary.TryGetValue(1, out int value).Should().BeTrue();
-            value.Should().Be(1);
+using BitFaster.Caching.Atomic;
+using FluentAssertions;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests.Atomic
+{
+    public class ConcurrentDictionaryExtensionTests
+    {
+        private ConcurrentDictionary<int, AtomicFactory<int, int>> dictionary = new ConcurrentDictionary<int, AtomicFactory<int, int>>();
+
+        [Fact]
+        public void WhenItemIsAddedItCanBeRetrieved()
+        {
+            dictionary.GetOrAdd(1, k => k);
+
+            dictionary.TryGetValue(1, out int value).Should().BeTrue();
+            value.Should().Be(1);
         }
 
-        [Fact]
-        public void WhenItemIsAddedWithArgItCanBeRetrieved()
-        {
-            dictionary.GetOrAdd(1, (k,a) => k + a, 2);
-
-            dictionary.TryGetValue(1, out int value).Should().BeTrue();
-            value.Should().Be(3);
+        [Fact]
+        public void WhenItemIsAddedWithArgItCanBeRetrieved()
+        {
+            dictionary.GetOrAdd(1, (k,a) => k + a, 2);
+
+            dictionary.TryGetValue(1, out int value).Should().BeTrue();
+            value.Should().Be(3);
         }
 
-        [Fact]
+        [Fact]
         public void WhenKeyDoesNotExistTryGetReturnsFalse()
         {
-            dictionary.TryGetValue(1, out int _).Should().BeFalse();
+            dictionary.TryGetValue(1, out int _).Should().BeFalse();
         }
 
-        [Fact]
-        public void WhenItemIsAddedItCanBeRemovedByKey()
-        {
-            dictionary.GetOrAdd(1, k => k);
-
-            dictionary.TryRemove(1, out int value).Should().BeTrue();
-            value.Should().Be(1);
+        [Fact]
+        public void WhenItemIsAddedItCanBeRemovedByKey()
+        {
+            dictionary.GetOrAdd(1, k => k);
+
+            dictionary.TryRemove(1, out int value).Should().BeTrue();
+            value.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedItCanBeRemovedByKvp()
+        {
+            dictionary.GetOrAdd(1, k => k);
+
+            dictionary.TryRemove(new KeyValuePair<int, int>(1, 1)).Should().BeTrue();
+            dictionary.TryGetValue(1, out _).Should().BeFalse();
         }
 
-        [Fact]
-        public void WhenItemIsAddedItCanBeRemovedByKvp()
-        {
-            dictionary.GetOrAdd(1, k => k);
-
-            dictionary.TryRemove(new KeyValuePair<int, int>(1, 1)).Should().BeTrue();
-            dictionary.TryGetValue(1, out _).Should().BeFalse();
-        }
-
-        [Fact]
+        [Fact]
         public void WhenKeyDoesNotExistTryRemoveReturnsFalse()
         {
-            dictionary.TryRemove(1, out int _).Should().BeFalse();
-        }
-    }
-}
+            dictionary.TryRemove(1, out int _).Should().BeFalse();
+        }
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/Buffers/MpscBoundedBufferTests.cs b/BitFaster.Caching.UnitTests/Buffers/MpscBoundedBufferTests.cs
index 60ada589..a4a65242 100644
--- a/BitFaster.Caching.UnitTests/Buffers/MpscBoundedBufferTests.cs
+++ b/BitFaster.Caching.UnitTests/Buffers/MpscBoundedBufferTests.cs
@@ -1,155 +1,155 @@
-using System;
-using BitFaster.Caching.Buffers;
-using FluentAssertions;
+using System;
+using BitFaster.Caching.Buffers;
+using FluentAssertions;
 using Xunit;
 
-namespace BitFaster.Caching.UnitTests.Buffers
-{
-    public class MpscBoundedBufferTests
-    {
+namespace BitFaster.Caching.UnitTests.Buffers
+{
+    public class MpscBoundedBufferTests
+    {
         private readonly MpscBoundedBuffer<string> buffer = new MpscBoundedBuffer<string>(10);
-
-        [Fact]
-        public void WhenSizeIsLessThan1CtorThrows()
-        {
-            Action constructor = () => { var x = new MpscBoundedBuffer<string>(-1); };
-
-            constructor.Should().Throw<ArgumentOutOfRangeException>();
-        }
-
-        [Fact]
-        public void SizeIsPowerOfTwo()
-        {
-            buffer.Capacity.Should().Be(16);
-        }
-
-        [Fact]
-        public void WhenBufferIsEmptyCountIsZero()
-        {
-            buffer.Count.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenBufferHasOneItemCountIsOne()
-        {
-            // head < tail
-            buffer.TryAdd("1");
-            buffer.Count.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenBufferHas15ItemCountIs15()
-        {
-            buffer.TryAdd("1").Should().Be(BufferStatus.Success);
-            buffer.TryTake(out var _).Should().Be(BufferStatus.Success);
-
-            for (var i = 0; i < 15; i++)
-            {
-                buffer.TryAdd("0").Should().Be(BufferStatus.Success);
-            }
-
-            // head = 1, tail = 0 : head > tail
-            buffer.Count.Should().Be(15);
-        }
-
-        [Fact]
-        public void WhenBufferIsFullTryAddIsFalse()
-        {
-            for (var i = 0; i < 16; i++)
-            {
-                buffer.TryAdd(i.ToString()).Should().Be(BufferStatus.Success);
-            }
-
-            buffer.TryAdd("666").Should().Be(BufferStatus.Full);
-        }
-
-        [Fact]
-        public void WhenBufferIsEmptyTryTakeIsFalse()
-        {
-            buffer.TryTake(out var _).Should().Be(BufferStatus.Empty);
-        }
-
-        [Fact]
-        public void WhenItemAddedItCanBeTaken()
-        {
-            buffer.TryAdd("123").Should().Be(BufferStatus.Success);
-            buffer.TryTake(out var item).Should().Be(BufferStatus.Success);
-            item.Should().Be("123");
-        }
-
-        [Fact]
-        public void WhenItemsAreAddedClearRemovesItems()
-        {
-            buffer.TryAdd("1");
-            buffer.TryAdd("2");
-
-            buffer.Count.Should().Be(2);
-
-            buffer.Clear();
-
-            buffer.Count.Should().Be(0);
-            buffer.TryTake(out var _).Should().Be(BufferStatus.Empty);
-        }
-
-        [Fact]
-        public void WhenBufferEmptyDrainReturnsZero()
-        {
-            var outputBuffer = new string[16];
-            var output = new ArraySegment<string>(outputBuffer);
-
-            buffer.DrainTo(output).Should().Be(0);
-        }
-
-#if NETCOREAPP3_0_OR_GREATER
-        [Fact]
-        public void WhenBufferContainsItemsDrainArrayTakesItems()
-        {
-            buffer.TryAdd("1");
-            buffer.TryAdd("2");
-            buffer.TryAdd("3");
-
-            var outputBuffer = new string[16];
-
-            buffer.DrainTo(outputBuffer.AsSpan()).Should().Be(3);
-
-            outputBuffer[0].Should().Be("1");
-            outputBuffer[1].Should().Be("2");
-            outputBuffer[2].Should().Be("3");
-        }
-#endif
-
-        [Fact]
-        public void WhenBufferContainsItemsDrainSegmentTakesItems()
-        {
-            buffer.TryAdd("1");
-            buffer.TryAdd("2");
-            buffer.TryAdd("3");
-
-            var outputBuffer = new string[16];
-            var output = new ArraySegment<string>(outputBuffer);
-
-            buffer.DrainTo(output).Should().Be(3);
-
-            outputBuffer[0].Should().Be("1");
-            outputBuffer[1].Should().Be("2");
-            outputBuffer[2].Should().Be("3");
-        }
-
-        [Fact]
-        public void WhenSegmentUsesOffsetItemsDrainedToOffset()
-        {
-            buffer.TryAdd("1");
-            buffer.TryAdd("2");
-            buffer.TryAdd("3");
-
-            var outputBuffer = new string[16];
-            var output = new ArraySegment<string>(outputBuffer, 6, 10);
-
-            buffer.DrainTo(output).Should().Be(3);
-
-            outputBuffer[6].Should().Be("1");
-            outputBuffer[7].Should().Be("2");
-            outputBuffer[8].Should().Be("3");
-        }
-    }
-}
+
+        [Fact]
+        public void WhenSizeIsLessThan1CtorThrows()
+        {
+            Action constructor = () => { var x = new MpscBoundedBuffer<string>(-1); };
+
+            constructor.Should().Throw<ArgumentOutOfRangeException>();
+        }
+
+        [Fact]
+        public void SizeIsPowerOfTwo()
+        {
+            buffer.Capacity.Should().Be(16);
+        }
+
+        [Fact]
+        public void WhenBufferIsEmptyCountIsZero()
+        {
+            buffer.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenBufferHasOneItemCountIsOne()
+        {
+            // head < tail
+            buffer.TryAdd("1");
+            buffer.Count.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenBufferHas15ItemCountIs15()
+        {
+            buffer.TryAdd("1").Should().Be(BufferStatus.Success);
+            buffer.TryTake(out var _).Should().Be(BufferStatus.Success);
+
+            for (var i = 0; i < 15; i++)
+            {
+                buffer.TryAdd("0").Should().Be(BufferStatus.Success);
+            }
+
+            // head = 1, tail = 0 : head > tail
+            buffer.Count.Should().Be(15);
+        }
+
+        [Fact]
+        public void WhenBufferIsFullTryAddIsFalse()
+        {
+            for (var i = 0; i < 16; i++)
+            {
+                buffer.TryAdd(i.ToString()).Should().Be(BufferStatus.Success);
+            }
+
+            buffer.TryAdd("666").Should().Be(BufferStatus.Full);
+        }
+
+        [Fact]
+        public void WhenBufferIsEmptyTryTakeIsFalse()
+        {
+            buffer.TryTake(out var _).Should().Be(BufferStatus.Empty);
+        }
+
+        [Fact]
+        public void WhenItemAddedItCanBeTaken()
+        {
+            buffer.TryAdd("123").Should().Be(BufferStatus.Success);
+            buffer.TryTake(out var item).Should().Be(BufferStatus.Success);
+            item.Should().Be("123");
+        }
+
+        [Fact]
+        public void WhenItemsAreAddedClearRemovesItems()
+        {
+            buffer.TryAdd("1");
+            buffer.TryAdd("2");
+
+            buffer.Count.Should().Be(2);
+
+            buffer.Clear();
+
+            buffer.Count.Should().Be(0);
+            buffer.TryTake(out var _).Should().Be(BufferStatus.Empty);
+        }
+
+        [Fact]
+        public void WhenBufferEmptyDrainReturnsZero()
+        {
+            var outputBuffer = new string[16];
+            var output = new ArraySegment<string>(outputBuffer);
+
+            buffer.DrainTo(output).Should().Be(0);
+        }
+
+#if NETCOREAPP3_0_OR_GREATER
+        [Fact]
+        public void WhenBufferContainsItemsDrainArrayTakesItems()
+        {
+            buffer.TryAdd("1");
+            buffer.TryAdd("2");
+            buffer.TryAdd("3");
+
+            var outputBuffer = new string[16];
+
+            buffer.DrainTo(outputBuffer.AsSpan()).Should().Be(3);
+
+            outputBuffer[0].Should().Be("1");
+            outputBuffer[1].Should().Be("2");
+            outputBuffer[2].Should().Be("3");
+        }
+#endif
+
+        [Fact]
+        public void WhenBufferContainsItemsDrainSegmentTakesItems()
+        {
+            buffer.TryAdd("1");
+            buffer.TryAdd("2");
+            buffer.TryAdd("3");
+
+            var outputBuffer = new string[16];
+            var output = new ArraySegment<string>(outputBuffer);
+
+            buffer.DrainTo(output).Should().Be(3);
+
+            outputBuffer[0].Should().Be("1");
+            outputBuffer[1].Should().Be("2");
+            outputBuffer[2].Should().Be("3");
+        }
+
+        [Fact]
+        public void WhenSegmentUsesOffsetItemsDrainedToOffset()
+        {
+            buffer.TryAdd("1");
+            buffer.TryAdd("2");
+            buffer.TryAdd("3");
+
+            var outputBuffer = new string[16];
+            var output = new ArraySegment<string>(outputBuffer, 6, 10);
+
+            buffer.DrainTo(output).Should().Be(3);
+
+            outputBuffer[6].Should().Be("1");
+            outputBuffer[7].Should().Be("2");
+            outputBuffer[8].Should().Be("3");
+        }
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs
index b891225f..71b850ff 100644
--- a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs
+++ b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs
@@ -1,876 +1,876 @@
-using FluentAssertions;
-using BitFaster.Caching.Lru;
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Xunit;
-using Xunit.Abstractions;
+using FluentAssertions;
+using BitFaster.Caching.Lru;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
 using System.Collections.Concurrent;
 using System.Reflection;
 
-namespace BitFaster.Caching.UnitTests.Lru
-{
-    public class ConcurrentLruTests
-    {
-        private readonly ITestOutputHelper testOutputHelper;
-        private const int hotCap = 3;
-        private const int warmCap = 3;
-        private const int coldCap = 3;
-        private static readonly ICapacityPartition capacity = new EqualCapacityPartition(hotCap + warmCap + coldCap);
-
-        private ConcurrentLru<int, string> lru = new ConcurrentLru<int, string>(1, capacity, EqualityComparer<int>.Default);
-        private ValueFactory valueFactory = new ValueFactory();
-
-        private List<ItemRemovedEventArgs<int, int>> removedItems = new List<ItemRemovedEventArgs<int, int>>();
-        private List<ItemUpdatedEventArgs<int, int>> updatedItems = new List<ItemUpdatedEventArgs<int, int>>();
-
-        private void OnLruItemRemoved(object sender, ItemRemovedEventArgs<int, int> e)
-        {
-            removedItems.Add(e);
-        }
-
-        private void OnLruItemUpdated(object sender, ItemUpdatedEventArgs<int, int> e)
-        {
-            updatedItems.Add(e);
-        }
-
-        public ConcurrentLruTests(ITestOutputHelper testOutputHelper)
-        {
-            this.testOutputHelper = testOutputHelper;
-        }
-
-        [Fact]
-        public void WhenConcurrencyIsLessThan1CtorThrows()
-        {
-            Action constructor = () => { var x = new ConcurrentLru<int, string>(0, 3, EqualityComparer<int>.Default); };
-
-            constructor.Should().Throw<ArgumentOutOfRangeException>();
-        }
-
-        [Fact]
-        public void WhenCapacityIsLessThan3CtorThrows()
-        {
-            Action constructor = () => { var x = new ConcurrentLru<int, string>(1, 2, EqualityComparer<int>.Default); };
-
-            constructor.Should().Throw<ArgumentOutOfRangeException>();
-        }
-
-        [Fact]
-        public void WhenPartitionIsNullCtorThrows()
-        {
-            ICapacityPartition partition = null;
-            Action constructor = () => { var x = new ConcurrentLru<int, string>(1, partition, EqualityComparer<int>.Default); };
-
-            constructor.Should().Throw<ArgumentNullException>();
-        }
-
-        [Fact]
-        public void WhenPartitionIsInvalidThrows()
-        {
-            var p = new TestCapacityPartition { Cold = 2, Warm = 0, Hot = 2 };
-            Action constructor = () => { var x = new ConcurrentLru<int, string>(1, p, EqualityComparer<int>.Default); };
-
-            constructor.Should().Throw<ArgumentOutOfRangeException>();
-        }
-
-        [Fact]
-        public void WhenComparerIsNullCtorThrows()
-        {
-            Action constructor = () => { var x = new ConcurrentLru<int, string>(1, 3, null); };
-
-            constructor.Should().Throw<ArgumentNullException>();
-        }
-
-        [Fact]
-        public void WhenCapacityIs4HotHasCapacity1AndColdHasCapacity1()
-        {
-            var lru = new ConcurrentLru<int, int>(1, new EqualCapacityPartition(4), EqualityComparer<int>.Default);
-
-            for (int i = 0; i < 5; i++)
-            {
-                lru.GetOrAdd(i, x => x);
-            }
-
-            lru.HotCount.Should().Be(1);
-            lru.ColdCount.Should().Be(1);
-            lru.Capacity.Should().Be(4);
-        }
-
-        [Fact]
-        public void WhenCapacityIs5HotHasCapacity1AndColdHasCapacity2()
-        {
-            var lru = new ConcurrentLru<int, int>(1, new EqualCapacityPartition(5), EqualityComparer<int>.Default);
-
-            for (int i = 0; i < 5; i++)
-            {
-                lru.GetOrAdd(i, x => x);
-            }
-
-            lru.HotCount.Should().Be(1);
-            lru.ColdCount.Should().Be(2);
-            lru.Capacity.Should().Be(5);
-        }
-
-        [Fact]
-        public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()
-        {
-            var x = new ConcurrentLru<int, int>(3);
-
-            x.GetOrAdd(1, k => k).Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenItemIsAddedCountIsCorrect()
-        {
-            lru.Count.Should().Be(0);
-            lru.GetOrAdd(1, valueFactory.Create);
-            lru.Count.Should().Be(1);
-        }
-
-        [Fact]
-        public async Task WhenItemIsAddedCountIsCorrectAsync()
-        {
-            lru.Count.Should().Be(0);
-            await lru.GetOrAddAsync(0, valueFactory.CreateAsync);
-            lru.Count.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenItemsAddedKeysContainsTheKeys()
-        {
-            lru.Count.Should().Be(0);
-            lru.GetOrAdd(1, valueFactory.Create);
-            lru.GetOrAdd(2, valueFactory.Create);
-            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 FromColdWarmupFillsWarmQueue()
-        {
-            this.Warmup();
-
-            this.lru.Count.Should().Be(9);
-        }
-
-        [Fact]
-        public void WhenItemExistsTryGetReturnsValueAndTrue()
-        {
-            lru.GetOrAdd(1, valueFactory.Create);
-            bool result = lru.TryGet(1, out var value);
-
-            result.Should().Be(true);
-            value.Should().Be("1");
-        }
-
-        [Fact]
-        public void WhenItemDoesNotExistTryGetReturnsNullAndFalse()
-        {
-            lru.GetOrAdd(1, valueFactory.Create);
-            bool result = lru.TryGet(2, out var value);
-
-            result.Should().Be(false);
-            value.Should().BeNull();
-        }
-
-        [Fact]
-        public void MetricsAreEnabled()
-        {
-            lru.Metrics.HasValue.Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenItemIsAddedThenRetrievedMetricHitRatioIsHalf()
-        {
-            lru.GetOrAdd(1, valueFactory.Create);
-            bool result = lru.TryGet(1, out var value);
-
-            lru.Metrics.Value.HitRatio.Should().Be(0.5);
-        }
-
-        [Fact]
-        public void WhenItemIsAddedThenRetrievedTotalIs2()
-        {
-            lru.GetOrAdd(1, valueFactory.Create);
-            bool result = lru.TryGet(1, out var value);
-
-            lru.Metrics.Value.Total.Should().Be(2);
-        }
-
-        [Fact]
-        public void WhenRefToMetricsIsCapturedResultIsCorrect()
-        {
-            // this detects the case where the struct is copied. If the internal Data class
-            // doesn't work, this test fails.
-            var m = lru.Metrics;
-
-            lru.GetOrAdd(1, valueFactory.Create);
-            bool result = lru.TryGet(1, out var value);
-
-            m.Value.HitRatio.Should().Be(0.5);
-        }
-
-        [Fact]
-        public void ExpireAfterWriteHasValueIsFalse()
-        {
-            this.lru.Policy.ExpireAfterWrite.HasValue.Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenKeyIsRequestedItIsCreatedAndCached()
-        {
-            var result1 = lru.GetOrAdd(1, valueFactory.Create);
-            var result2 = lru.GetOrAdd(1, valueFactory.Create);
-
-            valueFactory.timesCalled.Should().Be(1);
-            result1.Should().Be(result2);
-        }
-
-        [Fact]
-        public void WhenKeyIsRequestedWithArgItIsCreatedAndCached()
-        {
-            var result1 = lru.GetOrAdd(1, valueFactory.Create, "x");
-            var result2 = lru.GetOrAdd(1, valueFactory.Create, "y");
-
-            valueFactory.timesCalled.Should().Be(1);
-            result1.Should().Be(result2);
-        }
-
-        [Fact]
-        public async Task WhenKeyIsRequestedItIsCreatedAndCachedAsync()
-        {
-            var result1 = await lru.GetOrAddAsync(1, valueFactory.CreateAsync);
-            var result2 = await lru.GetOrAddAsync(1, valueFactory.CreateAsync);
-
-            valueFactory.timesCalled.Should().Be(1);
-            result1.Should().Be(result2);
-        }
-
-        [Fact]
-        public async Task WhenKeyIsRequestedWithArgItIsCreatedAndCachedAsync()
-        {
-            var result1 = await lru.GetOrAddAsync(1, valueFactory.CreateAsync, "x");
-            var result2 = await lru.GetOrAddAsync(1, valueFactory.CreateAsync, "y");
-
-            valueFactory.timesCalled.Should().Be(1);
-            result1.Should().Be(result2);
-        }
-
-        [Fact]
-        public void WhenDifferentKeysAreRequestedValueIsCreatedForEach()
-        {
-            var result1 = lru.GetOrAdd(1, valueFactory.Create);
-            var result2 = lru.GetOrAdd(2, valueFactory.Create);
-
-            valueFactory.timesCalled.Should().Be(2);
-
-            result1.Should().Be("1");
-            result2.Should().Be("2");
-        }
-
-        [Fact]
-        public async Task WhenDifferentKeysAreRequesteValueIsCreatedForEachAsync()
-        {
-            var result1 = await lru.GetOrAddAsync(1, valueFactory.CreateAsync);
-            var result2 = await lru.GetOrAddAsync(2, valueFactory.CreateAsync);
-
-            valueFactory.timesCalled.Should().Be(2);
-
-            result1.Should().Be("1");
-            result2.Should().Be("2");
-        }
-
-        [Fact]
-        public void WhenValuesAreNotReadAndMoreKeysRequestedThanCapacityCountDoesNotIncrease()
-        {
-            this.Warmup();
-
-            var result = lru.GetOrAdd(1, valueFactory.Create);
-
-            lru.Count.Should().Be(9);
-            valueFactory.timesCalled.Should().Be(10);
-        }
-
-        [Fact]
-        public void WhenValuesAreReadAndMoreKeysRequestedThanCapacityCountIsBounded()
-        {
-            int capacity = hotCap + coldCap + warmCap;
-            for (int i = 0; i < capacity + 1; i++)
-            {
-                lru.GetOrAdd(i, valueFactory.Create);
-
-                // touch items already cached when they are still in hot
-                if (i > 0)
-                {
-                    lru.GetOrAdd(i - 1, valueFactory.Create);
-                }
-            }
-
-            lru.Count.Should().Be(capacity);
-            valueFactory.timesCalled.Should().Be(capacity + 1);
-        }
-
-        [Fact]
-        public void WhenKeysAreContinuouslyRequestedInTheOrderTheyAreAddedCountIsBounded()
-        {
-            int capacity = hotCap + coldCap + warmCap;
-            for (int i = 0; i < capacity + 10; i++)
-            {
-                lru.GetOrAdd(i, valueFactory.Create);
-
-                // Touch all items already cached in hot, warm and cold.
-                // This is worst case scenario, since we touch them in the exact order they
-                // were added.
-                for (int j = 0; j < i; j++)
-                {
-                    lru.GetOrAdd(j, valueFactory.Create);
-                }
-
-                testOutputHelper.WriteLine($"Total: {lru.Count} Hot: {lru.HotCount} Warm: {lru.WarmCount} Cold: {lru.ColdCount}");
-                lru.Count.Should().BeLessOrEqualTo(capacity + 1);
-            }
+namespace BitFaster.Caching.UnitTests.Lru
+{
+    public class ConcurrentLruTests
+    {
+        private readonly ITestOutputHelper testOutputHelper;
+        private const int hotCap = 3;
+        private const int warmCap = 3;
+        private const int coldCap = 3;
+        private static readonly ICapacityPartition capacity = new EqualCapacityPartition(hotCap + warmCap + coldCap);
+
+        private ConcurrentLru<int, string> lru = new ConcurrentLru<int, string>(1, capacity, EqualityComparer<int>.Default);
+        private ValueFactory valueFactory = new ValueFactory();
+
+        private List<ItemRemovedEventArgs<int, int>> removedItems = new List<ItemRemovedEventArgs<int, int>>();
+        private List<ItemUpdatedEventArgs<int, int>> updatedItems = new List<ItemUpdatedEventArgs<int, int>>();
+
+        private void OnLruItemRemoved(object sender, ItemRemovedEventArgs<int, int> e)
+        {
+            removedItems.Add(e);
+        }
+
+        private void OnLruItemUpdated(object sender, ItemUpdatedEventArgs<int, int> e)
+        {
+            updatedItems.Add(e);
+        }
+
+        public ConcurrentLruTests(ITestOutputHelper testOutputHelper)
+        {
+            this.testOutputHelper = testOutputHelper;
+        }
+
+        [Fact]
+        public void WhenConcurrencyIsLessThan1CtorThrows()
+        {
+            Action constructor = () => { var x = new ConcurrentLru<int, string>(0, 3, EqualityComparer<int>.Default); };
+
+            constructor.Should().Throw<ArgumentOutOfRangeException>();
+        }
+
+        [Fact]
+        public void WhenCapacityIsLessThan3CtorThrows()
+        {
+            Action constructor = () => { var x = new ConcurrentLru<int, string>(1, 2, EqualityComparer<int>.Default); };
+
+            constructor.Should().Throw<ArgumentOutOfRangeException>();
+        }
+
+        [Fact]
+        public void WhenPartitionIsNullCtorThrows()
+        {
+            ICapacityPartition partition = null;
+            Action constructor = () => { var x = new ConcurrentLru<int, string>(1, partition, EqualityComparer<int>.Default); };
+
+            constructor.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WhenPartitionIsInvalidThrows()
+        {
+            var p = new TestCapacityPartition { Cold = 2, Warm = 0, Hot = 2 };
+            Action constructor = () => { var x = new ConcurrentLru<int, string>(1, p, EqualityComparer<int>.Default); };
+
+            constructor.Should().Throw<ArgumentOutOfRangeException>();
+        }
+
+        [Fact]
+        public void WhenComparerIsNullCtorThrows()
+        {
+            Action constructor = () => { var x = new ConcurrentLru<int, string>(1, 3, null); };
+
+            constructor.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void WhenCapacityIs4HotHasCapacity1AndColdHasCapacity1()
+        {
+            var lru = new ConcurrentLru<int, int>(1, new EqualCapacityPartition(4), EqualityComparer<int>.Default);
+
+            for (int i = 0; i < 5; i++)
+            {
+                lru.GetOrAdd(i, x => x);
+            }
+
+            lru.HotCount.Should().Be(1);
+            lru.ColdCount.Should().Be(1);
+            lru.Capacity.Should().Be(4);
+        }
+
+        [Fact]
+        public void WhenCapacityIs5HotHasCapacity1AndColdHasCapacity2()
+        {
+            var lru = new ConcurrentLru<int, int>(1, new EqualCapacityPartition(5), EqualityComparer<int>.Default);
+
+            for (int i = 0; i < 5; i++)
+            {
+                lru.GetOrAdd(i, x => x);
+            }
+
+            lru.HotCount.Should().Be(1);
+            lru.ColdCount.Should().Be(2);
+            lru.Capacity.Should().Be(5);
+        }
+
+        [Fact]
+        public void ConstructAddAndRetrieveWithDefaultCtorReturnsValue()
+        {
+            var x = new ConcurrentLru<int, int>(3);
+
+            x.GetOrAdd(1, k => k).Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedCountIsCorrect()
+        {
+            lru.Count.Should().Be(0);
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.Count.Should().Be(1);
+        }
+
+        [Fact]
+        public async Task WhenItemIsAddedCountIsCorrectAsync()
+        {
+            lru.Count.Should().Be(0);
+            await lru.GetOrAddAsync(0, valueFactory.CreateAsync);
+            lru.Count.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenItemsAddedKeysContainsTheKeys()
+        {
+            lru.Count.Should().Be(0);
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+            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 FromColdWarmupFillsWarmQueue()
+        {
+            this.Warmup();
+
+            this.lru.Count.Should().Be(9);
+        }
+
+        [Fact]
+        public void WhenItemExistsTryGetReturnsValueAndTrue()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+            bool result = lru.TryGet(1, out var value);
+
+            result.Should().Be(true);
+            value.Should().Be("1");
+        }
+
+        [Fact]
+        public void WhenItemDoesNotExistTryGetReturnsNullAndFalse()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+            bool result = lru.TryGet(2, out var value);
+
+            result.Should().Be(false);
+            value.Should().BeNull();
+        }
+
+        [Fact]
+        public void MetricsAreEnabled()
+        {
+            lru.Metrics.HasValue.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenItemIsAddedThenRetrievedMetricHitRatioIsHalf()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+            bool result = lru.TryGet(1, out var value);
+
+            lru.Metrics.Value.HitRatio.Should().Be(0.5);
+        }
+
+        [Fact]
+        public void WhenItemIsAddedThenRetrievedTotalIs2()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+            bool result = lru.TryGet(1, out var value);
+
+            lru.Metrics.Value.Total.Should().Be(2);
+        }
+
+        [Fact]
+        public void WhenRefToMetricsIsCapturedResultIsCorrect()
+        {
+            // this detects the case where the struct is copied. If the internal Data class
+            // doesn't work, this test fails.
+            var m = lru.Metrics;
+
+            lru.GetOrAdd(1, valueFactory.Create);
+            bool result = lru.TryGet(1, out var value);
+
+            m.Value.HitRatio.Should().Be(0.5);
+        }
+
+        [Fact]
+        public void ExpireAfterWriteHasValueIsFalse()
+        {
+            this.lru.Policy.ExpireAfterWrite.HasValue.Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyIsRequestedItIsCreatedAndCached()
+        {
+            var result1 = lru.GetOrAdd(1, valueFactory.Create);
+            var result2 = lru.GetOrAdd(1, valueFactory.Create);
+
+            valueFactory.timesCalled.Should().Be(1);
+            result1.Should().Be(result2);
+        }
+
+        [Fact]
+        public void WhenKeyIsRequestedWithArgItIsCreatedAndCached()
+        {
+            var result1 = lru.GetOrAdd(1, valueFactory.Create, "x");
+            var result2 = lru.GetOrAdd(1, valueFactory.Create, "y");
+
+            valueFactory.timesCalled.Should().Be(1);
+            result1.Should().Be(result2);
+        }
+
+        [Fact]
+        public async Task WhenKeyIsRequestedItIsCreatedAndCachedAsync()
+        {
+            var result1 = await lru.GetOrAddAsync(1, valueFactory.CreateAsync);
+            var result2 = await lru.GetOrAddAsync(1, valueFactory.CreateAsync);
+
+            valueFactory.timesCalled.Should().Be(1);
+            result1.Should().Be(result2);
+        }
+
+        [Fact]
+        public async Task WhenKeyIsRequestedWithArgItIsCreatedAndCachedAsync()
+        {
+            var result1 = await lru.GetOrAddAsync(1, valueFactory.CreateAsync, "x");
+            var result2 = await lru.GetOrAddAsync(1, valueFactory.CreateAsync, "y");
+
+            valueFactory.timesCalled.Should().Be(1);
+            result1.Should().Be(result2);
+        }
+
+        [Fact]
+        public void WhenDifferentKeysAreRequestedValueIsCreatedForEach()
+        {
+            var result1 = lru.GetOrAdd(1, valueFactory.Create);
+            var result2 = lru.GetOrAdd(2, valueFactory.Create);
+
+            valueFactory.timesCalled.Should().Be(2);
+
+            result1.Should().Be("1");
+            result2.Should().Be("2");
+        }
+
+        [Fact]
+        public async Task WhenDifferentKeysAreRequesteValueIsCreatedForEachAsync()
+        {
+            var result1 = await lru.GetOrAddAsync(1, valueFactory.CreateAsync);
+            var result2 = await lru.GetOrAddAsync(2, valueFactory.CreateAsync);
+
+            valueFactory.timesCalled.Should().Be(2);
+
+            result1.Should().Be("1");
+            result2.Should().Be("2");
+        }
+
+        [Fact]
+        public void WhenValuesAreNotReadAndMoreKeysRequestedThanCapacityCountDoesNotIncrease()
+        {
+            this.Warmup();
+
+            var result = lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.Count.Should().Be(9);
+            valueFactory.timesCalled.Should().Be(10);
+        }
+
+        [Fact]
+        public void WhenValuesAreReadAndMoreKeysRequestedThanCapacityCountIsBounded()
+        {
+            int capacity = hotCap + coldCap + warmCap;
+            for (int i = 0; i < capacity + 1; i++)
+            {
+                lru.GetOrAdd(i, valueFactory.Create);
+
+                // touch items already cached when they are still in hot
+                if (i > 0)
+                {
+                    lru.GetOrAdd(i - 1, valueFactory.Create);
+                }
+            }
+
+            lru.Count.Should().Be(capacity);
+            valueFactory.timesCalled.Should().Be(capacity + 1);
+        }
+
+        [Fact]
+        public void WhenKeysAreContinuouslyRequestedInTheOrderTheyAreAddedCountIsBounded()
+        {
+            int capacity = hotCap + coldCap + warmCap;
+            for (int i = 0; i < capacity + 10; i++)
+            {
+                lru.GetOrAdd(i, valueFactory.Create);
+
+                // Touch all items already cached in hot, warm and cold.
+                // This is worst case scenario, since we touch them in the exact order they
+                // were added.
+                for (int j = 0; j < i; j++)
+                {
+                    lru.GetOrAdd(j, valueFactory.Create);
+                }
+
+                testOutputHelper.WriteLine($"Total: {lru.Count} Hot: {lru.HotCount} Warm: {lru.WarmCount} Cold: {lru.ColdCount}");
+                lru.Count.Should().BeLessOrEqualTo(capacity + 1);
+            }
+        }
+
+        public class KeysInOrderTestDataGenerator : IEnumerable<object[]>
+        {
+            private readonly List<object[]> _data = new List<object[]>
+            {
+                new object[] { new EqualCapacityPartition(hotCap + warmCap + coldCap) },
+                new object[] { new EqualCapacityPartition(128) },
+                new object[] { new EqualCapacityPartition(256) },
+                new object[] { new EqualCapacityPartition(1024) },
+                new object[] { new FavorWarmPartition(128) },
+                new object[] { new FavorWarmPartition(256) },
+                new object[] { new FavorWarmPartition(1024) },
+                new object[] { new FavorWarmPartition(128, 0.6) },
+                new object[] { new FavorWarmPartition(256, 0.6) },
+                new object[] { new FavorWarmPartition(1024, 0.6) },
+            };
+
+            public IEnumerator<object[]> GetEnumerator() => _data.GetEnumerator();
+
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        }
+
+        [Theory]
+        [ClassData(typeof(KeysInOrderTestDataGenerator))]
+        public void WhenKeysAreContinuouslyRequestedInTheOrderTheyAreAddedCountIsBounded2(ICapacityPartition p)
+        {
+            int capacity = p.Hot + p.Cold + p.Warm;
+            lru = new ConcurrentLru<int, string>(capacity, p, EqualityComparer<int>.Default);
+
+            testOutputHelper.WriteLine($"Capacity: {lru.Capacity} (Hot: {p.Hot} Warm: {p.Warm} Cold: {p.Cold})");
+
+            for (int i = 0; i < capacity + 10; i++)
+            {
+                lru.GetOrAdd(i, valueFactory.Create);
+
+                // Touch all items already cached in hot, warm and cold.
+                // This is worst case scenario, since we touch them in the exact order they
+                // were added.
+                for (int j = 0; j < i; j++)
+                {
+                    lru.GetOrAdd(j, valueFactory.Create);
+                }
+
+                lru.Count.Should().BeLessOrEqualTo(capacity + 1, $"Total: {lru.Count} Hot: {lru.HotCount} Warm: {lru.WarmCount} Cold: {lru.ColdCount}");
+            }
+        }
+
+        [Fact]
+        public void WhenValueIsNotTouchedAndExpiresFromHotValueIsBumpedToCold()
+        {
+            this.Warmup();
+
+            lru.GetOrAdd(0, valueFactory.Create); // Don't touch in hot
+
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+            lru.GetOrAdd(3, valueFactory.Create);
+            lru.GetOrAdd(4, valueFactory.Create);
+            lru.GetOrAdd(5, valueFactory.Create);
+            lru.GetOrAdd(6, valueFactory.Create);
+            lru.GetOrAdd(7, valueFactory.Create);
+            lru.GetOrAdd(8, valueFactory.Create);
+            lru.GetOrAdd(9, valueFactory.Create);
+
+            lru.TryGet(0, out var value).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenValueIsTouchedAndExpiresFromHotValueIsBumpedToWarm()
+        {
+            this.Warmup();
+
+            lru.GetOrAdd(0, valueFactory.Create);
+            lru.GetOrAdd(0, valueFactory.Create); // Touch in hot
+
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+            lru.GetOrAdd(3, valueFactory.Create);
+            lru.GetOrAdd(4, valueFactory.Create);
+            lru.GetOrAdd(5, valueFactory.Create);
+            lru.GetOrAdd(6, valueFactory.Create);
+            lru.GetOrAdd(7, valueFactory.Create);
+            lru.GetOrAdd(8, valueFactory.Create);
+            lru.GetOrAdd(9, valueFactory.Create);
+
+            lru.TryGet(0, out var value).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenValueIsTouchedAndExpiresFromColdItIsBumpedToWarm()
+        {
+            this.Warmup();
+
+            lru.GetOrAdd(0, valueFactory.Create);
+
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+            lru.GetOrAdd(3, valueFactory.Create); // push 0 to cold (not touched in hot)
+
+            lru.GetOrAdd(0, valueFactory.Create); // Touch 0 in cold
+
+            lru.GetOrAdd(4, valueFactory.Create); // fully cycle cold, this will evict 0 if it is not moved to warm
+            lru.GetOrAdd(5, valueFactory.Create);
+            lru.GetOrAdd(6, valueFactory.Create);
+            lru.GetOrAdd(7, valueFactory.Create);
+            lru.GetOrAdd(8, valueFactory.Create);
+            lru.GetOrAdd(9, valueFactory.Create);
+
+            lru.TryGet(0, out var value).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenValueIsNotTouchedAndExpiresFromColdItIsRemoved()
+        {
+            this.Warmup();
+
+            lru.GetOrAdd(0, valueFactory.Create);
+
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+            lru.GetOrAdd(3, valueFactory.Create); // push 0 to cold (not touched in hot)
+
+            // Don't touch 0 in cold
+
+            lru.GetOrAdd(4, valueFactory.Create); // fully cycle cold, this will evict 0 if it is not moved to warm
+            lru.GetOrAdd(5, valueFactory.Create);
+            lru.GetOrAdd(6, valueFactory.Create);
+            lru.GetOrAdd(7, valueFactory.Create);
+            lru.GetOrAdd(8, valueFactory.Create);
+            lru.GetOrAdd(9, valueFactory.Create);
+
+            lru.TryGet(0, out var value).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenValueIsNotTouchedAndExpiresFromWarmValueIsBumpedToCold()
+        {
+            this.Warmup();
+
+            lru.GetOrAdd(0, valueFactory.Create);
+            lru.GetOrAdd(0, valueFactory.Create); // Touch 0 in hot, it will promote to warm
+
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+            lru.GetOrAdd(3, valueFactory.Create); // push 0 to warm
+
+            // touch next 3 values, so they will promote to warm
+            lru.GetOrAdd(4, valueFactory.Create); lru.GetOrAdd(4, valueFactory.Create);
+            lru.GetOrAdd(5, valueFactory.Create); lru.GetOrAdd(5, valueFactory.Create);
+            lru.GetOrAdd(6, valueFactory.Create); lru.GetOrAdd(6, valueFactory.Create);
+
+            // push 4,5,6 to warm, 0 to cold
+            lru.GetOrAdd(7, valueFactory.Create);
+            lru.GetOrAdd(8, valueFactory.Create);
+            lru.GetOrAdd(9, valueFactory.Create);
+
+            // verify 0 is present, but don't touch it
+            lru.Keys.Should().Contain(0);
+
+            // push 7,8,9 to cold, evict 0
+            lru.GetOrAdd(10, valueFactory.Create);
+            lru.GetOrAdd(11, valueFactory.Create);
+            lru.GetOrAdd(12, valueFactory.Create);
+
+            lru.TryGet(0, out var value).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenValueIsTouchedAndExpiresFromWarmValueIsBumpedBackIntoWarm()
+        {
+            this.Warmup();
+
+            lru.GetOrAdd(0, valueFactory.Create);
+            lru.GetOrAdd(0, valueFactory.Create); // Touch 0 in hot, it will promote to warm
+
+            lru.GetOrAdd(1, valueFactory.Create);
+            lru.GetOrAdd(2, valueFactory.Create);
+            lru.GetOrAdd(3, valueFactory.Create); // push 0 to warm
+
+            // touch next 3 values, so they will promote to warm
+            lru.GetOrAdd(4, valueFactory.Create); lru.GetOrAdd(4, valueFactory.Create);
+            lru.GetOrAdd(5, valueFactory.Create); lru.GetOrAdd(5, valueFactory.Create);
+            lru.GetOrAdd(6, valueFactory.Create); lru.GetOrAdd(6, valueFactory.Create);
+
+            // push 4,5,6 to warm, 0 to cold
+            lru.GetOrAdd(7, valueFactory.Create);
+            lru.GetOrAdd(8, valueFactory.Create);
+            lru.GetOrAdd(9, valueFactory.Create);
+
+            // Touch 0
+            lru.TryGet(0, out var value).Should().BeTrue();
+
+            // push 7,8,9 to cold, cycle 0 back to warm
+            lru.GetOrAdd(10, valueFactory.Create);
+            lru.GetOrAdd(11, valueFactory.Create);
+            lru.GetOrAdd(12, valueFactory.Create);
+
+            lru.TryGet(0, out value).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenValueExpiresItIsDisposed()
+        {
+            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, new EqualCapacityPartition(6), EqualityComparer<int>.Default);
+            var disposableValueFactory = new DisposableValueFactory();
+
+            for (int i = 0; i < 7; i++)
+            {
+                lruOfDisposable.GetOrAdd(i, disposableValueFactory.Create);
+            }
+
+            disposableValueFactory.Items[0].IsDisposed.Should().BeTrue();
+
+            disposableValueFactory.Items[1].IsDisposed.Should().BeFalse();
+            disposableValueFactory.Items[2].IsDisposed.Should().BeFalse();
+            disposableValueFactory.Items[3].IsDisposed.Should().BeFalse();
+            disposableValueFactory.Items[4].IsDisposed.Should().BeFalse();
+            disposableValueFactory.Items[5].IsDisposed.Should().BeFalse();
+            disposableValueFactory.Items[6].IsDisposed.Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenAddingNullValueCanBeAddedAndRemoved()
+        {
+            lru.GetOrAdd(1, _ => null).Should().BeNull();
+            lru.AddOrUpdate(1, null);
+            lru.TryRemove(1).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenValueEvictedItemRemovedEventIsFired()
+        {
+            var lruEvents = new ConcurrentLru<int, int>(1, new EqualCapacityPartition(6), EqualityComparer<int>.Default);
+            lruEvents.Events.Value.ItemRemoved += OnLruItemRemoved;
+
+            // First 6 adds
+            // hot[6, 5], warm[2, 1], cold[4, 3]
+            // =>
+            // hot[8, 7], warm[1, 0], cold[6, 5], evicted[4, 3]
+            for (int i = 0; i < 8; i++)
+            {
+                lruEvents.GetOrAdd(i + 1, i => i + 1);
+            }
+
+            removedItems.Count.Should().Be(2);
+
+            removedItems[0].Key.Should().Be(1);
+            removedItems[0].Value.Should().Be(2);
+            removedItems[0].Reason.Should().Be(ItemRemovedReason.Evicted);
+
+            removedItems[1].Key.Should().Be(4);
+            removedItems[1].Value.Should().Be(5);
+            removedItems[1].Reason.Should().Be(ItemRemovedReason.Evicted);
+        }
+
+        [Fact]
+        public void WhenValuesAreEvictedEvictionMetricCountsEvicted()
+        {
+            this.Warmup();
+
+            this.lru.GetOrAdd(1, valueFactory.Create);
+
+            this.lru.Metrics.Value.Evicted.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenItemRemovedEventIsUnregisteredEventIsNotFired()
+        {
+            var lruEvents = new ConcurrentLru<int, int>(1, 6, EqualityComparer<int>.Default);
+
+            lruEvents.Events.Value.ItemRemoved += OnLruItemRemoved;
+            lruEvents.Events.Value.ItemRemoved -= OnLruItemRemoved;
+
+            for (int i = 0; i < 6; i++)
+            {
+                lruEvents.GetOrAdd(i + 1, i => i + 1);
+            }
+
+            removedItems.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenKeyExistsTryRemoveRemovesItemAndReturnsTrue()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryRemove(1).Should().BeTrue();
+            lru.TryGet(1, out var value).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyExistsTryRemoveReturnsValue()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryRemove(1, out var value).Should().BeTrue();
+            value.Should().Be("1");
         }
 
-        public class KeysInOrderTestDataGenerator : IEnumerable<object[]>
+        [Fact]
+        public void WhenItemIsRemovedItIsDisposed()
         {
-            private readonly List<object[]> _data = new List<object[]>
+            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, 6, EqualityComparer<int>.Default);
+            var disposableValueFactory = new DisposableValueFactory();
+
+            lruOfDisposable.GetOrAdd(1, disposableValueFactory.Create);
+            lruOfDisposable.TryRemove(1);
+
+            disposableValueFactory.Items[1].IsDisposed.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenItemIsRemovedRemovedEventIsFired()
+        {
+            var lruEvents = new ConcurrentLru<int, int>(1, 6, EqualityComparer<int>.Default);
+            lruEvents.Events.Value.ItemRemoved += OnLruItemRemoved;
+
+            lruEvents.GetOrAdd(1, i => i + 2);
+
+            lruEvents.TryRemove(1).Should().BeTrue();
+
+            removedItems.Count().Should().Be(1);
+            removedItems[0].Key.Should().Be(1);
+            removedItems[0].Value.Should().Be(3);
+            removedItems[0].Reason.Should().Be(ItemRemovedReason.Removed);
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryRemoveReturnsFalse()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryRemove(2).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenRepeatedlyAddingAndRemovingSameValueLruRemainsInConsistentState()
+        {
+            int capacity = hotCap + coldCap + warmCap;
+            for (int i = 0; i < capacity; i++)
             {
-                new object[] { new EqualCapacityPartition(hotCap + warmCap + coldCap) },
-                new object[] { new EqualCapacityPartition(128) },
-                new object[] { new EqualCapacityPartition(256) },
-                new object[] { new EqualCapacityPartition(1024) },
-                new object[] { new FavorWarmPartition(128) },
-                new object[] { new FavorWarmPartition(256) },
-                new object[] { new FavorWarmPartition(1024) },
-                new object[] { new FavorWarmPartition(128, 0.6) },
-                new object[] { new FavorWarmPartition(256, 0.6) },
-                new object[] { new FavorWarmPartition(1024, 0.6) },
-            };
+                // Because TryRemove leaves the item in the queue, when it is eventually removed
+                // from the cold queue, it should not remove the newly created value.
+                lru.GetOrAdd(1, valueFactory.Create);
+                lru.TryGet(1, out var value).Should().BeTrue();
+                lru.TryRemove(1);
+            }
+        }
 
-            public IEnumerator<object[]> GetEnumerator() => _data.GetEnumerator();
+        [Fact]
+        public void WhenKeyExistsTryUpdateUpdatesValueAndReturnsTrue()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
 
-            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+            lru.TryUpdate(1, "2").Should().BeTrue();
+
+            lru.TryGet(1, out var value);
+            value.Should().Be("2");
         }
 
-        [Theory]
-        [ClassData(typeof(KeysInOrderTestDataGenerator))]
-        public void WhenKeysAreContinuouslyRequestedInTheOrderTheyAreAddedCountIsBounded2(ICapacityPartition p)
-        {
-            int capacity = p.Hot + p.Cold + p.Warm;
-            lru = new ConcurrentLru<int, string>(capacity, p, EqualityComparer<int>.Default);
-
-            testOutputHelper.WriteLine($"Capacity: {lru.Capacity} (Hot: {p.Hot} Warm: {p.Warm} Cold: {p.Cold})");
-
-            for (int i = 0; i < capacity + 10; i++)
-            {
-                lru.GetOrAdd(i, valueFactory.Create);
-
-                // Touch all items already cached in hot, warm and cold.
-                // This is worst case scenario, since we touch them in the exact order they
-                // were added.
-                for (int j = 0; j < i; j++)
-                {
-                    lru.GetOrAdd(j, valueFactory.Create);
-                }
+        [Fact]
+        public void WhenKeyExistsTryUpdateDisposesOldValue()
+        {
+            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, 6, EqualityComparer<int>.Default);
+            var disposableValueFactory = new DisposableValueFactory();
+            var newValue = new DisposableItem();
 
-                lru.Count.Should().BeLessOrEqualTo(capacity + 1, $"Total: {lru.Count} Hot: {lru.HotCount} Warm: {lru.WarmCount} Cold: {lru.ColdCount}");
-            }
-        }
-
-        [Fact]
-        public void WhenValueIsNotTouchedAndExpiresFromHotValueIsBumpedToCold()
-        {
-            this.Warmup();
-
-            lru.GetOrAdd(0, valueFactory.Create); // Don't touch in hot
-
-            lru.GetOrAdd(1, valueFactory.Create);
-            lru.GetOrAdd(2, valueFactory.Create);
-            lru.GetOrAdd(3, valueFactory.Create);
-            lru.GetOrAdd(4, valueFactory.Create);
-            lru.GetOrAdd(5, valueFactory.Create);
-            lru.GetOrAdd(6, valueFactory.Create);
-            lru.GetOrAdd(7, valueFactory.Create);
-            lru.GetOrAdd(8, valueFactory.Create);
-            lru.GetOrAdd(9, valueFactory.Create);
-
-            lru.TryGet(0, out var value).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenValueIsTouchedAndExpiresFromHotValueIsBumpedToWarm()
-        {
-            this.Warmup();
-
-            lru.GetOrAdd(0, valueFactory.Create);
-            lru.GetOrAdd(0, valueFactory.Create); // Touch in hot
-
-            lru.GetOrAdd(1, valueFactory.Create);
-            lru.GetOrAdd(2, valueFactory.Create);
-            lru.GetOrAdd(3, valueFactory.Create);
-            lru.GetOrAdd(4, valueFactory.Create);
-            lru.GetOrAdd(5, valueFactory.Create);
-            lru.GetOrAdd(6, valueFactory.Create);
-            lru.GetOrAdd(7, valueFactory.Create);
-            lru.GetOrAdd(8, valueFactory.Create);
-            lru.GetOrAdd(9, valueFactory.Create);
-
-            lru.TryGet(0, out var value).Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenValueIsTouchedAndExpiresFromColdItIsBumpedToWarm()
-        {
-            this.Warmup();
-
-            lru.GetOrAdd(0, valueFactory.Create);
-
-            lru.GetOrAdd(1, valueFactory.Create);
-            lru.GetOrAdd(2, valueFactory.Create);
-            lru.GetOrAdd(3, valueFactory.Create); // push 0 to cold (not touched in hot)
-
-            lru.GetOrAdd(0, valueFactory.Create); // Touch 0 in cold
-
-            lru.GetOrAdd(4, valueFactory.Create); // fully cycle cold, this will evict 0 if it is not moved to warm
-            lru.GetOrAdd(5, valueFactory.Create);
-            lru.GetOrAdd(6, valueFactory.Create);
-            lru.GetOrAdd(7, valueFactory.Create);
-            lru.GetOrAdd(8, valueFactory.Create);
-            lru.GetOrAdd(9, valueFactory.Create);
-
-            lru.TryGet(0, out var value).Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenValueIsNotTouchedAndExpiresFromColdItIsRemoved()
-        {
-            this.Warmup();
-
-            lru.GetOrAdd(0, valueFactory.Create);
-
-            lru.GetOrAdd(1, valueFactory.Create);
-            lru.GetOrAdd(2, valueFactory.Create);
-            lru.GetOrAdd(3, valueFactory.Create); // push 0 to cold (not touched in hot)
-
-            // Don't touch 0 in cold
-
-            lru.GetOrAdd(4, valueFactory.Create); // fully cycle cold, this will evict 0 if it is not moved to warm
-            lru.GetOrAdd(5, valueFactory.Create);
-            lru.GetOrAdd(6, valueFactory.Create);
-            lru.GetOrAdd(7, valueFactory.Create);
-            lru.GetOrAdd(8, valueFactory.Create);
-            lru.GetOrAdd(9, valueFactory.Create);
-
-            lru.TryGet(0, out var value).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenValueIsNotTouchedAndExpiresFromWarmValueIsBumpedToCold()
-        {
-            this.Warmup();
-
-            lru.GetOrAdd(0, valueFactory.Create);
-            lru.GetOrAdd(0, valueFactory.Create); // Touch 0 in hot, it will promote to warm
-
-            lru.GetOrAdd(1, valueFactory.Create);
-            lru.GetOrAdd(2, valueFactory.Create);
-            lru.GetOrAdd(3, valueFactory.Create); // push 0 to warm
-
-            // touch next 3 values, so they will promote to warm
-            lru.GetOrAdd(4, valueFactory.Create); lru.GetOrAdd(4, valueFactory.Create);
-            lru.GetOrAdd(5, valueFactory.Create); lru.GetOrAdd(5, valueFactory.Create);
-            lru.GetOrAdd(6, valueFactory.Create); lru.GetOrAdd(6, valueFactory.Create);
-
-            // push 4,5,6 to warm, 0 to cold
-            lru.GetOrAdd(7, valueFactory.Create);
-            lru.GetOrAdd(8, valueFactory.Create);
-            lru.GetOrAdd(9, valueFactory.Create);
-
-            // verify 0 is present, but don't touch it
-            lru.Keys.Should().Contain(0);
-
-            // push 7,8,9 to cold, evict 0
-            lru.GetOrAdd(10, valueFactory.Create);
-            lru.GetOrAdd(11, valueFactory.Create);
-            lru.GetOrAdd(12, valueFactory.Create);
-
-            lru.TryGet(0, out var value).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenValueIsTouchedAndExpiresFromWarmValueIsBumpedBackIntoWarm()
-        {
-            this.Warmup();
-
-            lru.GetOrAdd(0, valueFactory.Create);
-            lru.GetOrAdd(0, valueFactory.Create); // Touch 0 in hot, it will promote to warm
-
-            lru.GetOrAdd(1, valueFactory.Create);
-            lru.GetOrAdd(2, valueFactory.Create);
-            lru.GetOrAdd(3, valueFactory.Create); // push 0 to warm
-
-            // touch next 3 values, so they will promote to warm
-            lru.GetOrAdd(4, valueFactory.Create); lru.GetOrAdd(4, valueFactory.Create);
-            lru.GetOrAdd(5, valueFactory.Create); lru.GetOrAdd(5, valueFactory.Create);
-            lru.GetOrAdd(6, valueFactory.Create); lru.GetOrAdd(6, valueFactory.Create);
-
-            // push 4,5,6 to warm, 0 to cold
-            lru.GetOrAdd(7, valueFactory.Create);
-            lru.GetOrAdd(8, valueFactory.Create);
-            lru.GetOrAdd(9, valueFactory.Create);
-
-            // Touch 0
-            lru.TryGet(0, out var value).Should().BeTrue();
-
-            // push 7,8,9 to cold, cycle 0 back to warm
-            lru.GetOrAdd(10, valueFactory.Create);
-            lru.GetOrAdd(11, valueFactory.Create);
-            lru.GetOrAdd(12, valueFactory.Create);
-
-            lru.TryGet(0, out value).Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenValueExpiresItIsDisposed()
-        {
-            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, new EqualCapacityPartition(6), EqualityComparer<int>.Default);
-            var disposableValueFactory = new DisposableValueFactory();
-
-            for (int i = 0; i < 7; i++)
-            {
-                lruOfDisposable.GetOrAdd(i, disposableValueFactory.Create);
-            }
-
-            disposableValueFactory.Items[0].IsDisposed.Should().BeTrue();
-
-            disposableValueFactory.Items[1].IsDisposed.Should().BeFalse();
-            disposableValueFactory.Items[2].IsDisposed.Should().BeFalse();
-            disposableValueFactory.Items[3].IsDisposed.Should().BeFalse();
-            disposableValueFactory.Items[4].IsDisposed.Should().BeFalse();
-            disposableValueFactory.Items[5].IsDisposed.Should().BeFalse();
-            disposableValueFactory.Items[6].IsDisposed.Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenAddingNullValueCanBeAddedAndRemoved()
+            lruOfDisposable.GetOrAdd(1, disposableValueFactory.Create);
+            lruOfDisposable.TryUpdate(1, newValue);
+
+            disposableValueFactory.Items[1].IsDisposed.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryUpdateReturnsFalse()
         {
-            lru.GetOrAdd(1, _ => null).Should().BeNull();
-            lru.AddOrUpdate(1, null);
-            lru.TryRemove(1).Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenValueEvictedItemRemovedEventIsFired()
-        {
-            var lruEvents = new ConcurrentLru<int, int>(1, new EqualCapacityPartition(6), EqualityComparer<int>.Default);
-            lruEvents.Events.Value.ItemRemoved += OnLruItemRemoved;
-
-            // First 6 adds
-            // hot[6, 5], warm[2, 1], cold[4, 3]
-            // =>
-            // hot[8, 7], warm[1, 0], cold[6, 5], evicted[4, 3]
-            for (int i = 0; i < 8; i++)
-            {
-                lruEvents.GetOrAdd(i + 1, i => i + 1);
-            }
-
-            removedItems.Count.Should().Be(2);
-
-            removedItems[0].Key.Should().Be(1);
-            removedItems[0].Value.Should().Be(2);
-            removedItems[0].Reason.Should().Be(ItemRemovedReason.Evicted);
-
-            removedItems[1].Key.Should().Be(4);
-            removedItems[1].Value.Should().Be(5);
-            removedItems[1].Reason.Should().Be(ItemRemovedReason.Evicted);
-        }
-
-        [Fact]
-        public void WhenValuesAreEvictedEvictionMetricCountsEvicted()
-        {
-            this.Warmup();
-
-            this.lru.GetOrAdd(1, valueFactory.Create);
-
-            this.lru.Metrics.Value.Evicted.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenItemRemovedEventIsUnregisteredEventIsNotFired()
-        {
-            var lruEvents = new ConcurrentLru<int, int>(1, 6, EqualityComparer<int>.Default);
-
-            lruEvents.Events.Value.ItemRemoved += OnLruItemRemoved;
-            lruEvents.Events.Value.ItemRemoved -= OnLruItemRemoved;
-
-            for (int i = 0; i < 6; i++)
-            {
-                lruEvents.GetOrAdd(i + 1, i => i + 1);
-            }
-
-            removedItems.Count.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenKeyExistsTryRemoveRemovesItemAndReturnsTrue()
-        {
-            lru.GetOrAdd(1, valueFactory.Create);
-
-            lru.TryRemove(1).Should().BeTrue();
-            lru.TryGet(1, out var value).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenKeyExistsTryRemoveReturnsValue()
-        {
-            lru.GetOrAdd(1, valueFactory.Create);
-
-            lru.TryRemove(1, out var value).Should().BeTrue();
-            value.Should().Be("1");
-        }
-
-        [Fact]
-        public void WhenItemIsRemovedItIsDisposed()
-        {
-            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, 6, EqualityComparer<int>.Default);
-            var disposableValueFactory = new DisposableValueFactory();
-
-            lruOfDisposable.GetOrAdd(1, disposableValueFactory.Create);
-            lruOfDisposable.TryRemove(1);
-
-            disposableValueFactory.Items[1].IsDisposed.Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenItemIsRemovedRemovedEventIsFired()
-        {
-            var lruEvents = new ConcurrentLru<int, int>(1, 6, EqualityComparer<int>.Default);
-            lruEvents.Events.Value.ItemRemoved += OnLruItemRemoved;
-
-            lruEvents.GetOrAdd(1, i => i + 2);
-
-            lruEvents.TryRemove(1).Should().BeTrue();
-
-            removedItems.Count().Should().Be(1);
-            removedItems[0].Key.Should().Be(1);
-            removedItems[0].Value.Should().Be(3);
-            removedItems[0].Reason.Should().Be(ItemRemovedReason.Removed);
-        }
-
-        [Fact]
-        public void WhenKeyDoesNotExistTryRemoveReturnsFalse()
-        {
-            lru.GetOrAdd(1, valueFactory.Create);
-
-            lru.TryRemove(2).Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenRepeatedlyAddingAndRemovingSameValueLruRemainsInConsistentState()
-        {
-            int capacity = hotCap + coldCap + warmCap;
-            for (int i = 0; i < capacity; i++)
-            {
-                // Because TryRemove leaves the item in the queue, when it is eventually removed
-                // from the cold queue, it should not remove the newly created value.
-                lru.GetOrAdd(1, valueFactory.Create);
-                lru.TryGet(1, out var value).Should().BeTrue();
-                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 WhenKeyExistsTryUpdateDisposesOldValue()
-        {
-            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, 6, EqualityComparer<int>.Default);
-            var disposableValueFactory = new DisposableValueFactory();
-            var newValue = new DisposableItem();
-
-            lruOfDisposable.GetOrAdd(1, disposableValueFactory.Create);
-            lruOfDisposable.TryUpdate(1, newValue);
-
-            disposableValueFactory.Items[1].IsDisposed.Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenKeyDoesNotExistTryUpdateReturnsFalse()
-        {
-            lru.GetOrAdd(1, valueFactory.Create);
-
-            lru.TryUpdate(2, "3").Should().BeFalse();
-        }
-
-// backcompat: remove conditional compile
-#if NETCOREAPP3_0_OR_GREATER
-        [Fact]
-        public void WhenKeyExistsTryUpdateIncrementsUpdateCount()
-        {
-            lru.GetOrAdd(1, valueFactory.Create);
-
-            lru.TryUpdate(1, "2").Should().BeTrue();
-
-            lru.Metrics.Value.Updated.Should().Be(1);
-        }
-
-        [Fact]
-        public void WhenKeyDoesNotExistTryUpdateDoesNotIncrementCounter()
-        {
-            lru.GetOrAdd(1, valueFactory.Create);
-
-            lru.TryUpdate(2, "3").Should().BeFalse();
-
-            lru.Metrics.Value.Updated.Should().Be(0);
-        }
-#endif
-        [Fact]
-        public void WhenKeyDoesNotExistAddOrUpdateAddsNewItem()
-        {
-            lru.AddOrUpdate(1, "1");
-
-            lru.TryGet(1, out var value).Should().BeTrue();
-            value.Should().Be("1");
-        }
-
-        [Fact]
-        public void WhenKeyExistsAddOrUpdateUpdatesExistingItem()
-        {
-            lru.AddOrUpdate(1, "1");
-            lru.AddOrUpdate(1, "2");
-
-            lru.TryGet(1, out var value).Should().BeTrue();
-            value.Should().Be("2");
-        }
-
-        [Fact]
-        public void WhenKeyExistsAddOrUpdateDisposesOldValue()
-        {
-            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, 6, EqualityComparer<int>.Default);
-            var disposableValueFactory = new DisposableValueFactory();
-            var newValue = new DisposableItem();
-
-            lruOfDisposable.GetOrAdd(1, disposableValueFactory.Create);
-            lruOfDisposable.AddOrUpdate(1, newValue);
-
-            disposableValueFactory.Items[1].IsDisposed.Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenKeyDoesNotExistAddOrUpdateMaintainsLruOrder()
-        {
-            lru.AddOrUpdate(1, "1");
-            lru.AddOrUpdate(2, "2");
-            lru.AddOrUpdate(3, "3");
-            lru.AddOrUpdate(4, "4");
-
-            lru.HotCount.Should().Be(3);
-            lru.WarmCount.Should().Be(1); // items must have been enqueued and cycled for one of them to reach the warm queue
-        }
-
-// backcompat: remove conditional compile
-#if NETCOREAPP3_0_OR_GREATER
-        [Fact]
-        public void WhenItemExistsAddOrUpdateFiresUpdateEvent()
-        {
-            var lruEvents = new ConcurrentLru<int, int>(1, new EqualCapacityPartition(6), EqualityComparer<int>.Default);
-            lruEvents.Events.Value.ItemUpdated += OnLruItemUpdated;
-
-            lruEvents.AddOrUpdate(1, 2);
-            lruEvents.AddOrUpdate(2, 3);
-
-            lruEvents.AddOrUpdate(1, 3);
-
-            this.updatedItems.Count.Should().Be(1);
-            this.updatedItems[0].Key.Should().Be(1);
-            this.updatedItems[0].OldValue.Should().Be(2);
-            this.updatedItems[0].NewValue.Should().Be(3);
-        }
-
-        [Fact]
-        public void WhenItemExistsTryUpdateFiresUpdateEvent()
-        {
-            var lruEvents = new ConcurrentLru<int, int>(1, new EqualCapacityPartition(6), EqualityComparer<int>.Default);
-            lruEvents.Events.Value.ItemUpdated += OnLruItemUpdated;
-
-            lruEvents.AddOrUpdate(1, 2);
-            lruEvents.AddOrUpdate(2, 3);
-
-            lruEvents.TryUpdate(1, 3);
-
-            this.updatedItems.Count.Should().Be(1);
-            this.updatedItems[0].Key.Should().Be(1);
-            this.updatedItems[0].OldValue.Should().Be(2);
-            this.updatedItems[0].NewValue.Should().Be(3);
-        }
-
-        [Fact]
-        public void WhenItemUpdatedEventIsUnregisteredEventIsNotFired()
-        {
-            var lruEvents = new ConcurrentLru<int, int>(1, 6, EqualityComparer<int>.Default);
-
-            lruEvents.Events.Value.ItemUpdated += OnLruItemUpdated;
-            lruEvents.Events.Value.ItemUpdated -= OnLruItemUpdated;
-
-            lruEvents.AddOrUpdate(1, 2);
-            lruEvents.AddOrUpdate(1, 2);
-            lruEvents.AddOrUpdate(1, 2);
-
-            updatedItems.Count.Should().Be(0);
-        }
-#endif
-
-        [Fact]
-        public void WhenCacheIsEmptyClearIsNoOp()
-        {
-            lru.Clear();
-            lru.Count.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenItemsExistClearRemovesAllItems()
-        {
-            lru.AddOrUpdate(1, "1");
-            lru.AddOrUpdate(2, "2");
-
-            lru.Clear();
-
-            lru.Count.Should().Be(0);
-
-            // verify queues are purged
-            lru.HotCount.Should().Be(0);
-            lru.WarmCount.Should().Be(0);
-            lru.ColdCount.Should().Be(0);
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryUpdate(2, "3").Should().BeFalse();
+        }
+
+// backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        [Fact]
+        public void WhenKeyExistsTryUpdateIncrementsUpdateCount()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryUpdate(1, "2").Should().BeTrue();
+
+            lru.Metrics.Value.Updated.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistTryUpdateDoesNotIncrementCounter()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryUpdate(2, "3").Should().BeFalse();
+
+            lru.Metrics.Value.Updated.Should().Be(0);
+        }
+#endif
+        [Fact]
+        public void WhenKeyDoesNotExistAddOrUpdateAddsNewItem()
+        {
+            lru.AddOrUpdate(1, "1");
+
+            lru.TryGet(1, out var value).Should().BeTrue();
+            value.Should().Be("1");
+        }
+
+        [Fact]
+        public void WhenKeyExistsAddOrUpdateUpdatesExistingItem()
+        {
+            lru.AddOrUpdate(1, "1");
+            lru.AddOrUpdate(1, "2");
+
+            lru.TryGet(1, out var value).Should().BeTrue();
+            value.Should().Be("2");
+        }
+
+        [Fact]
+        public void WhenKeyExistsAddOrUpdateDisposesOldValue()
+        {
+            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, 6, EqualityComparer<int>.Default);
+            var disposableValueFactory = new DisposableValueFactory();
+            var newValue = new DisposableItem();
+
+            lruOfDisposable.GetOrAdd(1, disposableValueFactory.Create);
+            lruOfDisposable.AddOrUpdate(1, newValue);
+
+            disposableValueFactory.Items[1].IsDisposed.Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenKeyDoesNotExistAddOrUpdateMaintainsLruOrder()
+        {
+            lru.AddOrUpdate(1, "1");
+            lru.AddOrUpdate(2, "2");
+            lru.AddOrUpdate(3, "3");
+            lru.AddOrUpdate(4, "4");
+
+            lru.HotCount.Should().Be(3);
+            lru.WarmCount.Should().Be(1); // items must have been enqueued and cycled for one of them to reach the warm queue
+        }
+
+// backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        [Fact]
+        public void WhenItemExistsAddOrUpdateFiresUpdateEvent()
+        {
+            var lruEvents = new ConcurrentLru<int, int>(1, new EqualCapacityPartition(6), EqualityComparer<int>.Default);
+            lruEvents.Events.Value.ItemUpdated += OnLruItemUpdated;
+
+            lruEvents.AddOrUpdate(1, 2);
+            lruEvents.AddOrUpdate(2, 3);
+
+            lruEvents.AddOrUpdate(1, 3);
+
+            this.updatedItems.Count.Should().Be(1);
+            this.updatedItems[0].Key.Should().Be(1);
+            this.updatedItems[0].OldValue.Should().Be(2);
+            this.updatedItems[0].NewValue.Should().Be(3);
+        }
+
+        [Fact]
+        public void WhenItemExistsTryUpdateFiresUpdateEvent()
+        {
+            var lruEvents = new ConcurrentLru<int, int>(1, new EqualCapacityPartition(6), EqualityComparer<int>.Default);
+            lruEvents.Events.Value.ItemUpdated += OnLruItemUpdated;
+
+            lruEvents.AddOrUpdate(1, 2);
+            lruEvents.AddOrUpdate(2, 3);
+
+            lruEvents.TryUpdate(1, 3);
+
+            this.updatedItems.Count.Should().Be(1);
+            this.updatedItems[0].Key.Should().Be(1);
+            this.updatedItems[0].OldValue.Should().Be(2);
+            this.updatedItems[0].NewValue.Should().Be(3);
+        }
+
+        [Fact]
+        public void WhenItemUpdatedEventIsUnregisteredEventIsNotFired()
+        {
+            var lruEvents = new ConcurrentLru<int, int>(1, 6, EqualityComparer<int>.Default);
+
+            lruEvents.Events.Value.ItemUpdated += OnLruItemUpdated;
+            lruEvents.Events.Value.ItemUpdated -= OnLruItemUpdated;
+
+            lruEvents.AddOrUpdate(1, 2);
+            lruEvents.AddOrUpdate(1, 2);
+            lruEvents.AddOrUpdate(1, 2);
+
+            updatedItems.Count.Should().Be(0);
+        }
+#endif
+
+        [Fact]
+        public void WhenCacheIsEmptyClearIsNoOp()
+        {
+            lru.Clear();
+            lru.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenItemsExistClearRemovesAllItems()
+        {
+            lru.AddOrUpdate(1, "1");
+            lru.AddOrUpdate(2, "2");
+
+            lru.Clear();
+
+            lru.Count.Should().Be(0);
+
+            // verify queues are purged
+            lru.HotCount.Should().Be(0);
+            lru.WarmCount.Should().Be(0);
+            lru.ColdCount.Should().Be(0);
         }
 
         // This is a special case:
@@ -895,353 +895,353 @@ public void WhenCacheIsSize3ItemsExistAndItemsAccessedClearRemovesAllItems()
             lru.Count.Should().Be(0);
         }
 
-        [Theory]
-        [InlineData(1)]
-        [InlineData(2)]
-        [InlineData(3)]
-        [InlineData(4)]
-        [InlineData(5)]
-        [InlineData(6)]
-        [InlineData(7)]
-        [InlineData(8)]
-        [InlineData(9)]
-        [InlineData(10)]
-        public void WhenItemsExistAndItemsAccessedClearRemovesAllItems(int itemCount)
-        {
-            // By default capacity is 9. Test all possible states of touched items
-            // in the cache.
-
-            for (int i = 0; i < itemCount; i++) 
+        [Theory]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        [InlineData(4)]
+        [InlineData(5)]
+        [InlineData(6)]
+        [InlineData(7)]
+        [InlineData(8)]
+        [InlineData(9)]
+        [InlineData(10)]
+        public void WhenItemsExistAndItemsAccessedClearRemovesAllItems(int itemCount)
+        {
+            // By default capacity is 9. Test all possible states of touched items
+            // in the cache.
+
+            for (int i = 0; i < itemCount; i++) 
             {
-                lru.AddOrUpdate(i, "1");
+                lru.AddOrUpdate(i, "1");
             }
 
             // touch n items
             for (int i = 0; i < itemCount; i++)
             {
-                lru.TryGet(i, out _);
-            }
-
-            lru.Clear();
-
-            this.testOutputHelper.WriteLine("LRU " + string.Join(" ", lru.Keys));
-
-            lru.Count.Should().Be(0);
-
-            // verify queues are purged
-            lru.HotCount.Should().Be(0);
-            lru.WarmCount.Should().Be(0);
-            lru.ColdCount.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenWarmThenClearedIsWarmIsReset()
-        {
+                lru.TryGet(i, out _);
+            }
+
+            lru.Clear();
+
+            this.testOutputHelper.WriteLine("LRU " + string.Join(" ", lru.Keys));
+
+            lru.Count.Should().Be(0);
+
+            // verify queues are purged
+            lru.HotCount.Should().Be(0);
+            lru.WarmCount.Should().Be(0);
+            lru.ColdCount.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenWarmThenClearedIsWarmIsReset()
+        {
             for (int i = 0; i < 20; i++)
-            { 
-                lru.GetOrAdd(i, k => k.ToString()); 
-            }
-
-            lru.Clear();
-            lru.Count.Should().Be(0);
-
+            { 
+                lru.GetOrAdd(i, k => k.ToString()); 
+            }
+
+            lru.Clear();
+            lru.Count.Should().Be(0);
+
             for (int i = 0; i < 20; i++)
-            { 
-                lru.GetOrAdd(i, k => k.ToString()); 
-            }
-
-            lru.Count.Should().Be(capacity.Hot + capacity.Warm + capacity.Cold);
-        }
-
-        [Fact]
-        public void WhenItemsAreDisposableClearDisposesItemsOnRemove()
-        {
-            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, 6, EqualityComparer<int>.Default);
-
-            var items = Enumerable.Range(1, 4).Select(i => new DisposableItem()).ToList();
-
-            for (int i = 0; i < 4; i++)
-            {
-                lruOfDisposable.AddOrUpdate(i, items[i]);
-            }
-
-            lruOfDisposable.Clear();
-
-            items.All(i => i.IsDisposed == true).Should().BeTrue();
-        }
-
-        [Fact]
-        public void WhenItemsArClearedAnEventIsFired()
-        {
-            var lruEvents = new ConcurrentLru<int, int>(1, capacity, EqualityComparer<int>.Default);
-            lruEvents.Events.Value.ItemRemoved += OnLruItemRemoved;
-
-            for (int i = 0; i < 6; i++)
-            {
-                lruEvents.GetOrAdd(i + 1, i => i + 1);
-            }
-
-            lruEvents.Clear();
-
-            removedItems.Count.Should().Be(6);
-
-            for (int i = 0; i < 6; i++)
-            {
-                removedItems[i].Reason.Should().Be(ItemRemovedReason.Cleared);
-            }
-        }
-
-        [Fact]
-        public void WhenTrimCountIsZeroThrows()
-        {
-            lru.Invoking(l => lru.Trim(0)).Should().Throw<ArgumentOutOfRangeException>();
-        }
-
-        [Fact]
-        public void WhenTrimCountIsMoreThanCapacityThrows()
-        {
-            lru.Invoking(l => lru.Trim(hotCap + warmCap + coldCap + 1)).Should().Throw<ArgumentOutOfRangeException>();
-        }
-
-        [Theory]
-        [InlineData(1, new[] { 9, 8, 7, 3, 2, 1, 6, 5 })]
-        [InlineData(2, new[] { 9, 8, 7, 3, 2, 1, 6 })]
-        [InlineData(3, new[] { 9, 8, 7, 3, 2, 1 })]
-        [InlineData(4, new[] { 9, 8, 7, 3, 2 })]
-        [InlineData(5, new[] { 9, 8, 7, 3 })]
-        [InlineData(6, new[] { 9, 8, 7 })]
-        [InlineData(7, new[] { 9, 8 })]
-        [InlineData(8, new[] { 9 })]
-        [InlineData(9, new int[] { })]
-        public void WhenColdItemsExistTrimRemovesExpectedItemCount(int trimCount, int[] expected)
-        {
-            Warmup();
-
-            // initial state:
-            // Hot = 9, 8, 7
-            // Warm = 3, 2, 1
-            // Cold = 6, 5, 4
-            lru.AddOrUpdate(1, "1");
-            lru.AddOrUpdate(2, "2");
-            lru.AddOrUpdate(3, "3");
-            lru.GetOrAdd(1, i => i.ToString());
-            lru.GetOrAdd(2, i => i.ToString());
-            lru.GetOrAdd(3, i => i.ToString());
-
-            lru.AddOrUpdate(4, "4");
-            lru.AddOrUpdate(5, "5");
-            lru.AddOrUpdate(6, "6");
-
-            lru.AddOrUpdate(7, "7");
-            lru.AddOrUpdate(8, "8");
-            lru.AddOrUpdate(9, "9");
-
-            lru.Trim(trimCount);
-
-            lru.Keys.Should().BeEquivalentTo(expected);
-        }
-
-        [Theory]
-        [InlineData(1, new[] { 6, 5, 4, 3, 2 })]
-        [InlineData(2, new[] { 6, 5, 4, 3 })]
-        [InlineData(3, new[] { 6, 5, 4 })]
-        [InlineData(4, new[] { 6, 5 })]
-        [InlineData(5, new[] { 6 })]
-        [InlineData(6, new int[] { })]
-        [InlineData(7, new int[] { })]
-        [InlineData(8, new int[] { })]
-        [InlineData(9, new int[] { })]
-        public void WhenHotAndWarmItemsExistTrimRemovesExpectedItemCount(int itemCount, int[] expected)
-        {
-            // initial state:
-            // Hot = 6, 5, 4
-            // Warm = 3, 2, 1
-            // Cold = -
-            lru.AddOrUpdate(1, "1");
-            lru.AddOrUpdate(2, "2");
-            lru.AddOrUpdate(3, "3");
-            lru.GetOrAdd(1, i => i.ToString());
-            lru.GetOrAdd(2, i => i.ToString());
-            lru.GetOrAdd(3, i => i.ToString());
-
-            lru.AddOrUpdate(4, "4");
-            lru.AddOrUpdate(5, "5");
-            lru.AddOrUpdate(6, "6");
-
-            lru.Trim(itemCount);
-
-            lru.Keys.Should().BeEquivalentTo(expected);
-        }
-
-        [Theory]
-        [InlineData(1, new[] { 3, 2 })]
-        [InlineData(2, new[] { 3 })]
-        [InlineData(3, new int[] { })]
-        [InlineData(4, new int[] { })]
-        [InlineData(5, new int[] { })]
-        [InlineData(6, new int[] { })]
-        [InlineData(7, new int[] { })]
-        [InlineData(8, new int[] { })]
-        [InlineData(9, new int[] { })]
-        public void WhenHotItemsExistTrimRemovesExpectedItemCount(int itemCount, int[] expected)
-        {
-            // initial state:
-            // Hot = 3, 2, 1
-            // Warm = -
-            // Cold = -
-            lru.AddOrUpdate(1, "1");
-            lru.AddOrUpdate(2, "2");
-            lru.AddOrUpdate(3, "3");
-
-            lru.Trim(itemCount);
-
-            lru.Keys.Should().BeEquivalentTo(expected);
-        }
-
-        [Theory]
-        [InlineData(1, new[] { 9, 8, 7, 6, 5, 4, 3, 2 })]
-        [InlineData(2, new[] { 9, 8, 7, 6, 5, 4, 3 })]
-        [InlineData(3, new[] { 9, 8, 7, 6, 5, 4 })]
-        [InlineData(4, new[] { 9, 8, 7, 6, 5 })]
-        [InlineData(5, new[] { 9, 8, 7, 6 })]
-        [InlineData(6, new[] { 9, 8, 7 })]
-        [InlineData(7, new[] { 9, 8 })]
-        [InlineData(8, new[] { 9 })]
-        [InlineData(9, new int[] { })]
-        public void WhenColdItemsAreTouchedTrimRemovesExpectedItemCount(int trimCount, int[] expected)
-        {
-            Warmup();
-
-            // initial state:
-            // Hot = 9, 8, 7
-            // Warm = 3, 2, 1
-            // Cold = 6*, 5*, 4*
-            lru.AddOrUpdate(1, "1");
-            lru.AddOrUpdate(2, "2");
-            lru.AddOrUpdate(3, "3");
-            lru.GetOrAdd(1, i => i.ToString());
-            lru.GetOrAdd(2, i => i.ToString());
-            lru.GetOrAdd(3, i => i.ToString());
-
-            lru.AddOrUpdate(4, "4");
-            lru.AddOrUpdate(5, "5");
-            lru.AddOrUpdate(6, "6");
-
-            lru.AddOrUpdate(7, "7");
-            lru.AddOrUpdate(8, "8");
-            lru.AddOrUpdate(9, "9");
-
-            // touch all items in the cold queue
-            lru.GetOrAdd(4, i => i.ToString());
-            lru.GetOrAdd(5, i => i.ToString());
-            lru.GetOrAdd(6, i => i.ToString());
-
-            lru.Trim(trimCount);
-
-            this.testOutputHelper.WriteLine("LRU " + string.Join(" ", lru.Keys));
-            this.testOutputHelper.WriteLine("exp " + string.Join(" ", expected));
-
-            lru.Keys.Should().BeEquivalentTo(expected);
-        }
-
-        [Theory]
-        [InlineData(1)]
-        [InlineData(2)]
-        [InlineData(3)]
-        [InlineData(4)]
-        [InlineData(5)]
-        [InlineData(6)]
-        [InlineData(7)]
-        [InlineData(8)]
-        [InlineData(9)]
-        [InlineData(10)]
-        public void WhenItemsExistAndItemsAccessedTrimRemovesAllItems(int itemCount)
-        {
-            // By default capacity is 9. Test all possible states of touched items
-            // in the cache.
-
+            { 
+                lru.GetOrAdd(i, k => k.ToString()); 
+            }
+
+            lru.Count.Should().Be(capacity.Hot + capacity.Warm + capacity.Cold);
+        }
+
+        [Fact]
+        public void WhenItemsAreDisposableClearDisposesItemsOnRemove()
+        {
+            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, 6, EqualityComparer<int>.Default);
+
+            var items = Enumerable.Range(1, 4).Select(i => new DisposableItem()).ToList();
+
+            for (int i = 0; i < 4; i++)
+            {
+                lruOfDisposable.AddOrUpdate(i, items[i]);
+            }
+
+            lruOfDisposable.Clear();
+
+            items.All(i => i.IsDisposed == true).Should().BeTrue();
+        }
+
+        [Fact]
+        public void WhenItemsArClearedAnEventIsFired()
+        {
+            var lruEvents = new ConcurrentLru<int, int>(1, capacity, EqualityComparer<int>.Default);
+            lruEvents.Events.Value.ItemRemoved += OnLruItemRemoved;
+
+            for (int i = 0; i < 6; i++)
+            {
+                lruEvents.GetOrAdd(i + 1, i => i + 1);
+            }
+
+            lruEvents.Clear();
+
+            removedItems.Count.Should().Be(6);
+
+            for (int i = 0; i < 6; i++)
+            {
+                removedItems[i].Reason.Should().Be(ItemRemovedReason.Cleared);
+            }
+        }
+
+        [Fact]
+        public void WhenTrimCountIsZeroThrows()
+        {
+            lru.Invoking(l => lru.Trim(0)).Should().Throw<ArgumentOutOfRangeException>();
+        }
+
+        [Fact]
+        public void WhenTrimCountIsMoreThanCapacityThrows()
+        {
+            lru.Invoking(l => lru.Trim(hotCap + warmCap + coldCap + 1)).Should().Throw<ArgumentOutOfRangeException>();
+        }
+
+        [Theory]
+        [InlineData(1, new[] { 9, 8, 7, 3, 2, 1, 6, 5 })]
+        [InlineData(2, new[] { 9, 8, 7, 3, 2, 1, 6 })]
+        [InlineData(3, new[] { 9, 8, 7, 3, 2, 1 })]
+        [InlineData(4, new[] { 9, 8, 7, 3, 2 })]
+        [InlineData(5, new[] { 9, 8, 7, 3 })]
+        [InlineData(6, new[] { 9, 8, 7 })]
+        [InlineData(7, new[] { 9, 8 })]
+        [InlineData(8, new[] { 9 })]
+        [InlineData(9, new int[] { })]
+        public void WhenColdItemsExistTrimRemovesExpectedItemCount(int trimCount, int[] expected)
+        {
+            Warmup();
+
+            // initial state:
+            // Hot = 9, 8, 7
+            // Warm = 3, 2, 1
+            // Cold = 6, 5, 4
+            lru.AddOrUpdate(1, "1");
+            lru.AddOrUpdate(2, "2");
+            lru.AddOrUpdate(3, "3");
+            lru.GetOrAdd(1, i => i.ToString());
+            lru.GetOrAdd(2, i => i.ToString());
+            lru.GetOrAdd(3, i => i.ToString());
+
+            lru.AddOrUpdate(4, "4");
+            lru.AddOrUpdate(5, "5");
+            lru.AddOrUpdate(6, "6");
+
+            lru.AddOrUpdate(7, "7");
+            lru.AddOrUpdate(8, "8");
+            lru.AddOrUpdate(9, "9");
+
+            lru.Trim(trimCount);
+
+            lru.Keys.Should().BeEquivalentTo(expected);
+        }
+
+        [Theory]
+        [InlineData(1, new[] { 6, 5, 4, 3, 2 })]
+        [InlineData(2, new[] { 6, 5, 4, 3 })]
+        [InlineData(3, new[] { 6, 5, 4 })]
+        [InlineData(4, new[] { 6, 5 })]
+        [InlineData(5, new[] { 6 })]
+        [InlineData(6, new int[] { })]
+        [InlineData(7, new int[] { })]
+        [InlineData(8, new int[] { })]
+        [InlineData(9, new int[] { })]
+        public void WhenHotAndWarmItemsExistTrimRemovesExpectedItemCount(int itemCount, int[] expected)
+        {
+            // initial state:
+            // Hot = 6, 5, 4
+            // Warm = 3, 2, 1
+            // Cold = -
+            lru.AddOrUpdate(1, "1");
+            lru.AddOrUpdate(2, "2");
+            lru.AddOrUpdate(3, "3");
+            lru.GetOrAdd(1, i => i.ToString());
+            lru.GetOrAdd(2, i => i.ToString());
+            lru.GetOrAdd(3, i => i.ToString());
+
+            lru.AddOrUpdate(4, "4");
+            lru.AddOrUpdate(5, "5");
+            lru.AddOrUpdate(6, "6");
+
+            lru.Trim(itemCount);
+
+            lru.Keys.Should().BeEquivalentTo(expected);
+        }
+
+        [Theory]
+        [InlineData(1, new[] { 3, 2 })]
+        [InlineData(2, new[] { 3 })]
+        [InlineData(3, new int[] { })]
+        [InlineData(4, new int[] { })]
+        [InlineData(5, new int[] { })]
+        [InlineData(6, new int[] { })]
+        [InlineData(7, new int[] { })]
+        [InlineData(8, new int[] { })]
+        [InlineData(9, new int[] { })]
+        public void WhenHotItemsExistTrimRemovesExpectedItemCount(int itemCount, int[] expected)
+        {
+            // initial state:
+            // Hot = 3, 2, 1
+            // Warm = -
+            // Cold = -
+            lru.AddOrUpdate(1, "1");
+            lru.AddOrUpdate(2, "2");
+            lru.AddOrUpdate(3, "3");
+
+            lru.Trim(itemCount);
+
+            lru.Keys.Should().BeEquivalentTo(expected);
+        }
+
+        [Theory]
+        [InlineData(1, new[] { 9, 8, 7, 6, 5, 4, 3, 2 })]
+        [InlineData(2, new[] { 9, 8, 7, 6, 5, 4, 3 })]
+        [InlineData(3, new[] { 9, 8, 7, 6, 5, 4 })]
+        [InlineData(4, new[] { 9, 8, 7, 6, 5 })]
+        [InlineData(5, new[] { 9, 8, 7, 6 })]
+        [InlineData(6, new[] { 9, 8, 7 })]
+        [InlineData(7, new[] { 9, 8 })]
+        [InlineData(8, new[] { 9 })]
+        [InlineData(9, new int[] { })]
+        public void WhenColdItemsAreTouchedTrimRemovesExpectedItemCount(int trimCount, int[] expected)
+        {
+            Warmup();
+
+            // initial state:
+            // Hot = 9, 8, 7
+            // Warm = 3, 2, 1
+            // Cold = 6*, 5*, 4*
+            lru.AddOrUpdate(1, "1");
+            lru.AddOrUpdate(2, "2");
+            lru.AddOrUpdate(3, "3");
+            lru.GetOrAdd(1, i => i.ToString());
+            lru.GetOrAdd(2, i => i.ToString());
+            lru.GetOrAdd(3, i => i.ToString());
+
+            lru.AddOrUpdate(4, "4");
+            lru.AddOrUpdate(5, "5");
+            lru.AddOrUpdate(6, "6");
+
+            lru.AddOrUpdate(7, "7");
+            lru.AddOrUpdate(8, "8");
+            lru.AddOrUpdate(9, "9");
+
+            // touch all items in the cold queue
+            lru.GetOrAdd(4, i => i.ToString());
+            lru.GetOrAdd(5, i => i.ToString());
+            lru.GetOrAdd(6, i => i.ToString());
+
+            lru.Trim(trimCount);
+
+            this.testOutputHelper.WriteLine("LRU " + string.Join(" ", lru.Keys));
+            this.testOutputHelper.WriteLine("exp " + string.Join(" ", expected));
+
+            lru.Keys.Should().BeEquivalentTo(expected);
+        }
+
+        [Theory]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        [InlineData(4)]
+        [InlineData(5)]
+        [InlineData(6)]
+        [InlineData(7)]
+        [InlineData(8)]
+        [InlineData(9)]
+        [InlineData(10)]
+        public void WhenItemsExistAndItemsAccessedTrimRemovesAllItems(int itemCount)
+        {
+            // By default capacity is 9. Test all possible states of touched items
+            // in the cache.
+
             for (int i = 0; i < itemCount; i++)
             {
-                lru.AddOrUpdate(i, "1");
+                lru.AddOrUpdate(i, "1");
             }
 
             // touch n items
             for (int i = 0; i < itemCount; i++)
             {
-                lru.TryGet(i, out _);
-            }
-
-            lru.Trim(Math.Min(itemCount, lru.Capacity));
-
-            this.testOutputHelper.WriteLine("LRU " + string.Join(" ", lru.Keys));
-
-            lru.Count.Should().Be(0);
-
-            // verify queues are purged
-            lru.HotCount.Should().Be(0);
-            lru.WarmCount.Should().Be(0);
-            lru.ColdCount.Should().Be(0);
-        }
-
-        [Fact]
-        public void WhenItemsAreDisposableTrimDisposesItems()
-        {
-            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, new EqualCapacityPartition(6), EqualityComparer<int>.Default);
-
-            var items = Enumerable.Range(1, 4).Select(i => new DisposableItem()).ToList();
-
-            for (int i = 0; i < 4; i++)
-            {
-                lruOfDisposable.AddOrUpdate(i, items[i]);
-            }
-
-            lruOfDisposable.Trim(2);
-
-            items[0].IsDisposed.Should().BeTrue();
-            items[1].IsDisposed.Should().BeTrue();
-            items[2].IsDisposed.Should().BeFalse();
-            items[3].IsDisposed.Should().BeFalse();
-        }
-
-        [Fact]
-        public void WhenItemsAreTrimmedAnEventIsFired()
-        {
-            var lruEvents = new ConcurrentLru<int, int>(1, capacity, EqualityComparer<int>.Default);
-            lruEvents.Events.Value.ItemRemoved += OnLruItemRemoved;
-
-            for (int i = 0; i < 6; i++)
-            {
-                lruEvents.GetOrAdd(i + 1, i => i + 1);
-            }
-
-            lruEvents.Trim(2);
-
-            removedItems.Count.Should().Be(2);
-
-            removedItems[0].Key.Should().Be(1);
-            removedItems[0].Value.Should().Be(2);
-            removedItems[0].Reason.Should().Be(ItemRemovedReason.Trimmed);
-
-            removedItems[1].Key.Should().Be(2);
-            removedItems[1].Value.Should().Be(3);
-            removedItems[1].Reason.Should().Be(ItemRemovedReason.Trimmed);
-        }
-
-
-        private void Warmup()
-        {
-            lru.GetOrAdd(-1, valueFactory.Create);
-            lru.GetOrAdd(-2, valueFactory.Create);
-            lru.GetOrAdd(-3, valueFactory.Create);
-            lru.GetOrAdd(-4, valueFactory.Create);
-            lru.GetOrAdd(-5, valueFactory.Create);
-            lru.GetOrAdd(-6, valueFactory.Create);
-            lru.GetOrAdd(-7, valueFactory.Create);
-            lru.GetOrAdd(-8, valueFactory.Create);
-            lru.GetOrAdd(-9, valueFactory.Create);
-        }
-    }
-
+                lru.TryGet(i, out _);
+            }
+
+            lru.Trim(Math.Min(itemCount, lru.Capacity));
+
+            this.testOutputHelper.WriteLine("LRU " + string.Join(" ", lru.Keys));
+
+            lru.Count.Should().Be(0);
+
+            // verify queues are purged
+            lru.HotCount.Should().Be(0);
+            lru.WarmCount.Should().Be(0);
+            lru.ColdCount.Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenItemsAreDisposableTrimDisposesItems()
+        {
+            var lruOfDisposable = new ConcurrentLru<int, DisposableItem>(1, new EqualCapacityPartition(6), EqualityComparer<int>.Default);
+
+            var items = Enumerable.Range(1, 4).Select(i => new DisposableItem()).ToList();
+
+            for (int i = 0; i < 4; i++)
+            {
+                lruOfDisposable.AddOrUpdate(i, items[i]);
+            }
+
+            lruOfDisposable.Trim(2);
+
+            items[0].IsDisposed.Should().BeTrue();
+            items[1].IsDisposed.Should().BeTrue();
+            items[2].IsDisposed.Should().BeFalse();
+            items[3].IsDisposed.Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenItemsAreTrimmedAnEventIsFired()
+        {
+            var lruEvents = new ConcurrentLru<int, int>(1, capacity, EqualityComparer<int>.Default);
+            lruEvents.Events.Value.ItemRemoved += OnLruItemRemoved;
+
+            for (int i = 0; i < 6; i++)
+            {
+                lruEvents.GetOrAdd(i + 1, i => i + 1);
+            }
+
+            lruEvents.Trim(2);
+
+            removedItems.Count.Should().Be(2);
+
+            removedItems[0].Key.Should().Be(1);
+            removedItems[0].Value.Should().Be(2);
+            removedItems[0].Reason.Should().Be(ItemRemovedReason.Trimmed);
+
+            removedItems[1].Key.Should().Be(2);
+            removedItems[1].Value.Should().Be(3);
+            removedItems[1].Reason.Should().Be(ItemRemovedReason.Trimmed);
+        }
+
+
+        private void Warmup()
+        {
+            lru.GetOrAdd(-1, valueFactory.Create);
+            lru.GetOrAdd(-2, valueFactory.Create);
+            lru.GetOrAdd(-3, valueFactory.Create);
+            lru.GetOrAdd(-4, valueFactory.Create);
+            lru.GetOrAdd(-5, valueFactory.Create);
+            lru.GetOrAdd(-6, valueFactory.Create);
+            lru.GetOrAdd(-7, valueFactory.Create);
+            lru.GetOrAdd(-8, valueFactory.Create);
+            lru.GetOrAdd(-9, valueFactory.Create);
+        }
+    }
+
     public class ConcurrentLruIntegrityChecker<K, V, I, P, T>
         where I : LruItem<K, V>
         where P : struct, IItemPolicy<K, V, I>
@@ -1251,38 +1251,38 @@ public class ConcurrentLruIntegrityChecker<K, V, I, P, T>
         
         private readonly ConcurrentQueue<I> hotQueue;
         private readonly ConcurrentQueue<I> warmQueue;
-        private readonly ConcurrentQueue<I> coldQueue;
-
-        private static FieldInfo hotQueueField = typeof(ConcurrentLruCore<K, V, I, P, T>).GetField("hotQueue", BindingFlags.NonPublic | BindingFlags.Instance);
-        private static FieldInfo warmQueueField = typeof(ConcurrentLruCore<K, V, I, P, T>).GetField("warmQueue", BindingFlags.NonPublic | BindingFlags.Instance);
-        private static FieldInfo coldQueueField = typeof(ConcurrentLruCore<K, V, I, P, T>).GetField("coldQueue", BindingFlags.NonPublic | BindingFlags.Instance);
-
+        private readonly ConcurrentQueue<I> coldQueue;
+
+        private static FieldInfo hotQueueField = typeof(ConcurrentLruCore<K, V, I, P, T>).GetField("hotQueue", BindingFlags.NonPublic | BindingFlags.Instance);
+        private static FieldInfo warmQueueField = typeof(ConcurrentLruCore<K, V, I, P, T>).GetField("warmQueue", BindingFlags.NonPublic | BindingFlags.Instance);
+        private static FieldInfo coldQueueField = typeof(ConcurrentLruCore<K, V, I, P, T>).GetField("coldQueue", BindingFlags.NonPublic | BindingFlags.Instance);
+
         public ConcurrentLruIntegrityChecker(ConcurrentLruCore<K, V, I, P, T> cache)
         {
-            this.cache = cache;
-
-            // get queues via reflection
-            this.hotQueue = (ConcurrentQueue<I>)hotQueueField.GetValue(cache);
+            this.cache = cache;
+
+            // get queues via reflection
+            this.hotQueue = (ConcurrentQueue<I>)hotQueueField.GetValue(cache);
             this.warmQueue = (ConcurrentQueue<I>)warmQueueField.GetValue(cache);
-            this.coldQueue = (ConcurrentQueue<I>)coldQueueField.GetValue(cache);
-        }
-
+            this.coldQueue = (ConcurrentQueue<I>)coldQueueField.GetValue(cache);
+        }
+
         public void Validate()
         {
             // queue counters must be consistent with queues
-            this.hotQueue.Count.Should().Be(cache.HotCount, "hot queue has a corrupted count");
-            this.warmQueue.Count.Should().Be(cache.WarmCount, "warm queue has a corrupted count");
-            this.coldQueue.Count.Should().Be(cache.ColdCount, "cold queue has a corrupted count");
-
-            // cache contents must be consistent with queued items
-            ValidateQueue(cache, this.hotQueue, "hot");
-            ValidateQueue(cache, this.warmQueue, "warm");
-            ValidateQueue(cache, this.coldQueue, "cold");
-
-            // cache must be within capacity
-            cache.Count.Should().BeLessThanOrEqualTo(cache.Capacity + 1, "capacity out of valid range");
-        }
-
+            this.hotQueue.Count.Should().Be(cache.HotCount, "hot queue has a corrupted count");
+            this.warmQueue.Count.Should().Be(cache.WarmCount, "warm queue has a corrupted count");
+            this.coldQueue.Count.Should().Be(cache.ColdCount, "cold queue has a corrupted count");
+
+            // cache contents must be consistent with queued items
+            ValidateQueue(cache, this.hotQueue, "hot");
+            ValidateQueue(cache, this.warmQueue, "warm");
+            ValidateQueue(cache, this.coldQueue, "cold");
+
+            // cache must be within capacity
+            cache.Count.Should().BeLessThanOrEqualTo(cache.Capacity + 1, "capacity out of valid range");
+        }
+
         private void ValidateQueue(ConcurrentLruCore<K, V, I, P, T> cache, ConcurrentQueue<I> queue, string queueName)
         {
             foreach (var item in queue)
@@ -1298,12 +1298,12 @@ private void ValidateQueue(ConcurrentLruCore<K, V, I, P, T> cache, ConcurrentQue
                             .Any(i => i.Key.Equals(item.Key) && !i.WasRemoved)
                             .Should().BeTrue($"{queueName} removed item {item.Key} was not removed");
                     }
-                }
+                }
                 else
                 {
-                    cache.TryGet(item.Key, out var value).Should().BeTrue($"{queueName} item {item.Key} was not present");
-                }
-            }
-        }
-    }
-}
+                    cache.TryGet(item.Key, out var value).Should().BeTrue($"{queueName} item {item.Key} was not present");
+                }
+            }
+        }
+    }
+}
diff --git a/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs b/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs
index 4feb3ee0..713cefa6 100644
--- a/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs
@@ -1,191 +1,191 @@
-using System;
+using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace BitFaster.Caching.Atomic
-{
-    /// <summary>
-    /// A class that provides simple, lightweight exactly once initialization for values
-    /// stored in a cache.
-    /// </summary>
-    /// <typeparam name="K">The type of the key.</typeparam>
-    /// <typeparam name="V">The type of the value.</typeparam>
-    [DebuggerDisplay("IsValueCreated={IsValueCreated}, Value={ValueIfCreated}")]
-    public sealed class AsyncAtomicFactory<K, V> : IEquatable<AsyncAtomicFactory<K, V>>
-    {
-        private Initializer initializer;
-
-        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private V value;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="AsyncAtomicFactory{K, V}"/> class.
-        /// </summary>
-        public AsyncAtomicFactory()
-        {
-            initializer = new Initializer();
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="AsyncAtomicFactory{K, V}"/> class with the
-        /// specified value.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        public AsyncAtomicFactory(V value)
-        {
-            this.value = value;
-        }
-
-        /// <summary>
-        /// Gets the value. If <see cref="IsValueCreated"/> is false, calling <see cref="GetValueAsync"/> will force initialization via the <paramref name="valueFactory"/> parameter.
-        /// </summary>
-        /// <param name="key">The key associated with the value.</param>
-        /// <param name="valueFactory">The value factory to use to create the value when it is not initialized.</param>
-        /// <returns>The value.</returns>
-        public async ValueTask<V> GetValueAsync(K key, Func<K, Task<V>> valueFactory)
-        {
-            if (initializer == null)
-            {
-                return value;
-            }
-
-            return await CreateValueAsync(key, new AsyncValueFactory<K, V>(valueFactory)).ConfigureAwait(false);
-        }
-
-        /// <summary>
-        /// Gets the value. If <see cref="IsValueCreated"/> is false, calling <see cref="GetValueAsync{TArg}"/> will force initialization via the <paramref name="valueFactory"/> parameter.
-        /// </summary>
-        /// <typeparam name="TArg">The type of the value factory argument.</typeparam>
-        /// <param name="key">The key associated with the value.</param>
-        /// <param name="valueFactory">The value factory to use to create the value when it is not initialized.</param>
-        /// <param name="factoryArgument">The value factory argument.</param>
-        /// <returns>The value.</returns>
-        public async ValueTask<V> GetValueAsync<TArg>(K key, Func<K, TArg, Task<V>> valueFactory, TArg factoryArgument)
-        {
-            if (initializer == null)
-            {
-                return value;
-            }
-
-            return await CreateValueAsync(key, new AsyncValueFactoryArg<K, TArg, V>(valueFactory, factoryArgument)).ConfigureAwait(false);
-        }
-
-        /// <summary>
-        /// Gets a value indicating whether the value has been initialized.
-        /// </summary>
-        public bool IsValueCreated => initializer == null;
-
-        /// <summary>
-        /// Gets the value if it has been initialized, else default.
-        /// </summary>
-        public V ValueIfCreated
-        {
-            get
-            {
-                if (!IsValueCreated)
-                {
-                    return default;
-                }
-
-                return value;
-            }
-        }
-
-        ///<inheritdoc/>
-        public override bool Equals(object obj)
-        {
-            return Equals(obj as AsyncAtomicFactory<K, V>);
-        }
-
-        ///<inheritdoc/>
-        public bool Equals(AsyncAtomicFactory<K, V> other)
-        {
-            if (other is null || !IsValueCreated || !other.IsValueCreated)
-            {
-                return false;
-            }
-
-            return EqualityComparer<V>.Default.Equals(ValueIfCreated, other.ValueIfCreated);
-        }
-
-        ///<inheritdoc/>
-        public override int GetHashCode()
-        {
-            if (!IsValueCreated)
-            {
-                return 0;
-            }
-
-            return ValueIfCreated.GetHashCode();
-        }
-
-        private async ValueTask<V> CreateValueAsync<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IAsyncValueFactory<K, V>
-        {
-            var init = Volatile.Read(ref initializer);
-
-            if (init != null)
-            {
-                value = await init.CreateValueAsync(key, valueFactory).ConfigureAwait(false);
-                Volatile.Write(ref initializer, null);
-            }
-
-            return value;
-        }
-
-        private class Initializer
-        {
-            private bool isInitialized;
-            private Task<V> valueTask;
-
-            public async ValueTask<V> CreateValueAsync<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IAsyncValueFactory<K, V>
-            {
-                var tcs = new TaskCompletionSource<V>(TaskCreationOptions.RunContinuationsAsynchronously);
-
-                var synchronizedTask = DoubleCheck(tcs.Task);
-
-                if (ReferenceEquals(synchronizedTask, tcs.Task))
-                {
-                    try
-                    {
-                        var value = await valueFactory.CreateAsync(key).ConfigureAwait(false);
-                        tcs.SetResult(value);
-
-                        return value;
-                    }
-                    catch (Exception ex)
-                    {
-                        Volatile.Write(ref isInitialized, false);
-                        tcs.SetException(ex);
-                        throw;
-                    }
-                }
-
-                return await synchronizedTask.ConfigureAwait(false);
-            }
-
-#pragma warning disable CA2002 // Do not lock on objects with weak identity
-            private Task<V> DoubleCheck(Task<V> value)
-            {
-                // Fast path
-                if (Volatile.Read(ref isInitialized))
-                {
-                    return valueTask;
-                }
-
-                lock (this)
-                {
-                    if (!isInitialized)
-                    {
-                        valueTask = value;
-                        isInitialized = true;
-                    }
-                }
-
-                return valueTask;
-            }
-#pragma warning restore CA2002 // Do not lock on objects with weak identity
-        }
-    }
-}
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching.Atomic
+{
+    /// <summary>
+    /// A class that provides simple, lightweight exactly once initialization for values
+    /// stored in a cache.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
+    [DebuggerDisplay("IsValueCreated={IsValueCreated}, Value={ValueIfCreated}")]
+    public sealed class AsyncAtomicFactory<K, V> : IEquatable<AsyncAtomicFactory<K, V>>
+    {
+        private Initializer initializer;
+
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        private V value;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AsyncAtomicFactory{K, V}"/> class.
+        /// </summary>
+        public AsyncAtomicFactory()
+        {
+            initializer = new Initializer();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AsyncAtomicFactory{K, V}"/> class with the
+        /// specified value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public AsyncAtomicFactory(V value)
+        {
+            this.value = value;
+        }
+
+        /// <summary>
+        /// Gets the value. If <see cref="IsValueCreated"/> is false, calling <see cref="GetValueAsync"/> will force initialization via the <paramref name="valueFactory"/> parameter.
+        /// </summary>
+        /// <param name="key">The key associated with the value.</param>
+        /// <param name="valueFactory">The value factory to use to create the value when it is not initialized.</param>
+        /// <returns>The value.</returns>
+        public async ValueTask<V> GetValueAsync(K key, Func<K, Task<V>> valueFactory)
+        {
+            if (initializer == null)
+            {
+                return value;
+            }
+
+            return await CreateValueAsync(key, new AsyncValueFactory<K, V>(valueFactory)).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Gets the value. If <see cref="IsValueCreated"/> is false, calling <see cref="GetValueAsync{TArg}"/> will force initialization via the <paramref name="valueFactory"/> parameter.
+        /// </summary>
+        /// <typeparam name="TArg">The type of the value factory argument.</typeparam>
+        /// <param name="key">The key associated with the value.</param>
+        /// <param name="valueFactory">The value factory to use to create the value when it is not initialized.</param>
+        /// <param name="factoryArgument">The value factory argument.</param>
+        /// <returns>The value.</returns>
+        public async ValueTask<V> GetValueAsync<TArg>(K key, Func<K, TArg, Task<V>> valueFactory, TArg factoryArgument)
+        {
+            if (initializer == null)
+            {
+                return value;
+            }
+
+            return await CreateValueAsync(key, new AsyncValueFactoryArg<K, TArg, V>(valueFactory, factoryArgument)).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the value has been initialized.
+        /// </summary>
+        public bool IsValueCreated => initializer == null;
+
+        /// <summary>
+        /// Gets the value if it has been initialized, else default.
+        /// </summary>
+        public V ValueIfCreated
+        {
+            get
+            {
+                if (!IsValueCreated)
+                {
+                    return default;
+                }
+
+                return value;
+            }
+        }
+
+        ///<inheritdoc/>
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as AsyncAtomicFactory<K, V>);
+        }
+
+        ///<inheritdoc/>
+        public bool Equals(AsyncAtomicFactory<K, V> other)
+        {
+            if (other is null || !IsValueCreated || !other.IsValueCreated)
+            {
+                return false;
+            }
+
+            return EqualityComparer<V>.Default.Equals(ValueIfCreated, other.ValueIfCreated);
+        }
+
+        ///<inheritdoc/>
+        public override int GetHashCode()
+        {
+            if (!IsValueCreated)
+            {
+                return 0;
+            }
+
+            return ValueIfCreated.GetHashCode();
+        }
+
+        private async ValueTask<V> CreateValueAsync<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IAsyncValueFactory<K, V>
+        {
+            var init = Volatile.Read(ref initializer);
+
+            if (init != null)
+            {
+                value = await init.CreateValueAsync(key, valueFactory).ConfigureAwait(false);
+                Volatile.Write(ref initializer, null);
+            }
+
+            return value;
+        }
+
+        private class Initializer
+        {
+            private bool isInitialized;
+            private Task<V> valueTask;
+
+            public async ValueTask<V> CreateValueAsync<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IAsyncValueFactory<K, V>
+            {
+                var tcs = new TaskCompletionSource<V>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+                var synchronizedTask = DoubleCheck(tcs.Task);
+
+                if (ReferenceEquals(synchronizedTask, tcs.Task))
+                {
+                    try
+                    {
+                        var value = await valueFactory.CreateAsync(key).ConfigureAwait(false);
+                        tcs.SetResult(value);
+
+                        return value;
+                    }
+                    catch (Exception ex)
+                    {
+                        Volatile.Write(ref isInitialized, false);
+                        tcs.SetException(ex);
+                        throw;
+                    }
+                }
+
+                return await synchronizedTask.ConfigureAwait(false);
+            }
+
+#pragma warning disable CA2002 // Do not lock on objects with weak identity
+            private Task<V> DoubleCheck(Task<V> value)
+            {
+                // Fast path
+                if (Volatile.Read(ref isInitialized))
+                {
+                    return valueTask;
+                }
+
+                lock (this)
+                {
+                    if (!isInitialized)
+                    {
+                        valueTask = value;
+                        isInitialized = true;
+                    }
+                }
+
+                return valueTask;
+            }
+#pragma warning restore CA2002 // Do not lock on objects with weak identity
+        }
+    }
+}
diff --git a/BitFaster.Caching/Atomic/AtomicFactory.cs b/BitFaster.Caching/Atomic/AtomicFactory.cs
index 0ca92318..2873dbe5 100644
--- a/BitFaster.Caching/Atomic/AtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactory.cs
@@ -1,108 +1,108 @@
-using System;
+using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.Threading;
-
-namespace BitFaster.Caching.Atomic
-{
-    /// <summary>
-    /// A class that provides simple, lightweight exactly once initialization for values
-    /// stored in a cache.
-    /// </summary>
-    /// <typeparam name="K">The type of the key.</typeparam>
-    /// <typeparam name="V">The type of the value.</typeparam>
-    [DebuggerDisplay("IsValueCreated={IsValueCreated}, Value={ValueIfCreated}")]
-    public sealed class AtomicFactory<K, V> : IEquatable<AtomicFactory<K, V>>
-    {
-        private Initializer initializer;
-
-        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private V value;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="AtomicFactory{K, V}"/> class.
-        /// </summary>
-        public AtomicFactory()
-        {
-            initializer = new Initializer();
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="AtomicFactory{K, V}"/> class with the
-        /// specified value.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        public AtomicFactory(V value)
-        {
-            this.value = value;
-        }
-
-        /// <summary>
-        /// Gets the value. If <see cref="IsValueCreated"/> is false, calling <see cref="GetValue"/> will force initialization via the <paramref name="valueFactory"/> parameter.
-        /// </summary>
-        /// <param name="key">The key associated with the value.</param>
-        /// <param name="valueFactory">The value factory to use to create the value when it is not initialized.</param>
-        /// <returns>The value.</returns>
-        public V GetValue(K key, Func<K, V> valueFactory)
-        {
-            if (initializer == null)
-            {
-                return value;
-            }
-
-            return CreateValue(key, new ValueFactory<K, V>(valueFactory));
-        }
-
-        /// <summary>
-        /// Gets the value. If <see cref="IsValueCreated"/> is false, calling <see cref="GetValue{TArg}"/> will force initialization via the <paramref name="valueFactory"/> parameter.
-        /// </summary>
-        /// <typeparam name="TArg">The type of the value factory argument.</typeparam>
-        /// <param name="key">The key associated with the value.</param>
-        /// <param name="valueFactory">The value factory to use to create the value when it is not initialized.</param>
-        /// <param name="factoryArgument">The value factory argument.</param>
-        /// <returns>The value.</returns>
-        public V GetValue<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument)
-        {
-            if (initializer == null)
-            {
-                return value;
-            }
-
-            return CreateValue(key, new ValueFactoryArg<K, TArg, V>(valueFactory, factoryArgument));
-        }
-
-        /// <summary>
-        /// Gets a value indicating whether the value has been initialized.
-        /// </summary>
-        public bool IsValueCreated => Volatile.Read(ref initializer) == null;
-
-        /// <summary>
-        /// Gets the value if it has been initialized, else default.
-        /// </summary>
-        public V ValueIfCreated
-        {
-            get
-            {
-                if (!IsValueCreated)
-                {
-                    return default;
-                }
-
-                return value;
-            }
-        }
-
-        private V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, V>
-        {
-            var init = Volatile.Read(ref initializer);
-
-            if (init != null)
-            {
-                value = init.CreateValue(key, valueFactory);
-                Volatile.Write(ref initializer, null); // volatile write must occur after setting value
-            }
-
-            return value;
+using System.Diagnostics;
+using System.Threading;
+
+namespace BitFaster.Caching.Atomic
+{
+    /// <summary>
+    /// A class that provides simple, lightweight exactly once initialization for values
+    /// stored in a cache.
+    /// </summary>
+    /// <typeparam name="K">The type of the key.</typeparam>
+    /// <typeparam name="V">The type of the value.</typeparam>
+    [DebuggerDisplay("IsValueCreated={IsValueCreated}, Value={ValueIfCreated}")]
+    public sealed class AtomicFactory<K, V> : IEquatable<AtomicFactory<K, V>>
+    {
+        private Initializer initializer;
+
+        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
+        private V value;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AtomicFactory{K, V}"/> class.
+        /// </summary>
+        public AtomicFactory()
+        {
+            initializer = new Initializer();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AtomicFactory{K, V}"/> class with the
+        /// specified value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public AtomicFactory(V value)
+        {
+            this.value = value;
+        }
+
+        /// <summary>
+        /// Gets the value. If <see cref="IsValueCreated"/> is false, calling <see cref="GetValue"/> will force initialization via the <paramref name="valueFactory"/> parameter.
+        /// </summary>
+        /// <param name="key">The key associated with the value.</param>
+        /// <param name="valueFactory">The value factory to use to create the value when it is not initialized.</param>
+        /// <returns>The value.</returns>
+        public V GetValue(K key, Func<K, V> valueFactory)
+        {
+            if (initializer == null)
+            {
+                return value;
+            }
+
+            return CreateValue(key, new ValueFactory<K, V>(valueFactory));
+        }
+
+        /// <summary>
+        /// Gets the value. If <see cref="IsValueCreated"/> is false, calling <see cref="GetValue{TArg}"/> will force initialization via the <paramref name="valueFactory"/> parameter.
+        /// </summary>
+        /// <typeparam name="TArg">The type of the value factory argument.</typeparam>
+        /// <param name="key">The key associated with the value.</param>
+        /// <param name="valueFactory">The value factory to use to create the value when it is not initialized.</param>
+        /// <param name="factoryArgument">The value factory argument.</param>
+        /// <returns>The value.</returns>
+        public V GetValue<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument)
+        {
+            if (initializer == null)
+            {
+                return value;
+            }
+
+            return CreateValue(key, new ValueFactoryArg<K, TArg, V>(valueFactory, factoryArgument));
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the value has been initialized.
+        /// </summary>
+        public bool IsValueCreated => Volatile.Read(ref initializer) == null;
+
+        /// <summary>
+        /// Gets the value if it has been initialized, else default.
+        /// </summary>
+        public V ValueIfCreated
+        {
+            get
+            {
+                if (!IsValueCreated)
+                {
+                    return default;
+                }
+
+                return value;
+            }
+        }
+
+        private V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, V>
+        {
+            var init = Volatile.Read(ref initializer);
+
+            if (init != null)
+            {
+                value = init.CreateValue(key, valueFactory);
+                Volatile.Write(ref initializer, null); // volatile write must occur after setting value
+            }
+
+            return value;
         }
 
         ///<inheritdoc/>
@@ -134,26 +134,26 @@ public override int GetHashCode()
         }
 
 #pragma warning disable CA2002 // Do not lock on objects with weak identity
-        private class Initializer
-        {
-            private bool isInitialized;
-            private V value;
-
-            public V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, V>
-            {
-                lock (this)
-                {
-                    if (isInitialized)
-                    {
-                        return value;
-                    }
-
-                    value = valueFactory.Create(key);
-                    isInitialized = true;
-                    return value;
-                }
-            }
+        private class Initializer
+        {
+            private bool isInitialized;
+            private V value;
+
+            public V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, V>
+            {
+                lock (this)
+                {
+                    if (isInitialized)
+                    {
+                        return value;
+                    }
+
+                    value = valueFactory.Create(key);
+                    isInitialized = true;
+                    return value;
+                }
+            }
         }
 #pragma warning restore CA2002 // Do not lock on objects with weak identity
-    }
-}
+    }
+}
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
index 5d3e94ba..3ac0ad0a 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
@@ -1,212 +1,212 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Threading.Tasks;
-
-namespace BitFaster.Caching.Atomic
-{
-    /// <summary>
-    /// A cache decorator for working with  <see cref="AsyncAtomicFactory{K, V}"/> wrapped values, giving exactly once initialization.
-    /// </summary>
-    /// <typeparam name="K">The type of keys in the cache.</typeparam>
-    /// <typeparam name="V">The type of values in the cache.</typeparam>
-    [DebuggerTypeProxy(typeof(AtomicFactoryAsyncCache<,>.AsyncCacheDebugView))]
-    [DebuggerDisplay("Count = {Count}")]
-    public sealed class AtomicFactoryAsyncCache<K, V> : IAsyncCache<K, V>
-    {
-        private readonly ICache<K, AsyncAtomicFactory<K, V>> cache;
-        private readonly Optional<ICacheEvents<K, V>> events;
-
-        /// <summary>
-        /// Initializes a new instance of the AtomicFactoryAsyncCache class with the specified inner cache.
-        /// </summary>
-        /// <param name="cache">The decorated cache.</param>
-        public AtomicFactoryAsyncCache(ICache<K, AsyncAtomicFactory<K, V>> cache)
-        {
-            if (cache == null)
-                Throw.ArgNull(ExceptionArgument.cache);
-
-            this.cache = cache;
-
-            if (cache.Events.HasValue)
-            {
-                this.events = new Optional<ICacheEvents<K, V>>(new EventProxy(cache.Events.Value));
-            }
-            else
-            {
-                this.events = Optional<ICacheEvents<K, V>>.None();
-            }
-        }
-
-        ///<inheritdoc/>
-        public int Count => AtomicEx.EnumerateCount(this.GetEnumerator());
-
-        ///<inheritdoc/>
-        public Optional<ICacheMetrics> Metrics => cache.Metrics;
-
-        ///<inheritdoc/>
-        public Optional<ICacheEvents<K, V>> Events => this.events;
-
-        ///<inheritdoc/>
-        public ICollection<K> Keys => AtomicEx.FilterKeys<K, AsyncAtomicFactory<K, V>>(this.cache, v => v.IsValueCreated);
-
-        ///<inheritdoc/>
-        public CachePolicy Policy => this.cache.Policy;
-
-        ///<inheritdoc/>
-        public void AddOrUpdate(K key, V value)
-        {
-            cache.AddOrUpdate(key, new AsyncAtomicFactory<K, V>(value));
-        }
-
-        ///<inheritdoc/>
-        public void Clear()
-        {
-            cache.Clear();
-        }
-
-        ///<inheritdoc/>
-        public ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
-        {
-            var synchronized = cache.GetOrAdd(key, _ => new AsyncAtomicFactory<K, V>());
-            return synchronized.GetValueAsync(key, valueFactory);
-        }
-
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
-        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
-        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
-        public ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valueFactory, TArg factoryArgument)
-        {
-            var synchronized = cache.GetOrAdd(key, _ => new AsyncAtomicFactory<K, V>());
-            return synchronized.GetValueAsync(key, valueFactory, factoryArgument);
-        }
-
-        ///<inheritdoc/>
-        public bool TryGet(K key, out V value)
-        {
-            AsyncAtomicFactory<K, V> output;
-            var ret = cache.TryGet(key, out output);
-
-            if (ret && output.IsValueCreated)
-            {
-                value = output.ValueIfCreated;
-                return true;
-            }
-
-            value = default;
-            return false;
-        }
-
-        ///<inheritdoc/>
-        public bool TryRemove(K key)
-        {
-            return cache.TryRemove(key);
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching.Atomic
+{
+    /// <summary>
+    /// A cache decorator for working with  <see cref="AsyncAtomicFactory{K, V}"/> wrapped values, giving exactly once initialization.
+    /// </summary>
+    /// <typeparam name="K">The type of keys in the cache.</typeparam>
+    /// <typeparam name="V">The type of values in the cache.</typeparam>
+    [DebuggerTypeProxy(typeof(AtomicFactoryAsyncCache<,>.AsyncCacheDebugView))]
+    [DebuggerDisplay("Count = {Count}")]
+    public sealed class AtomicFactoryAsyncCache<K, V> : IAsyncCache<K, V>
+    {
+        private readonly ICache<K, AsyncAtomicFactory<K, V>> cache;
+        private readonly Optional<ICacheEvents<K, V>> events;
+
+        /// <summary>
+        /// Initializes a new instance of the AtomicFactoryAsyncCache class with the specified inner cache.
+        /// </summary>
+        /// <param name="cache">The decorated cache.</param>
+        public AtomicFactoryAsyncCache(ICache<K, AsyncAtomicFactory<K, V>> cache)
+        {
+            if (cache == null)
+                Throw.ArgNull(ExceptionArgument.cache);
+
+            this.cache = cache;
+
+            if (cache.Events.HasValue)
+            {
+                this.events = new Optional<ICacheEvents<K, V>>(new EventProxy(cache.Events.Value));
+            }
+            else
+            {
+                this.events = Optional<ICacheEvents<K, V>>.None();
+            }
+        }
+
+        ///<inheritdoc/>
+        public int Count => AtomicEx.EnumerateCount(this.GetEnumerator());
+
+        ///<inheritdoc/>
+        public Optional<ICacheMetrics> Metrics => cache.Metrics;
+
+        ///<inheritdoc/>
+        public Optional<ICacheEvents<K, V>> Events => this.events;
+
+        ///<inheritdoc/>
+        public ICollection<K> Keys => AtomicEx.FilterKeys<K, AsyncAtomicFactory<K, V>>(this.cache, v => v.IsValueCreated);
+
+        ///<inheritdoc/>
+        public CachePolicy Policy => this.cache.Policy;
+
+        ///<inheritdoc/>
+        public void AddOrUpdate(K key, V value)
+        {
+            cache.AddOrUpdate(key, new AsyncAtomicFactory<K, V>(value));
+        }
+
+        ///<inheritdoc/>
+        public void Clear()
+        {
+            cache.Clear();
+        }
+
+        ///<inheritdoc/>
+        public ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
+        {
+            var synchronized = cache.GetOrAdd(key, _ => new AsyncAtomicFactory<K, V>());
+            return synchronized.GetValueAsync(key, valueFactory);
+        }
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
+        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
+        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
+        public ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valueFactory, TArg factoryArgument)
+        {
+            var synchronized = cache.GetOrAdd(key, _ => new AsyncAtomicFactory<K, V>());
+            return synchronized.GetValueAsync(key, valueFactory, factoryArgument);
+        }
+
+        ///<inheritdoc/>
+        public bool TryGet(K key, out V value)
+        {
+            AsyncAtomicFactory<K, V> output;
+            var ret = cache.TryGet(key, out output);
+
+            if (ret && output.IsValueCreated)
+            {
+                value = output.ValueIfCreated;
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+
+        ///<inheritdoc/>
+        public bool TryRemove(K key)
+        {
+            return cache.TryRemove(key);
         }
 
         // backcompat: remove conditional compile
-#if NETCOREAPP3_0_OR_GREATER
-        ///<inheritdoc/>
-        ///<remarks>
-        ///If the value factory is still executing, returns false.
-        ///</remarks>
-        public bool TryRemove(KeyValuePair<K, V> item)
-        {
-            var kvp = new KeyValuePair<K, AsyncAtomicFactory<K, V>>(item.Key, new AsyncAtomicFactory<K, V>(item.Value));
-            return cache.TryRemove(kvp);
-        }
-
-        ///<inheritdoc/>
-        /// <remarks>
-        /// If the value factory is still executing, the default value will be returned.
-        /// </remarks>
-        public bool TryRemove(K key, out V value)
-        {
-            if (cache.TryRemove(key, out var atomic))
-            {
-                value = atomic.ValueIfCreated;
-                return true;
-            }
-
-            value = default;
-            return false;
-        }
-#endif
-
-        ///<inheritdoc/>
-        public bool TryUpdate(K key, V value)
-        {
-            return cache.TryUpdate(key, new AsyncAtomicFactory<K, V>(value));
-        }
-
-        ///<inheritdoc/>
-        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
-        {
-            foreach (var kvp in this.cache)
-            {
-                if (kvp.Value.IsValueCreated)
-                { 
-                    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)
-                : base(inner)
-            {
-            }
-
-            protected override ItemRemovedEventArgs<K, V> TranslateOnRemoved(ItemRemovedEventArgs<K, AsyncAtomicFactory<K, V>> inner)
-            {
-                return new ItemRemovedEventArgs<K, V>(inner.Key, inner.Value.ValueIfCreated, inner.Reason);
-            }
-
-            protected override ItemUpdatedEventArgs<K, V> TranslateOnUpdated(ItemUpdatedEventArgs<K, AsyncAtomicFactory<K, V>> inner)
-            {
-                return new ItemUpdatedEventArgs<K, V>(inner.Key, inner.OldValue.ValueIfCreated, inner.NewValue.ValueIfCreated);
-            }
-        }
-
-        [ExcludeFromCodeCoverage]
-        internal class AsyncCacheDebugView
-        {
-            private readonly IAsyncCache<K, V> cache;
-
-            public AsyncCacheDebugView(IAsyncCache<K, V> cache)
-            {
-                this.cache = cache;
-            }
-
-            public KeyValuePair<K, V>[] Items
-            {
-                get
-                {
-                    var items = new KeyValuePair<K, V>[cache.Count];
-
-                    int index = 0;
-                    foreach (var kvp in cache)
-                    {
-                        items[index++] = kvp;
-                    }
-                    return items;
-                }
-            }
-
-            public ICacheMetrics Metrics => cache.Metrics.Value;
-        }
-    }
-}
+#if NETCOREAPP3_0_OR_GREATER
+        ///<inheritdoc/>
+        ///<remarks>
+        ///If the value factory is still executing, returns false.
+        ///</remarks>
+        public bool TryRemove(KeyValuePair<K, V> item)
+        {
+            var kvp = new KeyValuePair<K, AsyncAtomicFactory<K, V>>(item.Key, new AsyncAtomicFactory<K, V>(item.Value));
+            return cache.TryRemove(kvp);
+        }
+
+        ///<inheritdoc/>
+        /// <remarks>
+        /// If the value factory is still executing, the default value will be returned.
+        /// </remarks>
+        public bool TryRemove(K key, out V value)
+        {
+            if (cache.TryRemove(key, out var atomic))
+            {
+                value = atomic.ValueIfCreated;
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+#endif
+
+        ///<inheritdoc/>
+        public bool TryUpdate(K key, V value)
+        {
+            return cache.TryUpdate(key, new AsyncAtomicFactory<K, V>(value));
+        }
+
+        ///<inheritdoc/>
+        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
+        {
+            foreach (var kvp in this.cache)
+            {
+                if (kvp.Value.IsValueCreated)
+                { 
+                    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)
+                : base(inner)
+            {
+            }
+
+            protected override ItemRemovedEventArgs<K, V> TranslateOnRemoved(ItemRemovedEventArgs<K, AsyncAtomicFactory<K, V>> inner)
+            {
+                return new ItemRemovedEventArgs<K, V>(inner.Key, inner.Value.ValueIfCreated, inner.Reason);
+            }
+
+            protected override ItemUpdatedEventArgs<K, V> TranslateOnUpdated(ItemUpdatedEventArgs<K, AsyncAtomicFactory<K, V>> inner)
+            {
+                return new ItemUpdatedEventArgs<K, V>(inner.Key, inner.OldValue.ValueIfCreated, inner.NewValue.ValueIfCreated);
+            }
+        }
+
+        [ExcludeFromCodeCoverage]
+        internal class AsyncCacheDebugView
+        {
+            private readonly IAsyncCache<K, V> cache;
+
+            public AsyncCacheDebugView(IAsyncCache<K, V> cache)
+            {
+                this.cache = cache;
+            }
+
+            public KeyValuePair<K, V>[] Items
+            {
+                get
+                {
+                    var items = new KeyValuePair<K, V>[cache.Count];
+
+                    int index = 0;
+                    foreach (var kvp in cache)
+                    {
+                        items[index++] = kvp;
+                    }
+                    return items;
+                }
+            }
+
+            public ICacheMetrics Metrics => cache.Metrics.Value;
+        }
+    }
+}
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
index 0433b682..8269368a 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
@@ -1,107 +1,107 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-
-namespace BitFaster.Caching.Atomic
-{
-    /// <summary>
-    /// A cache decorator for working with  <see cref="AtomicFactory{K, V}"/> wrapped values, giving exactly once initialization.
-    /// </summary>
-    /// <typeparam name="K">The type of keys in the cache.</typeparam>
-    /// <typeparam name="V">The type of values in the cache.</typeparam>
-    [DebuggerTypeProxy(typeof(CacheDebugView<,>))]
-    [DebuggerDisplay("Count = {Count}")]
-    public sealed class AtomicFactoryCache<K, V> : ICache<K, V>
-    {
-        private readonly ICache<K, AtomicFactory<K, V>> cache;
-        private readonly Optional<ICacheEvents<K, V>> events;
-
-        /// <summary>
-        /// Initializes a new instance of the ScopedCache class with the specified inner cache.
-        /// </summary>
-        /// <param name="cache">The decorated cache.</param>
-        public AtomicFactoryCache(ICache<K, AtomicFactory<K, V>> cache)
-        {
-            if (cache == null)
-                Throw.ArgNull(ExceptionArgument.cache);
-
-            this.cache = cache;
-
-            if (cache.Events.HasValue)
-            {
-                this.events = new Optional<ICacheEvents<K, V>>(new EventProxy(cache.Events.Value));
-            }
-            else
-            {
-                this.events = Optional<ICacheEvents<K, V>>.None();
-            }
-        }
-
-        ///<inheritdoc/>
-        public int Count => AtomicEx.EnumerateCount(this.GetEnumerator());
-
-        ///<inheritdoc/>
-        public Optional<ICacheMetrics> Metrics => this.cache.Metrics;
-
-        ///<inheritdoc/>
-        public Optional<ICacheEvents<K, V>> Events => this.events;
-
-        ///<inheritdoc/>
-        public ICollection<K> Keys => AtomicEx.FilterKeys<K, AtomicFactory<K, V>>(this.cache, v => v.IsValueCreated);
-
-        ///<inheritdoc/>
-        public CachePolicy Policy => this.cache.Policy;
-
-        ///<inheritdoc/>
-        public void AddOrUpdate(K key, V value)
-        {
-            this.cache.AddOrUpdate(key, new AtomicFactory<K, V>(value));
-        }
-
-        ///<inheritdoc/>
-        public void Clear()
-        {
-            this.cache.Clear();
-        }
-
-        ///<inheritdoc/>
-        public V GetOrAdd(K key, Func<K, V> valueFactory)
-        {
-            var atomicFactory = cache.GetOrAdd(key, _ => new AtomicFactory<K, V>());
-            return atomicFactory.GetValue(key, valueFactory);
-        }
-
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
-        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
-        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
-        /// in the cache, or the new value if the key was not in the cache.</returns>
-        public V GetOrAdd<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument)
-        {
-            var atomicFactory = cache.GetOrAdd(key, _ => new AtomicFactory<K, V>());
-            return atomicFactory.GetValue(key, valueFactory, factoryArgument);
-        }
-
-        ///<inheritdoc/>
-        public bool TryGet(K key, out V value)
-        {
-            AtomicFactory<K, V> output;
-            var ret = cache.TryGet(key, out output);
-
-            if (ret && output.IsValueCreated)
-            {
-                value = output.ValueIfCreated;
-                return true;
-            }
-
-            value = default;
-            return false;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace BitFaster.Caching.Atomic
+{
+    /// <summary>
+    /// A cache decorator for working with  <see cref="AtomicFactory{K, V}"/> wrapped values, giving exactly once initialization.
+    /// </summary>
+    /// <typeparam name="K">The type of keys in the cache.</typeparam>
+    /// <typeparam name="V">The type of values in the cache.</typeparam>
+    [DebuggerTypeProxy(typeof(CacheDebugView<,>))]
+    [DebuggerDisplay("Count = {Count}")]
+    public sealed class AtomicFactoryCache<K, V> : ICache<K, V>
+    {
+        private readonly ICache<K, AtomicFactory<K, V>> cache;
+        private readonly Optional<ICacheEvents<K, V>> events;
+
+        /// <summary>
+        /// Initializes a new instance of the ScopedCache class with the specified inner cache.
+        /// </summary>
+        /// <param name="cache">The decorated cache.</param>
+        public AtomicFactoryCache(ICache<K, AtomicFactory<K, V>> cache)
+        {
+            if (cache == null)
+                Throw.ArgNull(ExceptionArgument.cache);
+
+            this.cache = cache;
+
+            if (cache.Events.HasValue)
+            {
+                this.events = new Optional<ICacheEvents<K, V>>(new EventProxy(cache.Events.Value));
+            }
+            else
+            {
+                this.events = Optional<ICacheEvents<K, V>>.None();
+            }
+        }
+
+        ///<inheritdoc/>
+        public int Count => AtomicEx.EnumerateCount(this.GetEnumerator());
+
+        ///<inheritdoc/>
+        public Optional<ICacheMetrics> Metrics => this.cache.Metrics;
+
+        ///<inheritdoc/>
+        public Optional<ICacheEvents<K, V>> Events => this.events;
+
+        ///<inheritdoc/>
+        public ICollection<K> Keys => AtomicEx.FilterKeys<K, AtomicFactory<K, V>>(this.cache, v => v.IsValueCreated);
+
+        ///<inheritdoc/>
+        public CachePolicy Policy => this.cache.Policy;
+
+        ///<inheritdoc/>
+        public void AddOrUpdate(K key, V value)
+        {
+            this.cache.AddOrUpdate(key, new AtomicFactory<K, V>(value));
+        }
+
+        ///<inheritdoc/>
+        public void Clear()
+        {
+            this.cache.Clear();
+        }
+
+        ///<inheritdoc/>
+        public V GetOrAdd(K key, Func<K, V> valueFactory)
+        {
+            var atomicFactory = cache.GetOrAdd(key, _ => new AtomicFactory<K, V>());
+            return atomicFactory.GetValue(key, valueFactory);
+        }
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
+        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
+        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
+        /// in the cache, or the new value if the key was not in the cache.</returns>
+        public V GetOrAdd<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument)
+        {
+            var atomicFactory = cache.GetOrAdd(key, _ => new AtomicFactory<K, V>());
+            return atomicFactory.GetValue(key, valueFactory, factoryArgument);
+        }
+
+        ///<inheritdoc/>
+        public bool TryGet(K key, out V value)
+        {
+            AtomicFactory<K, V> output;
+            var ret = cache.TryGet(key, out output);
+
+            if (ret && output.IsValueCreated)
+            {
+                value = output.ValueIfCreated;
+                return true;
+            }
+
+            value = default;
+            return false;
         }
 
         // backcompat: remove conditional compile
@@ -110,74 +110,74 @@ public bool TryGet(K key, out V value)
         ///<remarks>
         ///If the value factory is still executing, returns false.
         ///</remarks>
-        public bool TryRemove(KeyValuePair<K, V> item)
-        {
-            var kvp = new KeyValuePair<K, AtomicFactory<K, V>>(item.Key, new AtomicFactory<K, V>(item.Value));
-            return cache.TryRemove(kvp);
-        }
-
-        ///<inheritdoc/>
-        /// <remarks>
-        /// If the value factory is still executing, the default value will be returned.
-        /// </remarks>
-        public bool TryRemove(K key, out V value)
-        {
+        public bool TryRemove(KeyValuePair<K, V> item)
+        {
+            var kvp = new KeyValuePair<K, AtomicFactory<K, V>>(item.Key, new AtomicFactory<K, V>(item.Value));
+            return cache.TryRemove(kvp);
+        }
+
+        ///<inheritdoc/>
+        /// <remarks>
+        /// If the value factory is still executing, the default value will be returned.
+        /// </remarks>
+        public bool TryRemove(K key, out V value)
+        {
             if (cache.TryRemove(key, out var atomic))
             {
                 value = atomic.ValueIfCreated;
-                return true;
-            }
-
-            value = default;
-            return false;
-        }
-#endif
-
-        ///<inheritdoc/>
-        public bool TryRemove(K key)
-        {
-            return cache.TryRemove(key);
-        }
-
-        ///<inheritdoc/>
-        public bool TryUpdate(K key, V value)
-        {
-            return cache.TryUpdate(key, new AtomicFactory<K, V>(value));
-        }
-
-        ///<inheritdoc/>
-        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
-        {
-            foreach (var kvp in this.cache)
-            {
-                if (kvp.Value.IsValueCreated)
-                {
-                    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)
-                : base(inner)
-            {
-            }
-
-            protected override ItemRemovedEventArgs<K, V> TranslateOnRemoved(ItemRemovedEventArgs<K, AtomicFactory<K, V>> inner)
-            {
-                return new ItemRemovedEventArgs<K, V>(inner.Key, inner.Value.ValueIfCreated, inner.Reason);
-            }
-
-            protected override ItemUpdatedEventArgs<K, V> TranslateOnUpdated(ItemUpdatedEventArgs<K, AtomicFactory<K, V>> inner)
-            {
-                return new ItemUpdatedEventArgs<K, V>(inner.Key, inner.OldValue.ValueIfCreated, inner.NewValue.ValueIfCreated);
-            }
-        }
-    }
-}
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+#endif
+
+        ///<inheritdoc/>
+        public bool TryRemove(K key)
+        {
+            return cache.TryRemove(key);
+        }
+
+        ///<inheritdoc/>
+        public bool TryUpdate(K key, V value)
+        {
+            return cache.TryUpdate(key, new AtomicFactory<K, V>(value));
+        }
+
+        ///<inheritdoc/>
+        public IEnumerator<KeyValuePair<K, V>> GetEnumerator()
+        {
+            foreach (var kvp in this.cache)
+            {
+                if (kvp.Value.IsValueCreated)
+                {
+                    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)
+                : base(inner)
+            {
+            }
+
+            protected override ItemRemovedEventArgs<K, V> TranslateOnRemoved(ItemRemovedEventArgs<K, AtomicFactory<K, V>> inner)
+            {
+                return new ItemRemovedEventArgs<K, V>(inner.Key, inner.Value.ValueIfCreated, inner.Reason);
+            }
+
+            protected override ItemUpdatedEventArgs<K, V> TranslateOnUpdated(ItemUpdatedEventArgs<K, AtomicFactory<K, V>> inner)
+            {
+                return new ItemUpdatedEventArgs<K, V>(inner.Key, inner.OldValue.ValueIfCreated, inner.NewValue.ValueIfCreated);
+            }
+        }
+    }
+}
diff --git a/BitFaster.Caching/Atomic/ConcurrentDictionaryExtensions.cs b/BitFaster.Caching/Atomic/ConcurrentDictionaryExtensions.cs
index 333b8339..b8f3420f 100644
--- a/BitFaster.Caching/Atomic/ConcurrentDictionaryExtensions.cs
+++ b/BitFaster.Caching/Atomic/ConcurrentDictionaryExtensions.cs
@@ -1,27 +1,27 @@
-using System;
-using System.Collections.Concurrent;
+using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 
-namespace BitFaster.Caching.Atomic
-{
+namespace BitFaster.Caching.Atomic
+{
     /// <summary>
     /// Convenience methods for using AtomicFactory with ConcurrentDictionary. 
-    /// </summary>
-    public static class ConcurrentDictionaryExtensions
-    {
+    /// </summary>
+    public static class ConcurrentDictionaryExtensions
+    {
         /// <summary>
         /// Adds a key/value pair to the ConcurrentDictionary if the key does not already exist. Returns the new value, or the existing value if the key already exists.
         /// </summary>
         /// <param name="dictionary">The ConcurrentDictionary to use.</param>
         /// <param name="key">The key of the element to add.</param>
         /// <param name="valueFactory">The function used to generate a value for the key.</param>
-        /// <returns>The value for the key. This will be either the existing value for the key if the key is already in the dictionary, or the new value if the key was not in the dictionary.</returns>
-        public static V GetOrAdd<K, V>(this ConcurrentDictionary<K, AtomicFactory<K, V>> dictionary, K key, Func<K, V> valueFactory)
-        {
-            var atomicFactory = dictionary.GetOrAdd(key, _ => new AtomicFactory<K, V>());
-            return atomicFactory.GetValue(key, valueFactory);
-        }
-
+        /// <returns>The value for the key. This will be either the existing value for the key if the key is already in the dictionary, or the new value if the key was not in the dictionary.</returns>
+        public static V GetOrAdd<K, V>(this ConcurrentDictionary<K, AtomicFactory<K, V>> dictionary, K key, Func<K, V> valueFactory)
+        {
+            var atomicFactory = dictionary.GetOrAdd(key, _ => new AtomicFactory<K, V>());
+            return atomicFactory.GetValue(key, valueFactory);
+        }
+
         /// <summary>
         /// Adds a key/value pair to the ConcurrentDictionary by using the specified function and an argument if the key does not already exist, or returns the existing value if the key exists.
         /// </summary>
@@ -29,33 +29,33 @@ public static V GetOrAdd<K, V>(this ConcurrentDictionary<K, AtomicFactory<K, V>>
         /// <param name="key">The key of the element to add.</param>
         /// <param name="valueFactory">The function used to generate a value for the key.</param>
         /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
-        /// <returns>The value for the key. This will be either the existing value for the key if the key is already in the dictionary, or the new value if the key was not in the dictionary.</returns>
-        public static V GetOrAdd<K, V, TArg>(this ConcurrentDictionary<K, AtomicFactory<K, V>> dictionary, K key, Func<K, TArg, V> valueFactory, TArg factoryArgument)
-        {
-            var atomicFactory = dictionary.GetOrAdd(key, _ => new AtomicFactory<K, V>());
-            return atomicFactory.GetValue(key, valueFactory, factoryArgument);
-        }
-
+        /// <returns>The value for the key. This will be either the existing value for the key if the key is already in the dictionary, or the new value if the key was not in the dictionary.</returns>
+        public static V GetOrAdd<K, V, TArg>(this ConcurrentDictionary<K, AtomicFactory<K, V>> dictionary, K key, Func<K, TArg, V> valueFactory, TArg factoryArgument)
+        {
+            var atomicFactory = dictionary.GetOrAdd(key, _ => new AtomicFactory<K, V>());
+            return atomicFactory.GetValue(key, valueFactory, factoryArgument);
+        }
+
         /// <summary>
         /// Attempts to get the value associated with the specified key from the ConcurrentDictionary.
         /// </summary>
         /// <param name="dictionary">The ConcurrentDictionary to use.</param>
         /// <param name="key">The key of the value to get.</param>
         /// <param name="value">When this method returns, contains the object from the ConcurrentDictionary that has the specified key, or the default value of the type if the operation failed.</param>
-        /// <returns>true if the key was found in the ConcurrentDictionary; otherwise, false.</returns>
-        public static bool TryGetValue<K, V>(this ConcurrentDictionary<K, AtomicFactory<K, V>> dictionary, K key, out V value)
-        {
-            AtomicFactory<K, V> output;
-            var ret = dictionary.TryGetValue(key, out output);
-
-            if (ret && output.IsValueCreated)
-            {
-                value = output.ValueIfCreated;
-                return true;
-            }
-
-            value = default;
-            return false;
+        /// <returns>true if the key was found in the ConcurrentDictionary; otherwise, false.</returns>
+        public static bool TryGetValue<K, V>(this ConcurrentDictionary<K, AtomicFactory<K, V>> dictionary, K key, out V value)
+        {
+            AtomicFactory<K, V> output;
+            var ret = dictionary.TryGetValue(key, out output);
+
+            if (ret && output.IsValueCreated)
+            {
+                value = output.ValueIfCreated;
+                return true;
+            }
+
+            value = default;
+            return false;
         }
 
         /// <summary>
@@ -64,15 +64,15 @@ public static bool TryGetValue<K, V>(this ConcurrentDictionary<K, AtomicFactory<
         /// <param name="dictionary">The ConcurrentDictionary to use.</param>
         /// <param name="item">The KeyValuePair representing the key and value to remove.</param>
         /// <returns>true if the object was removed successfully; otherwise, false.</returns>
-        public static bool TryRemove<K, V>(this ConcurrentDictionary<K, AtomicFactory<K, V>> dictionary, KeyValuePair<K, V> item)
-        {
+        public static bool TryRemove<K, V>(this ConcurrentDictionary<K, AtomicFactory<K, V>> dictionary, KeyValuePair<K, V> item)
+        {
             var kvp = new KeyValuePair<K, AtomicFactory<K, V>>(item.Key, new AtomicFactory<K, V>(item.Value));
 #if NET6_0_OR_GREATER
             return dictionary.TryRemove(kvp);
 #else
             // https://devblogs.microsoft.com/pfxteam/little-known-gems-atomic-conditional-removals-from-concurrentdictionary/
             return ((ICollection<KeyValuePair<K, AtomicFactory<K, V>>>)dictionary).Remove(kvp);
-#endif
+#endif
         }
 
         /// <summary>
@@ -82,16 +82,16 @@ public static bool TryRemove<K, V>(this ConcurrentDictionary<K, AtomicFactory<K,
         /// <param name="key">The key of the element to remove and return.</param>
         /// <param name="value">When this method returns, contains the object removed from the ConcurrentDictionary, or the default value of the TValue type if key does not exist.</param>
         /// <returns>true if the object was removed successfully; otherwise, false.</returns>
-        public static bool TryRemove<K, V>(this ConcurrentDictionary<K, AtomicFactory<K, V>> dictionary, K key, out V value)
-        {
+        public static bool TryRemove<K, V>(this ConcurrentDictionary<K, AtomicFactory<K, V>> dictionary, K key, out V value)
+        {
             if (dictionary.TryRemove(key, out var atomic))
             {
                 value = atomic.ValueIfCreated;
-                return true;
-            }
-
-            value = default;
-            return false;
-        }
-    }
-}
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+    }
+}
diff --git a/BitFaster.Caching/IAsyncCache.cs b/BitFaster.Caching/IAsyncCache.cs
index 59299d60..11d5b171 100644
--- a/BitFaster.Caching/IAsyncCache.cs
+++ b/BitFaster.Caching/IAsyncCache.cs
@@ -1,113 +1,113 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace BitFaster.Caching
-{
-    /// <summary>
-    /// Represents a generic cache of key/value pairs.
-    /// </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> : IEnumerable<KeyValuePair<K, V>>
-    {
-        /// <summary>
-        /// Gets the number of items currently held in the cache.
-        /// </summary>
-        int Count { get; }
-
-        /// <summary>
-        /// Gets the cache metrics, if configured.
-        /// </summary>
-        Optional<ICacheMetrics> Metrics { get; }
-
-        /// <summary>
-        /// Gets the cache events, if configured.
-        /// </summary>
-        Optional<ICacheEvents<K, V>> Events { get; }
-
-        /// <summary>
-        /// Gets the cache policy.
-        /// </summary>
-        CachePolicy Policy { 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>
-        /// <param name="key">The key of the value to get.</param>
-        /// <param name="value">When this method returns, contains the object from the cache that has the specified key, or the default value of the type if the operation failed.</param>
-        /// <returns>true if the key was found in the cache; otherwise, false.</returns>
-        bool TryGet(K key, out V value);
-
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
-        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
-        ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory);
-
-        // backcompat: remove conditional compile
-#if NETCOREAPP3_0_OR_GREATER
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
-        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
-        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching
+{
+    /// <summary>
+    /// Represents a generic cache of key/value pairs.
+    /// </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> : IEnumerable<KeyValuePair<K, V>>
+    {
+        /// <summary>
+        /// Gets the number of items currently held in the cache.
+        /// </summary>
+        int Count { get; }
+
+        /// <summary>
+        /// Gets the cache metrics, if configured.
+        /// </summary>
+        Optional<ICacheMetrics> Metrics { get; }
+
+        /// <summary>
+        /// Gets the cache events, if configured.
+        /// </summary>
+        Optional<ICacheEvents<K, V>> Events { get; }
+
+        /// <summary>
+        /// Gets the cache policy.
+        /// </summary>
+        CachePolicy Policy { 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>
+        /// <param name="key">The key of the value to get.</param>
+        /// <param name="value">When this method returns, contains the object from the cache that has the specified key, or the default value of the type if the operation failed.</param>
+        /// <returns>true if the key was found in the cache; otherwise, false.</returns>
+        bool TryGet(K key, out V value);
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
+        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
+        ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory);
+
+        // backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
+        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
+        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
         ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valueFactory, TArg factoryArgument) => this.GetOrAddAsync(key, k => valueFactory(k, factoryArgument));
 
-        /// <summary>
-        /// Attempts to remove and return the value that has the specified key.
-        /// </summary>
-        /// <param name="key">The key of the element to remove.</param>
-        /// <param name="value">When this method returns, contains the object removed, or the default value of the value type if key does not exist.</param>
-        /// <returns>true if the object was removed successfully; otherwise, false.</returns>
-        bool TryRemove(K key, out V value) => throw new NotSupportedException();
-
-        /// <summary>
-        /// Attempts to remove the specified key value pair.
-        /// </summary>
-        /// <param name="item">The item to remove.</param>
-        /// <returns>true if the item was removed successfully; otherwise, false.</returns>
-        bool TryRemove(KeyValuePair<K, V> item) => throw new NotSupportedException();
-#endif
-
-        /// <summary>
-        /// 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);
-
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist, or updates a key/value pair if the 
-        /// key already exists.
-        /// </summary>
-        /// <param name="key">The key of the element to update.</param>
-        /// <param name="value">The new value.</param>
-        void AddOrUpdate(K key, V value);
-
-        /// <summary>
-        /// Removes all keys and values from the cache.
-        /// </summary>
-        void Clear();
-    }
-}
+        /// <summary>
+        /// Attempts to remove and return the value that has the specified key.
+        /// </summary>
+        /// <param name="key">The key of the element to remove.</param>
+        /// <param name="value">When this method returns, contains the object removed, or the default value of the value type if key does not exist.</param>
+        /// <returns>true if the object was removed successfully; otherwise, false.</returns>
+        bool TryRemove(K key, out V value) => throw new NotSupportedException();
+
+        /// <summary>
+        /// Attempts to remove the specified key value pair.
+        /// </summary>
+        /// <param name="item">The item to remove.</param>
+        /// <returns>true if the item was removed successfully; otherwise, false.</returns>
+        bool TryRemove(KeyValuePair<K, V> item) => throw new NotSupportedException();
+#endif
+
+        /// <summary>
+        /// 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);
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist, or updates a key/value pair if the 
+        /// key already exists.
+        /// </summary>
+        /// <param name="key">The key of the element to update.</param>
+        /// <param name="value">The new value.</param>
+        void AddOrUpdate(K key, V value);
+
+        /// <summary>
+        /// Removes all keys and values from the cache.
+        /// </summary>
+        void Clear();
+    }
+}
diff --git a/BitFaster.Caching/ICache.cs b/BitFaster.Caching/ICache.cs
index 00e16c96..f28e85db 100644
--- a/BitFaster.Caching/ICache.cs
+++ b/BitFaster.Caching/ICache.cs
@@ -1,114 +1,114 @@
-using System;
-using System.Collections.Generic;
-
-namespace BitFaster.Caching
-{
-    /// <summary>
-    /// Represents a generic cache of key/value pairs.
-    /// </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> : IEnumerable<KeyValuePair<K, V>>
-    {
-        /// <summary>
-        /// Gets the number of items currently held in the cache.
-        /// </summary>
-        int Count { get; }
-
-        /// <summary>
-        /// Gets the cache metrics, if configured.
-        /// </summary>
-        Optional<ICacheMetrics> Metrics { get; }
-
-        /// <summary>
-        /// Gets the cache events, if configured.
-        /// </summary>
-        Optional<ICacheEvents<K, V>> Events { get; }
-
-        /// <summary>
-        /// Gets the cache policy.
-        /// </summary>
-        CachePolicy Policy { 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>
-        /// <param name="key">The key of the value to get.</param>
-        /// <param name="value">When this method returns, contains the object from the cache that has the specified key, or the default value of the type if the operation failed.</param>
-        /// <returns>true if the key was found in the cache; otherwise, false.</returns>
-        bool TryGet(K key, out V value);
-
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
-        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
-        /// in the cache, or the new value if the key was not in the cache.</returns>
-        V GetOrAdd(K key, Func<K, V> valueFactory);
-
-        // backcompat: remove conditional compile
-#if NETCOREAPP3_0_OR_GREATER
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
-        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
-        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
-        /// in the cache, or the new value if the key was not in the cache.</returns>
-        V GetOrAdd<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument) => this.GetOrAdd(key, k => valueFactory(k, factoryArgument));
-
+using System;
+using System.Collections.Generic;
+
+namespace BitFaster.Caching
+{
+    /// <summary>
+    /// Represents a generic cache of key/value pairs.
+    /// </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> : IEnumerable<KeyValuePair<K, V>>
+    {
+        /// <summary>
+        /// Gets the number of items currently held in the cache.
+        /// </summary>
+        int Count { get; }
+
+        /// <summary>
+        /// Gets the cache metrics, if configured.
+        /// </summary>
+        Optional<ICacheMetrics> Metrics { get; }
+
+        /// <summary>
+        /// Gets the cache events, if configured.
+        /// </summary>
+        Optional<ICacheEvents<K, V>> Events { get; }
+
+        /// <summary>
+        /// Gets the cache policy.
+        /// </summary>
+        CachePolicy Policy { 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>
+        /// <param name="key">The key of the value to get.</param>
+        /// <param name="value">When this method returns, contains the object from the cache that has the specified key, or the default value of the type if the operation failed.</param>
+        /// <returns>true if the key was found in the cache; otherwise, false.</returns>
+        bool TryGet(K key, out V value);
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
+        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
+        /// in the cache, or the new value if the key was not in the cache.</returns>
+        V GetOrAdd(K key, Func<K, V> valueFactory);
+
+        // backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
+        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
+        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
+        /// in the cache, or the new value if the key was not in the cache.</returns>
+        V GetOrAdd<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument) => this.GetOrAdd(key, k => valueFactory(k, factoryArgument));
+
         /// <summary>
         /// Attempts to remove and return the value that has the specified key.
         /// </summary>
         /// <param name="key">The key of the element to remove.</param>
         /// <param name="value">When this method returns, contains the object removed, or the default value of the value type if key does not exist.</param>
         /// <returns>true if the object was removed successfully; otherwise, false.</returns>
-        bool TryRemove(K key, out V value) => throw new NotSupportedException();
-
+        bool TryRemove(K key, out V value) => throw new NotSupportedException();
+
         /// <summary>
         /// Attempts to remove the specified key value pair.
         /// </summary>
         /// <param name="item">The item to remove.</param>
         /// <returns>true if the item was removed successfully; otherwise, false.</returns>
-        bool TryRemove(KeyValuePair<K, V> item) => throw new NotSupportedException();
-#endif
-
-        /// <summary>
-        /// 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);
-
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist, or updates a key/value pair if the 
-        /// key already exists.
-        /// </summary>
-        /// <param name="key">The key of the element to update.</param>
-        /// <param name="value">The new value.</param>
-        void AddOrUpdate(K key, V value);
-
-        /// <summary>
-        /// Removes all keys and values from the cache.
-        /// </summary>
-        void Clear();
-    }
-}
+        bool TryRemove(KeyValuePair<K, V> item) => throw new NotSupportedException();
+#endif
+
+        /// <summary>
+        /// 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);
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist, or updates a key/value pair if the 
+        /// key already exists.
+        /// </summary>
+        /// <param name="key">The key of the element to update.</param>
+        /// <param name="value">The new value.</param>
+        void AddOrUpdate(K key, V value);
+
+        /// <summary>
+        /// Removes all keys and values from the cache.
+        /// </summary>
+        void Clear();
+    }
+}
diff --git a/BitFaster.Caching/Lfu/ConcurrentLfu.cs b/BitFaster.Caching/Lfu/ConcurrentLfu.cs
index fb550b32..0d47aeee 100644
--- a/BitFaster.Caching/Lfu/ConcurrentLfu.cs
+++ b/BitFaster.Caching/Lfu/ConcurrentLfu.cs
@@ -1,330 +1,330 @@
-using System;
-using System.Collections;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Threading;
-using System.Threading.Tasks;
-using BitFaster.Caching.Buffers;
-using BitFaster.Caching.Counters;
-using BitFaster.Caching.Lru;
-using BitFaster.Caching.Scheduler;
-
-#if DEBUG
-using System.Text;
-#endif
-
-namespace BitFaster.Caching.Lfu
-{
-    /// <summary>
-    /// An approximate LFU based on the W-TinyLfu eviction policy. W-TinyLfu tracks items using a window LRU list, and 
-    /// a main space LRU divided into protected and probation segments. Reads and writes to the cache are stored in buffers
-    /// and later applied to the policy LRU lists in batches under a lock. Each read and write is tracked using a compact 
-    /// popularity sketch to probalistically estimate item frequency. Items proceed through the LRU lists as follows:
-    /// <list type="number">
-    ///   <item><description>New items are added to the window LRU. When acessed window items move to the window MRU position.</description></item>
-    ///   <item><description>When the window is full, candidate items are moved to the probation segment in LRU order.</description></item>
-    ///   <item><description>When the main space is full, the access frequency of each window candidate is compared 
-    ///   to probation victims in LRU order. The item with the lowest frequency is evicted until the cache size is within bounds.</description></item>
-    ///   <item><description>When a probation item is accessed, it is moved to the protected segment. If the protected segment is full, 
-    ///   the LRU protected item is demoted to probation.</description></item>
-    ///   <item><description>When a protected item is accessed, it is moved to the protected MRU position.</description></item>
-    /// </list>
-    /// The size of the admission window and main space are adapted over time to iteratively improve hit rate using a 
-    /// hill climbing algorithm. A larger window favors workloads with high recency bias, whereas a larger main space
-    /// favors workloads with frequency bias.
-    /// </summary>
-    /// Based on the Caffeine library by ben.manes@gmail.com (Ben Manes).
-    /// https://github.com/ben-manes/caffeine
-    [DebuggerTypeProxy(typeof(ConcurrentLfu<,>.LfuDebugView))]
-    [DebuggerDisplay("Count = {Count}/{Capacity}")]
-    public sealed class ConcurrentLfu<K, V> : ICache<K, V>, IAsyncCache<K, V>, IBoundedPolicy
-    {
-        private const int MaxWriteBufferRetries = 64;
-
-        /// <summary>
-        /// The default buffer size.
-        /// </summary>
-        public const int DefaultBufferSize = 128;
-
-        private readonly ConcurrentDictionary<K, LfuNode<K, V>> dictionary;
-
-        private readonly StripedMpscBuffer<LfuNode<K, V>> readBuffer;
-        private readonly MpscBoundedBuffer<LfuNode<K, V>> writeBuffer;
-
-        private readonly CacheMetrics metrics = new();
-
-        private readonly CmSketch<K> cmSketch;
-
-        private readonly LfuNodeList<K, V> windowLru;
-        private readonly LfuNodeList<K, V> probationLru;
-        private readonly LfuNodeList<K, V> protectedLru;
-
-        private readonly LfuCapacityPartition capacity;
-
-        private readonly DrainStatus drainStatus = new();
-        private readonly object maintenanceLock = new();
-
-        private readonly IScheduler scheduler;
-        private readonly Action drainBuffers;
-
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+using BitFaster.Caching.Buffers;
+using BitFaster.Caching.Counters;
+using BitFaster.Caching.Lru;
+using BitFaster.Caching.Scheduler;
+
+#if DEBUG
+using System.Text;
+#endif
+
+namespace BitFaster.Caching.Lfu
+{
+    /// <summary>
+    /// An approximate LFU based on the W-TinyLfu eviction policy. W-TinyLfu tracks items using a window LRU list, and 
+    /// a main space LRU divided into protected and probation segments. Reads and writes to the cache are stored in buffers
+    /// and later applied to the policy LRU lists in batches under a lock. Each read and write is tracked using a compact 
+    /// popularity sketch to probalistically estimate item frequency. Items proceed through the LRU lists as follows:
+    /// <list type="number">
+    ///   <item><description>New items are added to the window LRU. When acessed window items move to the window MRU position.</description></item>
+    ///   <item><description>When the window is full, candidate items are moved to the probation segment in LRU order.</description></item>
+    ///   <item><description>When the main space is full, the access frequency of each window candidate is compared 
+    ///   to probation victims in LRU order. The item with the lowest frequency is evicted until the cache size is within bounds.</description></item>
+    ///   <item><description>When a probation item is accessed, it is moved to the protected segment. If the protected segment is full, 
+    ///   the LRU protected item is demoted to probation.</description></item>
+    ///   <item><description>When a protected item is accessed, it is moved to the protected MRU position.</description></item>
+    /// </list>
+    /// The size of the admission window and main space are adapted over time to iteratively improve hit rate using a 
+    /// hill climbing algorithm. A larger window favors workloads with high recency bias, whereas a larger main space
+    /// favors workloads with frequency bias.
+    /// </summary>
+    /// Based on the Caffeine library by ben.manes@gmail.com (Ben Manes).
+    /// https://github.com/ben-manes/caffeine
+    [DebuggerTypeProxy(typeof(ConcurrentLfu<,>.LfuDebugView))]
+    [DebuggerDisplay("Count = {Count}/{Capacity}")]
+    public sealed class ConcurrentLfu<K, V> : ICache<K, V>, IAsyncCache<K, V>, IBoundedPolicy
+    {
+        private const int MaxWriteBufferRetries = 64;
+
+        /// <summary>
+        /// The default buffer size.
+        /// </summary>
+        public const int DefaultBufferSize = 128;
+
+        private readonly ConcurrentDictionary<K, LfuNode<K, V>> dictionary;
+
+        private readonly StripedMpscBuffer<LfuNode<K, V>> readBuffer;
+        private readonly MpscBoundedBuffer<LfuNode<K, V>> writeBuffer;
+
+        private readonly CacheMetrics metrics = new();
+
+        private readonly CmSketch<K> cmSketch;
+
+        private readonly LfuNodeList<K, V> windowLru;
+        private readonly LfuNodeList<K, V> probationLru;
+        private readonly LfuNodeList<K, V> protectedLru;
+
+        private readonly LfuCapacityPartition capacity;
+
+        private readonly DrainStatus drainStatus = new();
+        private readonly object maintenanceLock = new();
+
+        private readonly IScheduler scheduler;
+        private readonly Action drainBuffers;
+
         private readonly LfuNode<K, V>[] drainBuffer;
-
-        /// <summary>
-        /// Initializes a new instance of the ConcurrentLfu class with the specified capacity.
-        /// </summary>
-        /// <param name="capacity">The capacity.</param>
-        public ConcurrentLfu(int capacity)
-            : this(Defaults.ConcurrencyLevel, capacity, new ThreadPoolScheduler(), EqualityComparer<K>.Default)
-        {        
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the ConcurrentLfu class with the specified concurrencyLevel, capacity, scheduler, equality comparer and buffer size.
-        /// </summary>
-        /// <param name="concurrencyLevel">The concurrency level.</param>
-        /// <param name="capacity">The capacity.</param>
-        /// <param name="scheduler">The scheduler.</param>
-        /// <param name="comparer">The equality comparer.</param>
-        public ConcurrentLfu(int concurrencyLevel, int capacity, IScheduler scheduler, IEqualityComparer<K> comparer)
-        {
-            int dictionaryCapacity = ConcurrentDictionarySize.Estimate(capacity);
-            this.dictionary = new ConcurrentDictionary<K, LfuNode<K, V>>(concurrencyLevel, dictionaryCapacity, comparer);
-
-            // cap concurrency at proc count * 2
-            int readStripes = Math.Min(BitOps.CeilingPowerOfTwo(concurrencyLevel), BitOps.CeilingPowerOfTwo(Environment.ProcessorCount * 2));
-            this.readBuffer = new StripedMpscBuffer<LfuNode<K, V>>(readStripes, DefaultBufferSize);
-
-            // Cap the write buffer to the cache size, or 128. Whichever is smaller.
-            int writeBufferSize = Math.Min(BitOps.CeilingPowerOfTwo(capacity), 128);
-            this.writeBuffer = new MpscBoundedBuffer<LfuNode<K, V>>(writeBufferSize);
-
-            this.cmSketch = new CmSketch<K>(capacity, comparer);
-            this.windowLru = new LfuNodeList<K, V>();
-            this.probationLru = new LfuNodeList<K, V>();
-            this.protectedLru = new LfuNodeList<K, V>();
-
-            this.capacity = new LfuCapacityPartition(capacity);
-
-            this.scheduler = scheduler;
-            this.drainBuffers = () => this.DrainBuffers();
-
-            this.drainBuffer = new LfuNode<K, V>[this.readBuffer.Capacity];
-        }
-
-        // No lock count: https://arbel.net/2013/02/03/best-practices-for-using-concurrentdictionary/
-        ///<inheritdoc/>
-        public int Count => this.dictionary.Skip(0).Count();
-
-        ///<inheritdoc/>
-        public int Capacity => this.capacity.Capacity;
-
-        ///<inheritdoc/>
-        public Optional<ICacheMetrics> Metrics => new(this.metrics);
-
-        ///<inheritdoc/>
-        public Optional<ICacheEvents<K, V>> Events => Optional<ICacheEvents<K, V>>.None();
-
-        ///<inheritdoc/>
-        public CachePolicy Policy => new(new Optional<IBoundedPolicy>(this), Optional<ITimePolicy>.None());
-
-        ///<inheritdoc/>
-        public ICollection<K> Keys => this.dictionary.Keys;
-
-        /// <summary>
-        /// Gets the scheduler.
-        /// </summary>
-        public IScheduler Scheduler => scheduler;
-
-        ///<inheritdoc/>
-        public void AddOrUpdate(K key, V value)
-        {
-            while (true)
-            {
-                if (TryUpdate(key, value))
-                {
-                    return;
-                }
-
-                var node = new LfuNode<K, V>(key, value);
-                if (this.dictionary.TryAdd(key, node))
-                {
-                    AfterWrite(node);
-                    return;
-                }
-            }
-        }
-
-        ///<inheritdoc/>
-        public void Clear()
-        {
-            this.Trim(this.Count);
-
-            lock (maintenanceLock)
-            {
-                this.cmSketch.Clear();
-                this.readBuffer.Clear();
-                this.writeBuffer.Clear();
-            }
-        }
-
-        /// <summary>
-        /// Trim the specified number of items from the cache.
-        /// </summary>
-        /// <param name="itemCount">The number of items to remove.</param>
-        public void Trim(int itemCount)
-        {
-            itemCount = Math.Min(itemCount, this.Count);
-            var candidates = new List<LfuNode<K, V>>(itemCount);
-
-            // TODO: this is LRU order eviction, Caffeine is based on frequency
-            lock (maintenanceLock)
-            {
-                // flush all buffers
-                Maintenance();
-
-                // walk in lru order, get itemCount keys to evict
-                TakeCandidatesInLruOrder(this.probationLru, candidates, itemCount);
-                TakeCandidatesInLruOrder(this.protectedLru, candidates, itemCount);
-                TakeCandidatesInLruOrder(this.windowLru, candidates, itemCount);
-            }
-
-#if NET6_0_OR_GREATER
+
+        /// <summary>
+        /// Initializes a new instance of the ConcurrentLfu class with the specified capacity.
+        /// </summary>
+        /// <param name="capacity">The capacity.</param>
+        public ConcurrentLfu(int capacity)
+            : this(Defaults.ConcurrencyLevel, capacity, new ThreadPoolScheduler(), EqualityComparer<K>.Default)
+        {        
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the ConcurrentLfu class with the specified concurrencyLevel, capacity, scheduler, equality comparer and buffer size.
+        /// </summary>
+        /// <param name="concurrencyLevel">The concurrency level.</param>
+        /// <param name="capacity">The capacity.</param>
+        /// <param name="scheduler">The scheduler.</param>
+        /// <param name="comparer">The equality comparer.</param>
+        public ConcurrentLfu(int concurrencyLevel, int capacity, IScheduler scheduler, IEqualityComparer<K> comparer)
+        {
+            int dictionaryCapacity = ConcurrentDictionarySize.Estimate(capacity);
+            this.dictionary = new ConcurrentDictionary<K, LfuNode<K, V>>(concurrencyLevel, dictionaryCapacity, comparer);
+
+            // cap concurrency at proc count * 2
+            int readStripes = Math.Min(BitOps.CeilingPowerOfTwo(concurrencyLevel), BitOps.CeilingPowerOfTwo(Environment.ProcessorCount * 2));
+            this.readBuffer = new StripedMpscBuffer<LfuNode<K, V>>(readStripes, DefaultBufferSize);
+
+            // Cap the write buffer to the cache size, or 128. Whichever is smaller.
+            int writeBufferSize = Math.Min(BitOps.CeilingPowerOfTwo(capacity), 128);
+            this.writeBuffer = new MpscBoundedBuffer<LfuNode<K, V>>(writeBufferSize);
+
+            this.cmSketch = new CmSketch<K>(capacity, comparer);
+            this.windowLru = new LfuNodeList<K, V>();
+            this.probationLru = new LfuNodeList<K, V>();
+            this.protectedLru = new LfuNodeList<K, V>();
+
+            this.capacity = new LfuCapacityPartition(capacity);
+
+            this.scheduler = scheduler;
+            this.drainBuffers = () => this.DrainBuffers();
+
+            this.drainBuffer = new LfuNode<K, V>[this.readBuffer.Capacity];
+        }
+
+        // No lock count: https://arbel.net/2013/02/03/best-practices-for-using-concurrentdictionary/
+        ///<inheritdoc/>
+        public int Count => this.dictionary.Skip(0).Count();
+
+        ///<inheritdoc/>
+        public int Capacity => this.capacity.Capacity;
+
+        ///<inheritdoc/>
+        public Optional<ICacheMetrics> Metrics => new(this.metrics);
+
+        ///<inheritdoc/>
+        public Optional<ICacheEvents<K, V>> Events => Optional<ICacheEvents<K, V>>.None();
+
+        ///<inheritdoc/>
+        public CachePolicy Policy => new(new Optional<IBoundedPolicy>(this), Optional<ITimePolicy>.None());
+
+        ///<inheritdoc/>
+        public ICollection<K> Keys => this.dictionary.Keys;
+
+        /// <summary>
+        /// Gets the scheduler.
+        /// </summary>
+        public IScheduler Scheduler => scheduler;
+
+        ///<inheritdoc/>
+        public void AddOrUpdate(K key, V value)
+        {
+            while (true)
+            {
+                if (TryUpdate(key, value))
+                {
+                    return;
+                }
+
+                var node = new LfuNode<K, V>(key, value);
+                if (this.dictionary.TryAdd(key, node))
+                {
+                    AfterWrite(node);
+                    return;
+                }
+            }
+        }
+
+        ///<inheritdoc/>
+        public void Clear()
+        {
+            this.Trim(this.Count);
+
+            lock (maintenanceLock)
+            {
+                this.cmSketch.Clear();
+                this.readBuffer.Clear();
+                this.writeBuffer.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Trim the specified number of items from the cache.
+        /// </summary>
+        /// <param name="itemCount">The number of items to remove.</param>
+        public void Trim(int itemCount)
+        {
+            itemCount = Math.Min(itemCount, this.Count);
+            var candidates = new List<LfuNode<K, V>>(itemCount);
+
+            // TODO: this is LRU order eviction, Caffeine is based on frequency
+            lock (maintenanceLock)
+            {
+                // flush all buffers
+                Maintenance();
+
+                // walk in lru order, get itemCount keys to evict
+                TakeCandidatesInLruOrder(this.probationLru, candidates, itemCount);
+                TakeCandidatesInLruOrder(this.protectedLru, candidates, itemCount);
+                TakeCandidatesInLruOrder(this.windowLru, candidates, itemCount);
+            }
+
+#if NET6_0_OR_GREATER
             foreach (var candidate in CollectionsMarshal.AsSpan(candidates))
-#else
-            foreach (var candidate in candidates)
-#endif
-            {
-                this.TryRemove(candidate.Key);
-            }
-        }
-
-        private bool TryAdd(K key, V value)
-        {
-            var node = new LfuNode<K, V>(key, value);
-
-            if (this.dictionary.TryAdd(key, node))
-            {
-                AfterWrite(node);
-                return true;
-            }
-
-            Disposer<V>.Dispose(node.Value);
-            return false;
-        }
-
-        ///<inheritdoc/>
-        public V GetOrAdd(K key, Func<K, V> valueFactory)
-        {
-            while (true)
-            {
-                if (this.TryGet(key, out V value))
-                {
-                    return value;
-                }
-
-                value = valueFactory(key);
-                if (this.TryAdd(key, value))
-                {
-                    return value;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
-        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
-        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
-        /// in the cache, or the new value if the key was not in the cache.</returns>
-        public V GetOrAdd<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument)
-        {
-            while (true)
-            {
-                if (this.TryGet(key, out V value))
-                {
-                    return value;
-                }
-
-                value = valueFactory(key, factoryArgument);
-                if (this.TryAdd(key, value))
-                {
-                    return value;
-                }
-            }
-        }
-
-        ///<inheritdoc/>
-        public async ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
-        {
-            while (true)
-            {
-                if (this.TryGet(key, out V value))
-                {
-                    return value;
-                }
-
-                value = await valueFactory(key).ConfigureAwait(false);
-                if (this.TryAdd(key, value))
-                {
-                    return value;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
-        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
-        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
-        public async ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valueFactory, TArg factoryArgument)
-        {
-            while (true)
-            {
-                if (this.TryGet(key, out V value))
-                {
-                    return value;
-                }
-
-                value = await valueFactory(key, factoryArgument).ConfigureAwait(false);
-                if (this.TryAdd(key, value))
-                {
-                    return value;
-                }
-            }
-        }
-
-        ///<inheritdoc/>
-        public bool TryGet(K key, out V value)
-        {
-            if (this.dictionary.TryGetValue(key, out var node))
-            {
-                bool delayable = this.readBuffer.TryAdd(node) != BufferStatus.Full;
-
-                if (this.drainStatus.ShouldDrain(delayable))
-                { 
-                    TryScheduleDrain(); 
-                }
-                value = node.Value;               
-                return true;
-            }
-
-            this.metrics.requestMissCount.Increment();
-
-            value = default;
-            return false;
+#else
+            foreach (var candidate in candidates)
+#endif
+            {
+                this.TryRemove(candidate.Key);
+            }
+        }
+
+        private bool TryAdd(K key, V value)
+        {
+            var node = new LfuNode<K, V>(key, value);
+
+            if (this.dictionary.TryAdd(key, node))
+            {
+                AfterWrite(node);
+                return true;
+            }
+
+            Disposer<V>.Dispose(node.Value);
+            return false;
+        }
+
+        ///<inheritdoc/>
+        public V GetOrAdd(K key, Func<K, V> valueFactory)
+        {
+            while (true)
+            {
+                if (this.TryGet(key, out V value))
+                {
+                    return value;
+                }
+
+                value = valueFactory(key);
+                if (this.TryAdd(key, value))
+                {
+                    return value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
+        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
+        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
+        /// in the cache, or the new value if the key was not in the cache.</returns>
+        public V GetOrAdd<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument)
+        {
+            while (true)
+            {
+                if (this.TryGet(key, out V value))
+                {
+                    return value;
+                }
+
+                value = valueFactory(key, factoryArgument);
+                if (this.TryAdd(key, value))
+                {
+                    return value;
+                }
+            }
+        }
+
+        ///<inheritdoc/>
+        public async ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
+        {
+            while (true)
+            {
+                if (this.TryGet(key, out V value))
+                {
+                    return value;
+                }
+
+                value = await valueFactory(key).ConfigureAwait(false);
+                if (this.TryAdd(key, value))
+                {
+                    return value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
+        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
+        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
+        public async ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valueFactory, TArg factoryArgument)
+        {
+            while (true)
+            {
+                if (this.TryGet(key, out V value))
+                {
+                    return value;
+                }
+
+                value = await valueFactory(key, factoryArgument).ConfigureAwait(false);
+                if (this.TryAdd(key, value))
+                {
+                    return value;
+                }
+            }
+        }
+
+        ///<inheritdoc/>
+        public bool TryGet(K key, out V value)
+        {
+            if (this.dictionary.TryGetValue(key, out var node))
+            {
+                bool delayable = this.readBuffer.TryAdd(node) != BufferStatus.Full;
+
+                if (this.drainStatus.ShouldDrain(delayable))
+                { 
+                    TryScheduleDrain(); 
+                }
+                value = node.Value;               
+                return true;
+            }
+
+            this.metrics.requestMissCount.Increment();
+
+            value = default;
+            return false;
         }
 
         /// <summary>
@@ -332,8 +332,8 @@ public bool TryGet(K key, out V value)
         /// </summary>
         /// <param name="item">The item to remove.</param>
         /// <returns>true if the item was removed successfully; otherwise, false.</returns>
-        public bool TryRemove(KeyValuePair<K, V> item)
-        {
+        public bool TryRemove(KeyValuePair<K, V> item)
+        {
             if (this.dictionary.TryGetValue(item.Key, out var node))
             {
                 if (EqualityComparer<V>.Default.Equals(node.Value, item.Value))
@@ -348,13 +348,13 @@ public bool TryRemove(KeyValuePair<K, V> item)
 #endif
                     {
                         node.WasRemoved = true;
-                        AfterWrite(node);
-                        return true;
-                    }
-                }
-            }
-
-            return false;
+                        AfterWrite(node);
+                        return true;
+                    }
+                }
+            }
+
+            return false;
         }
 
         /// <summary>
@@ -362,340 +362,340 @@ public bool TryRemove(KeyValuePair<K, V> item)
         /// </summary>
         /// <param name="key">The key of the element to remove.</param>
         /// <param name="value">When this method returns, contains the object removed, or the default value of the value type if key does not exist.</param>
-        /// <returns>true if the object was removed successfully; otherwise, false.</returns>
-        public bool TryRemove(K key, out V value)
-        {
-            if (this.dictionary.TryRemove(key, out var node))
-            {
-                node.WasRemoved = true;
-                AfterWrite(node);
-                value = node.Value;
-                return true;
-            }
-
-            value = default;
-            return false;
-        }
-
-        ///<inheritdoc/>
-        public bool TryRemove(K key)
-        {
-            return this.TryRemove(key, out var _);
-        }
-
-        ///<inheritdoc/>
-        public bool TryUpdate(K key, V value)
-        {
-            if (this.dictionary.TryGetValue(key, out var node))
-            {
-                node.Value = value;
-
-                // It's ok for this to be lossy, since the node is already tracked
-                // and we will just lose ordering/hit count, but not orphan the node.
-                this.writeBuffer.TryAdd(node);
-                TryScheduleDrain();
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Synchronously perform all pending policy maintenance. Drain the read and write buffers then
-        /// use the eviction policy to preserve bounded size and remove expired items.
-        /// </summary>
-        /// <remarks>
-        /// Note: maintenance is automatically performed asynchronously immediately following a read or write.
-        /// It is not necessary to call this method, <see cref="DoMaintenance"/> is provided purely to enable tests to reach a consistent state.
-        /// </remarks>
-        public void DoMaintenance()
-        {
-            DrainBuffers();
-        }
-
-        /// <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);
-            }
-        }
-
-        private static void TakeCandidatesInLruOrder(LfuNodeList<K, V> lru, List<LfuNode<K, V>> candidates, int itemCount)
-        {
-            var curr = lru.First;
-
-            while (candidates.Count < itemCount && curr != null)
-            {
-                // LRUs can contain items that are already removed, skip those 
+        /// <returns>true if the object was removed successfully; otherwise, false.</returns>
+        public bool TryRemove(K key, out V value)
+        {
+            if (this.dictionary.TryRemove(key, out var node))
+            {
+                node.WasRemoved = true;
+                AfterWrite(node);
+                value = node.Value;
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+
+        ///<inheritdoc/>
+        public bool TryRemove(K key)
+        {
+            return this.TryRemove(key, out var _);
+        }
+
+        ///<inheritdoc/>
+        public bool TryUpdate(K key, V value)
+        {
+            if (this.dictionary.TryGetValue(key, out var node))
+            {
+                node.Value = value;
+
+                // It's ok for this to be lossy, since the node is already tracked
+                // and we will just lose ordering/hit count, but not orphan the node.
+                this.writeBuffer.TryAdd(node);
+                TryScheduleDrain();
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Synchronously perform all pending policy maintenance. Drain the read and write buffers then
+        /// use the eviction policy to preserve bounded size and remove expired items.
+        /// </summary>
+        /// <remarks>
+        /// Note: maintenance is automatically performed asynchronously immediately following a read or write.
+        /// It is not necessary to call this method, <see cref="DoMaintenance"/> is provided purely to enable tests to reach a consistent state.
+        /// </remarks>
+        public void DoMaintenance()
+        {
+            DrainBuffers();
+        }
+
+        /// <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);
+            }
+        }
+
+        private static void TakeCandidatesInLruOrder(LfuNodeList<K, V> lru, List<LfuNode<K, V>> candidates, int itemCount)
+        {
+            var curr = lru.First;
+
+            while (candidates.Count < itemCount && curr != null)
+            {
+                // LRUs can contain items that are already removed, skip those 
                 if (!curr.WasRemoved)
-                { 
-                    candidates.Add(curr); 
-                }
-
-                curr = curr.Next;
-            }
-        }
-
-        private void AfterWrite(LfuNode<K, V> node)
-        {
-            for (int i = 0; i < MaxWriteBufferRetries; i++)
-            {
-                if (writeBuffer.TryAdd(node) == BufferStatus.Success)
-                {
-                    ScheduleAfterWrite();
-                    return;
-                }
-
-                TryScheduleDrain();
-            }
-
-            lock (this.maintenanceLock)
-            {
-                // aggressively try to exit the lock early before doing full maintenance
-                var status = BufferStatus.Contended;
-                while (status != BufferStatus.Full)
-                {
-                    status = writeBuffer.TryAdd(node);
-
-                    if (status == BufferStatus.Success)
-                    {
-                        ScheduleAfterWrite();
-                        return;
-                    }
-                }
-
-                // if the write was dropped from the buffer, explicitly pass it to maintenance
-                Maintenance(node);
-            }
-        }
-
-        private void ScheduleAfterWrite()
-        {
-            var spinner = new SpinWait();
-            int status = this.drainStatus.NonVolatileRead();
-            while (true)
-            {
-                switch (status)
-                {
-                    case DrainStatus.Idle:
-                        this.drainStatus.Cas(DrainStatus.Idle, DrainStatus.Required);
-                        TryScheduleDrain();
-                        return;
-                    case DrainStatus.Required:
-                        TryScheduleDrain();
-                        return;
-                    case DrainStatus.ProcessingToIdle:
-                        if (this.drainStatus.Cas(DrainStatus.ProcessingToIdle, DrainStatus.ProcessingToRequired))
-                        {
-                            return;
-                        }
-                        status = this.drainStatus.VolatileRead();
-                        break;
-                    case DrainStatus.ProcessingToRequired:
-                        return;
-                }
-                spinner.SpinOnce();
-            }
-        }
-
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return ((ConcurrentLfu<K, V>)this).GetEnumerator();
-        }
-
-        private void TryScheduleDrain()
-        {
+                { 
+                    candidates.Add(curr); 
+                }
+
+                curr = curr.Next;
+            }
+        }
+
+        private void AfterWrite(LfuNode<K, V> node)
+        {
+            for (int i = 0; i < MaxWriteBufferRetries; i++)
+            {
+                if (writeBuffer.TryAdd(node) == BufferStatus.Success)
+                {
+                    ScheduleAfterWrite();
+                    return;
+                }
+
+                TryScheduleDrain();
+            }
+
+            lock (this.maintenanceLock)
+            {
+                // aggressively try to exit the lock early before doing full maintenance
+                var status = BufferStatus.Contended;
+                while (status != BufferStatus.Full)
+                {
+                    status = writeBuffer.TryAdd(node);
+
+                    if (status == BufferStatus.Success)
+                    {
+                        ScheduleAfterWrite();
+                        return;
+                    }
+                }
+
+                // if the write was dropped from the buffer, explicitly pass it to maintenance
+                Maintenance(node);
+            }
+        }
+
+        private void ScheduleAfterWrite()
+        {
+            var spinner = new SpinWait();
+            int status = this.drainStatus.NonVolatileRead();
+            while (true)
+            {
+                switch (status)
+                {
+                    case DrainStatus.Idle:
+                        this.drainStatus.Cas(DrainStatus.Idle, DrainStatus.Required);
+                        TryScheduleDrain();
+                        return;
+                    case DrainStatus.Required:
+                        TryScheduleDrain();
+                        return;
+                    case DrainStatus.ProcessingToIdle:
+                        if (this.drainStatus.Cas(DrainStatus.ProcessingToIdle, DrainStatus.ProcessingToRequired))
+                        {
+                            return;
+                        }
+                        status = this.drainStatus.VolatileRead();
+                        break;
+                    case DrainStatus.ProcessingToRequired:
+                        return;
+                }
+                spinner.SpinOnce();
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return ((ConcurrentLfu<K, V>)this).GetEnumerator();
+        }
+
+        private void TryScheduleDrain()
+        {
             if (this.drainStatus.NonVolatileRead() >= DrainStatus.ProcessingToIdle)
             {
-                return;
-            }
-
-            bool lockTaken = false;
-            try
-            {
-                Monitor.TryEnter(maintenanceLock, ref lockTaken);
-
-                if (lockTaken)
-                {
-                    int status = this.drainStatus.NonVolatileRead();
-
-                    if (status >= DrainStatus.ProcessingToIdle)
-                    {
-                        return;
-                    }
-
-                    this.drainStatus.VolatileWrite(DrainStatus.ProcessingToIdle);
-                    scheduler.Run(this.drainBuffers);
-                }
-            }
-            finally
-            {
-                if (lockTaken)
-                {
-                    Monitor.Exit(maintenanceLock);
-                }
-            }
-        }
-
-        private void DrainBuffers()
-        {
-            bool done = false;
-
-            while (!done)
-            {
-                lock (maintenanceLock)
-                {
-                    done = Maintenance();
-                }
-
-                // don't run continuous foreground maintenance
-                if (!scheduler.IsBackground)
-                {
-                    done = true;
-                }
-            }
-
-            if (this.drainStatus.VolatileRead() == DrainStatus.Required)
-            {
-                TryScheduleDrain();
-            }
-        }
-
-        private bool Maintenance(LfuNode<K, V> droppedWrite = null)
-        {
-            this.drainStatus.VolatileWrite(DrainStatus.ProcessingToIdle);
-
-            // Note: this is only Span on .NET Core 3.1+, else this is no-op and it is still an array
-            var buffer = this.drainBuffer.AsSpanOrArray();
-
-            // extract to a buffer before doing book keeping work, ~2x faster
-            int readCount = readBuffer.DrainTo(buffer);
-
-            for (int i = 0; i < readCount; i++)
-            {
-                this.cmSketch.Increment(buffer[i].Key);
-            }
-
-            for (int i = 0; i < readCount; i++)
-            {
-                OnAccess(buffer[i]);
-            }
-
-            int writeCount = this.writeBuffer.DrainTo(buffer.AsSpanOrSegment());
-
-            for (int i = 0; i < writeCount; i++)
-            {
-                OnWrite(buffer[i]);
-            }
-
-            // we are done only when both buffers are empty
-            var done = readCount == 0 & writeCount == 0;
-
-            if (droppedWrite != null)
-            {
-                OnWrite(droppedWrite);
-                done = true;
-            }
-
-            EvictEntries();
-            this.capacity.OptimizePartitioning(this.metrics, this.cmSketch.ResetSampleSize);
-            ReFitProtected();
-
-            // Reset to idle if either
-            // 1. We drained both input buffers (all work done)
-            // 2. or scheduler is foreground (since don't run continuously on the foreground)
-            if ((done || !scheduler.IsBackground) &&
-                (this.drainStatus.NonVolatileRead() != DrainStatus.ProcessingToIdle ||
-                !this.drainStatus.Cas(DrainStatus.ProcessingToIdle, DrainStatus.Idle)))
-            {
-                this.drainStatus.NonVolatileWrite(DrainStatus.Required);
-            }
-
-            return done;
-        }
-
-        private void OnAccess(LfuNode<K, V> node)
-        {
-            // there was a cache hit even if the item was removed or is not yet added.
-            this.metrics.requestHitCount++;
-
-            // Node is added to read buffer while it is removed by maintenance, or it is read before it has been added.
-            if (node.list == null)
-            {
-                return;
-            }
-
-            switch (node.Position)
-            {
-                case Position.Window:
-                    this.windowLru.MoveToEnd(node); 
-                    break;
-                case Position.Probation:
-                    PromoteProbation(node); 
-                    break;
-                case Position.Protected:
-                    this.protectedLru.MoveToEnd(node);
-                    break;
-            }
-        }
-
-        private void OnWrite(LfuNode<K, V> node)
-        {
-            // Nodes can be removed while they are in the write buffer, in which case they should
-            // not be added back into the LRU.
-            if (node.WasRemoved)
-            {
-                node.list?.Remove(node);
-
-                if (!node.WasDeleted)
-                {
-                    // if a write is in the buffer and is then removed in the buffer, it will enter OnWrite twice.
-                    // we mark as deleted to avoid double counting/disposing it
-                    this.metrics.evictedCount++;
-                    Disposer<V>.Dispose(node.Value);
-                    node.WasDeleted = true;
-                }
-
-                return;
-            }
-
-            this.cmSketch.Increment(node.Key);
-
-            // node can already be in one of the queues due to update
-            switch (node.Position)
-            {
-                case Position.Window:
-                    if (node.list == null)
-                    {
-                        this.windowLru.AddLast(node);
-                    }
-                    else
-                    {
-                        this.windowLru.MoveToEnd(node);
-                        this.metrics.updatedCount++;
-                    }
-                    break;
-                case Position.Probation:
-                    PromoteProbation(node);
-                    this.metrics.updatedCount++;
-                    break;
-                case Position.Protected:
-                    this.protectedLru.MoveToEnd(node);
-                    this.metrics.updatedCount++;
-                    break;
-            }
-        }
-
-        private void PromoteProbation(LfuNode<K, V> node)
+                return;
+            }
+
+            bool lockTaken = false;
+            try
+            {
+                Monitor.TryEnter(maintenanceLock, ref lockTaken);
+
+                if (lockTaken)
+                {
+                    int status = this.drainStatus.NonVolatileRead();
+
+                    if (status >= DrainStatus.ProcessingToIdle)
+                    {
+                        return;
+                    }
+
+                    this.drainStatus.VolatileWrite(DrainStatus.ProcessingToIdle);
+                    scheduler.Run(this.drainBuffers);
+                }
+            }
+            finally
+            {
+                if (lockTaken)
+                {
+                    Monitor.Exit(maintenanceLock);
+                }
+            }
+        }
+
+        private void DrainBuffers()
+        {
+            bool done = false;
+
+            while (!done)
+            {
+                lock (maintenanceLock)
+                {
+                    done = Maintenance();
+                }
+
+                // don't run continuous foreground maintenance
+                if (!scheduler.IsBackground)
+                {
+                    done = true;
+                }
+            }
+
+            if (this.drainStatus.VolatileRead() == DrainStatus.Required)
+            {
+                TryScheduleDrain();
+            }
+        }
+
+        private bool Maintenance(LfuNode<K, V> droppedWrite = null)
+        {
+            this.drainStatus.VolatileWrite(DrainStatus.ProcessingToIdle);
+
+            // Note: this is only Span on .NET Core 3.1+, else this is no-op and it is still an array
+            var buffer = this.drainBuffer.AsSpanOrArray();
+
+            // extract to a buffer before doing book keeping work, ~2x faster
+            int readCount = readBuffer.DrainTo(buffer);
+
+            for (int i = 0; i < readCount; i++)
+            {
+                this.cmSketch.Increment(buffer[i].Key);
+            }
+
+            for (int i = 0; i < readCount; i++)
+            {
+                OnAccess(buffer[i]);
+            }
+
+            int writeCount = this.writeBuffer.DrainTo(buffer.AsSpanOrSegment());
+
+            for (int i = 0; i < writeCount; i++)
+            {
+                OnWrite(buffer[i]);
+            }
+
+            // we are done only when both buffers are empty
+            var done = readCount == 0 & writeCount == 0;
+
+            if (droppedWrite != null)
+            {
+                OnWrite(droppedWrite);
+                done = true;
+            }
+
+            EvictEntries();
+            this.capacity.OptimizePartitioning(this.metrics, this.cmSketch.ResetSampleSize);
+            ReFitProtected();
+
+            // Reset to idle if either
+            // 1. We drained both input buffers (all work done)
+            // 2. or scheduler is foreground (since don't run continuously on the foreground)
+            if ((done || !scheduler.IsBackground) &&
+                (this.drainStatus.NonVolatileRead() != DrainStatus.ProcessingToIdle ||
+                !this.drainStatus.Cas(DrainStatus.ProcessingToIdle, DrainStatus.Idle)))
+            {
+                this.drainStatus.NonVolatileWrite(DrainStatus.Required);
+            }
+
+            return done;
+        }
+
+        private void OnAccess(LfuNode<K, V> node)
+        {
+            // there was a cache hit even if the item was removed or is not yet added.
+            this.metrics.requestHitCount++;
+
+            // Node is added to read buffer while it is removed by maintenance, or it is read before it has been added.
+            if (node.list == null)
+            {
+                return;
+            }
+
+            switch (node.Position)
+            {
+                case Position.Window:
+                    this.windowLru.MoveToEnd(node); 
+                    break;
+                case Position.Probation:
+                    PromoteProbation(node); 
+                    break;
+                case Position.Protected:
+                    this.protectedLru.MoveToEnd(node);
+                    break;
+            }
+        }
+
+        private void OnWrite(LfuNode<K, V> node)
+        {
+            // Nodes can be removed while they are in the write buffer, in which case they should
+            // not be added back into the LRU.
+            if (node.WasRemoved)
+            {
+                node.list?.Remove(node);
+
+                if (!node.WasDeleted)
+                {
+                    // if a write is in the buffer and is then removed in the buffer, it will enter OnWrite twice.
+                    // we mark as deleted to avoid double counting/disposing it
+                    this.metrics.evictedCount++;
+                    Disposer<V>.Dispose(node.Value);
+                    node.WasDeleted = true;
+                }
+
+                return;
+            }
+
+            this.cmSketch.Increment(node.Key);
+
+            // node can already be in one of the queues due to update
+            switch (node.Position)
+            {
+                case Position.Window:
+                    if (node.list == null)
+                    {
+                        this.windowLru.AddLast(node);
+                    }
+                    else
+                    {
+                        this.windowLru.MoveToEnd(node);
+                        this.metrics.updatedCount++;
+                    }
+                    break;
+                case Position.Probation:
+                    PromoteProbation(node);
+                    this.metrics.updatedCount++;
+                    break;
+                case Position.Protected:
+                    this.protectedLru.MoveToEnd(node);
+                    this.metrics.updatedCount++;
+                    break;
+            }
+        }
+
+        private void PromoteProbation(LfuNode<K, V> node)
         {
             if (node.list == null)
             {
@@ -703,316 +703,316 @@ private void PromoteProbation(LfuNode<K, V> node)
                 return;
             }
 
-            this.probationLru.Remove(node);
-            this.protectedLru.AddLast(node);
-            node.Position = Position.Protected;
-
-            // If the protected space exceeds its maximum, the LRU items are demoted to the probation space.
-            if (this.protectedLru.Count > this.capacity.Protected)
-            {
-                var demoted = this.protectedLru.First;
-                this.protectedLru.RemoveFirst();
-
-                demoted.Position = Position.Probation;
-                this.probationLru.AddLast(demoted);
-            }
-        }
-
-        private void EvictEntries()
-        {
-            var candidate = EvictFromWindow();
-            EvictFromMain(candidate);
-        }
-
-        private LfuNode<K, V> EvictFromWindow()
-        {
-            LfuNode<K, V> first = null;
-
-            while (this.windowLru.Count > this.capacity.Window)
-            {
-                var node = this.windowLru.First;
-                this.windowLru.RemoveFirst();
-
-                first ??= node;
-
-                this.probationLru.AddLast(node);
-                node.Position = Position.Probation;
-            }
-
-            return first;
-        }
-
-        private ref struct EvictIterator
-        {
-            private readonly CmSketch<K> sketch;
-            public LfuNode<K, V> node;
-            public int freq;
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public EvictIterator(CmSketch<K> sketch, LfuNode<K, V> node)
-            {
-                this.sketch = sketch;
-                this.node = node;
-                freq = node == null ? -1 : sketch.EstimateFrequency(node.Key);
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void Next()
-            {
-                node = node.Next;
-
-                if (node != null)
-                {
-                    freq = sketch.EstimateFrequency(node.Key);
-                }
-            }
-        }
-
-        private void EvictFromMain(LfuNode<K, V> candidateNode)
-        {
-            var victim = new EvictIterator(this.cmSketch, this.probationLru.First); // victims are LRU position in probation
-            var candidate = new EvictIterator(this.cmSketch, candidateNode);
-
-            // first pass: admit candidates
-            while (this.windowLru.Count + this.probationLru.Count + this.protectedLru.Count > this.Capacity)
-            {
-                // bail when we run out of options
-                if (candidate.node == null | victim.node == null)
-                {
-                    break;
-                }
-
-                if (victim.node == candidate.node)
-                {
-                    Evict(candidate.node);
-                    break;
-                }
-
-                // Evict the entry with the lowest frequency
-                if (candidate.freq > victim.freq)
-                {
-                    var evictee = victim.node;
-
-                    // victim is initialized to first, and iterates forwards
-                    victim.Next();
-                    candidate.Next();
-
-                    Evict(evictee);
-                }
-                else
-                {
-                    var evictee = candidate.node;
-
-                    // candidate is initialized to first cand, and iterates forwards
-                    candidate.Next();
-
-                    Evict(evictee);
-                }
-            }
-
-            // 2nd pass: remove probation items in LRU order, evict lowest frequency
-            while (this.windowLru.Count + this.probationLru.Count + this.protectedLru.Count > this.Capacity)
-            {
-                var victim1 = this.probationLru.First;
-                var victim2 = victim1.Next;
-
-                if (AdmitCandidate(victim1.Key, victim2.Key))
-                {
-                    Evict(victim2);
-                }
-                else
-                {
-                    Evict(victim1);
-                }
-            }
-        }
-
-        private bool AdmitCandidate(K candidateKey, K victimKey)
-        {
-            int victimFreq = this.cmSketch.EstimateFrequency(victimKey);
-            int candidateFreq = this.cmSketch.EstimateFrequency(candidateKey);
-
-            //var (victimFreq, candidateFreq) = this.cmSketch.EstimateFrequency(victimKey, candidateKey);
-
-            // TODO: random factor when candidate freq < 5
-            return candidateFreq > victimFreq;
-        }
-
-        private void Evict(LfuNode<K, V> evictee)
-        {
-            this.dictionary.TryRemove(evictee.Key, out var _);
-            evictee.list.Remove(evictee);
-            Disposer<V>.Dispose(evictee.Value);
-            this.metrics.evictedCount++;
-        }
-
-        private void ReFitProtected()
-        {
-            // If hill climbing decreased protected, there may be too many items
-            // - demote overflow to probation.
-            while (this.protectedLru.Count > this.capacity.Protected)
-            {
-                var demoted = this.protectedLru.First;
-                this.protectedLru.RemoveFirst();
-
-                demoted.Position = Position.Probation;
-                this.probationLru.AddLast(demoted);
-            }
-        }
-
-        [DebuggerDisplay("{Format(),nq}")]
-        private class DrainStatus
-        {
-            public const int Idle = 0;
-            public const int Required = 1;
-            public const int ProcessingToIdle = 2;
-            public const int ProcessingToRequired = 3;
-
-            private PaddedInt drainStatus; // mutable struct, don't mark readonly
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool ShouldDrain(bool delayable)
-            {
-                int status = this.NonVolatileRead();
-                return status switch
-                {
-                    Idle => !delayable,
-                    Required => true,
-                    ProcessingToIdle or ProcessingToRequired => false,
-                    _ => false,// not reachable
-                };
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void VolatileWrite(int newStatus)
-            { 
-                Volatile.Write(ref this.drainStatus.Value, newStatus);
+            this.probationLru.Remove(node);
+            this.protectedLru.AddLast(node);
+            node.Position = Position.Protected;
+
+            // If the protected space exceeds its maximum, the LRU items are demoted to the probation space.
+            if (this.protectedLru.Count > this.capacity.Protected)
+            {
+                var demoted = this.protectedLru.First;
+                this.protectedLru.RemoveFirst();
+
+                demoted.Position = Position.Probation;
+                this.probationLru.AddLast(demoted);
+            }
+        }
+
+        private void EvictEntries()
+        {
+            var candidate = EvictFromWindow();
+            EvictFromMain(candidate);
+        }
+
+        private LfuNode<K, V> EvictFromWindow()
+        {
+            LfuNode<K, V> first = null;
+
+            while (this.windowLru.Count > this.capacity.Window)
+            {
+                var node = this.windowLru.First;
+                this.windowLru.RemoveFirst();
+
+                first ??= node;
+
+                this.probationLru.AddLast(node);
+                node.Position = Position.Probation;
+            }
+
+            return first;
+        }
+
+        private ref struct EvictIterator
+        {
+            private readonly CmSketch<K> sketch;
+            public LfuNode<K, V> node;
+            public int freq;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public EvictIterator(CmSketch<K> sketch, LfuNode<K, V> node)
+            {
+                this.sketch = sketch;
+                this.node = node;
+                freq = node == null ? -1 : sketch.EstimateFrequency(node.Key);
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void Next()
+            {
+                node = node.Next;
+
+                if (node != null)
+                {
+                    freq = sketch.EstimateFrequency(node.Key);
+                }
+            }
+        }
+
+        private void EvictFromMain(LfuNode<K, V> candidateNode)
+        {
+            var victim = new EvictIterator(this.cmSketch, this.probationLru.First); // victims are LRU position in probation
+            var candidate = new EvictIterator(this.cmSketch, candidateNode);
+
+            // first pass: admit candidates
+            while (this.windowLru.Count + this.probationLru.Count + this.protectedLru.Count > this.Capacity)
+            {
+                // bail when we run out of options
+                if (candidate.node == null | victim.node == null)
+                {
+                    break;
+                }
+
+                if (victim.node == candidate.node)
+                {
+                    Evict(candidate.node);
+                    break;
+                }
+
+                // Evict the entry with the lowest frequency
+                if (candidate.freq > victim.freq)
+                {
+                    var evictee = victim.node;
+
+                    // victim is initialized to first, and iterates forwards
+                    victim.Next();
+                    candidate.Next();
+
+                    Evict(evictee);
+                }
+                else
+                {
+                    var evictee = candidate.node;
+
+                    // candidate is initialized to first cand, and iterates forwards
+                    candidate.Next();
+
+                    Evict(evictee);
+                }
+            }
+
+            // 2nd pass: remove probation items in LRU order, evict lowest frequency
+            while (this.windowLru.Count + this.probationLru.Count + this.protectedLru.Count > this.Capacity)
+            {
+                var victim1 = this.probationLru.First;
+                var victim2 = victim1.Next;
+
+                if (AdmitCandidate(victim1.Key, victim2.Key))
+                {
+                    Evict(victim2);
+                }
+                else
+                {
+                    Evict(victim1);
+                }
+            }
+        }
+
+        private bool AdmitCandidate(K candidateKey, K victimKey)
+        {
+            int victimFreq = this.cmSketch.EstimateFrequency(victimKey);
+            int candidateFreq = this.cmSketch.EstimateFrequency(candidateKey);
+
+            //var (victimFreq, candidateFreq) = this.cmSketch.EstimateFrequency(victimKey, candidateKey);
+
+            // TODO: random factor when candidate freq < 5
+            return candidateFreq > victimFreq;
+        }
+
+        private void Evict(LfuNode<K, V> evictee)
+        {
+            this.dictionary.TryRemove(evictee.Key, out var _);
+            evictee.list.Remove(evictee);
+            Disposer<V>.Dispose(evictee.Value);
+            this.metrics.evictedCount++;
+        }
+
+        private void ReFitProtected()
+        {
+            // If hill climbing decreased protected, there may be too many items
+            // - demote overflow to probation.
+            while (this.protectedLru.Count > this.capacity.Protected)
+            {
+                var demoted = this.protectedLru.First;
+                this.protectedLru.RemoveFirst();
+
+                demoted.Position = Position.Probation;
+                this.probationLru.AddLast(demoted);
+            }
+        }
+
+        [DebuggerDisplay("{Format(),nq}")]
+        private class DrainStatus
+        {
+            public const int Idle = 0;
+            public const int Required = 1;
+            public const int ProcessingToIdle = 2;
+            public const int ProcessingToRequired = 3;
+
+            private PaddedInt drainStatus; // mutable struct, don't mark readonly
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public bool ShouldDrain(bool delayable)
+            {
+                int status = this.NonVolatileRead();
+                return status switch
+                {
+                    Idle => !delayable,
+                    Required => true,
+                    ProcessingToIdle or ProcessingToRequired => false,
+                    _ => false,// not reachable
+                };
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void VolatileWrite(int newStatus)
+            { 
+                Volatile.Write(ref this.drainStatus.Value, newStatus);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public void NonVolatileWrite(int newStatus)
-            {
-                this.drainStatus.Value = newStatus;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public bool Cas(int oldStatus, int newStatus)
-            { 
-                return Interlocked.CompareExchange(ref this.drainStatus.Value, newStatus, oldStatus) == oldStatus;
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int VolatileRead()
-            {
-                return Volatile.Read(ref this.drainStatus.Value);
+            public void NonVolatileWrite(int newStatus)
+            {
+                this.drainStatus.Value = newStatus;
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public int NonVolatileRead()
-            {
-                return this.drainStatus.Value;
-            }
-
-            [ExcludeFromCodeCoverage]
-            internal string Format()
-            {
-                switch (this.drainStatus.Value)
-                {
-                    case Idle:
-                        return "Idle";
-                    case Required:
-                        return "Required";
-                    case ProcessingToIdle:
-                        return "ProcessingToIdle";
-                    case ProcessingToRequired:
-                        return "ProcessingToRequired"; ;
-                }
-
-                return "Invalid state";
-            }
-        }
-
-        [DebuggerDisplay("Hit = {Hits}, Miss = {Misses}, Upd = {Updated}, Evict = {Evicted}")]
-        internal class CacheMetrics : ICacheMetrics
-        {
-            public long requestHitCount;
-            public Counter requestMissCount = new();
-            public long updatedCount;
-            public long evictedCount;
-
-            public double HitRatio => (double)requestHitCount / (double)Total;
-
-            public long Total => requestHitCount + requestMissCount.Count();
-
-            public long Hits => requestHitCount;
-
-            public long Misses => requestMissCount.Count();
-
-            public long Updated => updatedCount;
-
-            public long Evicted => evictedCount;
-        }
-
-#if DEBUG
-        /// <summary>
-        /// Format the LFU as a string by converting all the keys to strings.
-        /// </summary>
-        /// <returns>The LFU formatted as a string.</returns>
-        public string FormatLfuString()
-        {
-            var sb = new StringBuilder();
-
-            sb.Append("W [");
-            sb.Append(string.Join(",", this.windowLru.Select(n => n.Key.ToString())));
-            sb.Append("] Protected [");
-            sb.Append(string.Join(",", this.protectedLru.Select(n => n.Key.ToString())));
-            sb.Append("] Probation [");
-            sb.Append(string.Join(",", this.probationLru.Select(n => n.Key.ToString())));
-            sb.Append("]");
-
-            return sb.ToString();
-        }
-#endif
-
-        [ExcludeFromCodeCoverage]
-        internal class LfuDebugView
-        {
-            private readonly ConcurrentLfu<K, V> lfu;
-
-            public LfuDebugView(ConcurrentLfu<K, V> lfu)
-            {
-                this.lfu = lfu;
-            }
-
-            public string Maintenance => lfu.drainStatus.Format();
-
-            public ICacheMetrics Metrics => lfu.metrics;
-
-            public StripedMpscBuffer<LfuNode<K, V>> ReadBuffer => this.lfu.readBuffer;
-
-            public MpscBoundedBuffer<LfuNode<K, V>> WriteBuffer => this.lfu.writeBuffer;
-
-            public KeyValuePair<K, V>[] Items
-            {
-                get
-                {
-                    var items = new KeyValuePair<K, V>[lfu.Count];
-
-                    int index = 0;
-                    foreach (var kvp in lfu)
-                    {
-                        items[index++] = kvp;
-                    }
-                    return items;
-                }
-            }
-        }
-    }
-
-    // Explicit layout cannot be a generic class member
-    [StructLayout(LayoutKind.Explicit, Size = 2 * Padding.CACHE_LINE_SIZE)]
-    internal struct PaddedInt
-    {
-        [FieldOffset(1 * Padding.CACHE_LINE_SIZE)] public int Value;
-    }
-}
+            public bool Cas(int oldStatus, int newStatus)
+            { 
+                return Interlocked.CompareExchange(ref this.drainStatus.Value, newStatus, oldStatus) == oldStatus;
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public int VolatileRead()
+            {
+                return Volatile.Read(ref this.drainStatus.Value);
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public int NonVolatileRead()
+            {
+                return this.drainStatus.Value;
+            }
+
+            [ExcludeFromCodeCoverage]
+            internal string Format()
+            {
+                switch (this.drainStatus.Value)
+                {
+                    case Idle:
+                        return "Idle";
+                    case Required:
+                        return "Required";
+                    case ProcessingToIdle:
+                        return "ProcessingToIdle";
+                    case ProcessingToRequired:
+                        return "ProcessingToRequired"; ;
+                }
+
+                return "Invalid state";
+            }
+        }
+
+        [DebuggerDisplay("Hit = {Hits}, Miss = {Misses}, Upd = {Updated}, Evict = {Evicted}")]
+        internal class CacheMetrics : ICacheMetrics
+        {
+            public long requestHitCount;
+            public Counter requestMissCount = new();
+            public long updatedCount;
+            public long evictedCount;
+
+            public double HitRatio => (double)requestHitCount / (double)Total;
+
+            public long Total => requestHitCount + requestMissCount.Count();
+
+            public long Hits => requestHitCount;
+
+            public long Misses => requestMissCount.Count();
+
+            public long Updated => updatedCount;
+
+            public long Evicted => evictedCount;
+        }
+
+#if DEBUG
+        /// <summary>
+        /// Format the LFU as a string by converting all the keys to strings.
+        /// </summary>
+        /// <returns>The LFU formatted as a string.</returns>
+        public string FormatLfuString()
+        {
+            var sb = new StringBuilder();
+
+            sb.Append("W [");
+            sb.Append(string.Join(",", this.windowLru.Select(n => n.Key.ToString())));
+            sb.Append("] Protected [");
+            sb.Append(string.Join(",", this.protectedLru.Select(n => n.Key.ToString())));
+            sb.Append("] Probation [");
+            sb.Append(string.Join(",", this.probationLru.Select(n => n.Key.ToString())));
+            sb.Append("]");
+
+            return sb.ToString();
+        }
+#endif
+
+        [ExcludeFromCodeCoverage]
+        internal class LfuDebugView
+        {
+            private readonly ConcurrentLfu<K, V> lfu;
+
+            public LfuDebugView(ConcurrentLfu<K, V> lfu)
+            {
+                this.lfu = lfu;
+            }
+
+            public string Maintenance => lfu.drainStatus.Format();
+
+            public ICacheMetrics Metrics => lfu.metrics;
+
+            public StripedMpscBuffer<LfuNode<K, V>> ReadBuffer => this.lfu.readBuffer;
+
+            public MpscBoundedBuffer<LfuNode<K, V>> WriteBuffer => this.lfu.writeBuffer;
+
+            public KeyValuePair<K, V>[] Items
+            {
+                get
+                {
+                    var items = new KeyValuePair<K, V>[lfu.Count];
+
+                    int index = 0;
+                    foreach (var kvp in lfu)
+                    {
+                        items[index++] = kvp;
+                    }
+                    return items;
+                }
+            }
+        }
+    }
+
+    // Explicit layout cannot be a generic class member
+    [StructLayout(LayoutKind.Explicit, Size = 2 * Padding.CACHE_LINE_SIZE)]
+    internal struct PaddedInt
+    {
+        [FieldOffset(1 * Padding.CACHE_LINE_SIZE)] public int Value;
+    }
+}
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
index 1216f330..bb69b33a 100644
--- a/BitFaster.Caching/Lru/ClassicLru.cs
+++ b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -1,250 +1,250 @@
-using System;
-using System.Collections;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace BitFaster.Caching.Lru
-{
-    /// <summary>
-    /// LRU implementation where Lookup operations are backed by a ConcurrentDictionary and the LRU list is protected
-    /// by a global lock. All list operations performed within the lock are fast O(1) operations. 
-    /// </summary>
-    /// <remarks>
-    /// Due to the lock protecting list operations, this class may suffer lock contention under heavy load.
-    /// </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>, IAsyncCache<K, V>, IBoundedPolicy, IEnumerable<KeyValuePair<K, V>>
-    {
-        private readonly int capacity;
-        private readonly ConcurrentDictionary<K, LinkedListNode<LruItem>> dictionary;
-        private readonly LinkedList<LruItem> linkedList = new();
-
-        private readonly CacheMetrics metrics = new();
-        private readonly CachePolicy policy;
-
-        /// <summary>
-        /// Initializes a new instance of the ClassicLru class with the specified capacity.
-        /// </summary>
-        /// <param name="capacity"></param>
-        public ClassicLru(int capacity)
-            : this(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a new instance of the ClassicLru class with the specified concurrencyLevel, capacity and equality comparer.
-        /// </summary>
-        /// <param name="concurrencyLevel">The concurrency level.</param>
-        /// <param name="capacity">The capacity.</param>
-        /// <param name="comparer">The key comparer</param>
-        /// <exception cref="ArgumentOutOfRangeException"></exception>
-        /// <exception cref="ArgumentNullException"></exception>
-        public ClassicLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
-        {
-            if (capacity < 3)
-                Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
-
-            if (comparer == null)
-                Throw.ArgNull(ExceptionArgument.comparer);
-
-            this.capacity = capacity;
-            int dictionaryCapacity = ConcurrentDictionarySize.Estimate(capacity);
-            this.dictionary = new ConcurrentDictionary<K, LinkedListNode<LruItem>>(concurrencyLevel, dictionaryCapacity, comparer);
-            this.policy = new CachePolicy(new Optional<IBoundedPolicy>(this), Optional<ITimePolicy>.None());
-        }
-
-        ///<inheritdoc/>
-        public int Count => this.linkedList.Count;
-
-        ///<inheritdoc/>
-        public int Capacity => this.capacity;
-
-        ///<inheritdoc/>
-        public Optional<ICacheMetrics> Metrics => new(this.metrics);
-
-        ///<inheritdoc/>
-        public Optional<ICacheEvents<K, V>> Events => Optional<ICacheEvents<K, V>>.None();
-
-        ///<inheritdoc/>
-        public CachePolicy Policy => this.policy;
-
-        /// <summary>
-        /// Gets a collection containing the keys in the cache.
-        /// </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)
-        {
-            Interlocked.Increment(ref this.metrics.requestTotalCount);
-
-            if (dictionary.TryGetValue(key, out var node))
-            {
-                LockAndMoveToEnd(node);
-                Interlocked.Increment(ref this.metrics.requestHitCount);
-                value = node.Value.Value;
-                return true;
-            }
-
-            value = default;
-            return false;
-        }
-
-        private bool TryAdd(K key, V value)
-        {
-            var node = new LinkedListNode<LruItem>(new LruItem(key, value));
-
-            if (this.dictionary.TryAdd(key, node))
-            {
-                LinkedListNode<LruItem> first = null;
-
-                lock (this.linkedList)
-                {
-                    if (linkedList.Count >= capacity)
-                    {
-                        first = linkedList.First;
-                        linkedList.RemoveFirst();
-                    }
-
-                    linkedList.AddLast(node);
-                }
-
-                // Remove from the dictionary outside the lock. This means that the dictionary at this moment
-                // contains an item that is not in the linked list. If another thread fetches this item, 
-                // LockAndMoveToEnd will ignore it, since it is detached. This means we potentially 'lose' an 
-                // item just as it was about to move to the back of the LRU list and be preserved. The next request
-                // for the same key will be a miss. Dictionary and list are eventually consistent.
-                // However, all operations inside the lock are extremely fast, so contention is minimized.
-                if (first != null)
-                {
-                    dictionary.TryRemove(first.Value.Key, out var removed);
-
-                    Interlocked.Increment(ref this.metrics.evictedCount);
-                    Disposer<V>.Dispose(removed.Value.Value);
-                }
-
-                return true;
-            }
-
-            return false;
-        }
-
-        ///<inheritdoc/>
-        public V GetOrAdd(K key, Func<K, V> valueFactory)
-        {
-            if (this.TryGet(key, out var value))
-            {
-                return value;
-            }
-
-            value = valueFactory(key);
-
-            if (TryAdd(key, value))
-            {
-                return value;
-            }
-
-            return this.GetOrAdd(key, valueFactory);
-        }
-
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
-        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
-        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
-        /// in the cache, or the new value if the key was not in the cache.</returns>
-        public V GetOrAdd<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument)
-        {
-            if (this.TryGet(key, out var value))
-            {
-                return value;
-            }
-
-            value = valueFactory(key, factoryArgument);
-
-            if (TryAdd(key, value))
-            {
-                return value;
-            }
-
-            return this.GetOrAdd(key, valueFactory, factoryArgument);
-        }
-
-        ///<inheritdoc/>
-        public async ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
-        {
-            if (this.TryGet(key, out var value))
-            {
-                return value;
-            }
-
-            value = await valueFactory(key).ConfigureAwait(false);
-
-            if (TryAdd(key, value))
-            {
-                return value;
-            }
-
-            return await this.GetOrAddAsync(key, valueFactory).ConfigureAwait(false);
-        }
-
-        /// <summary>
-        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
-        /// existing value if the key already exists.
-        /// </summary>
-        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
-        /// <param name="key">The key of the element to add.</param>
-        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
-        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
-        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
-        public async ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valueFactory, TArg factoryArgument)
-        {
-            if (this.TryGet(key, out var value))
-            {
-                return value;
-            }
-
-            value = await valueFactory(key, factoryArgument).ConfigureAwait(false);
-
-            if (TryAdd(key, value))
-            {
-                return value;
-            }
-
-            return await this.GetOrAddAsync(key, valueFactory, factoryArgument).ConfigureAwait(false);
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BitFaster.Caching.Lru
+{
+    /// <summary>
+    /// LRU implementation where Lookup operations are backed by a ConcurrentDictionary and the LRU list is protected
+    /// by a global lock. All list operations performed within the lock are fast O(1) operations. 
+    /// </summary>
+    /// <remarks>
+    /// Due to the lock protecting list operations, this class may suffer lock contention under heavy load.
+    /// </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>, IAsyncCache<K, V>, IBoundedPolicy, IEnumerable<KeyValuePair<K, V>>
+    {
+        private readonly int capacity;
+        private readonly ConcurrentDictionary<K, LinkedListNode<LruItem>> dictionary;
+        private readonly LinkedList<LruItem> linkedList = new();
+
+        private readonly CacheMetrics metrics = new();
+        private readonly CachePolicy policy;
+
+        /// <summary>
+        /// Initializes a new instance of the ClassicLru class with the specified capacity.
+        /// </summary>
+        /// <param name="capacity"></param>
+        public ClassicLru(int capacity)
+            : this(Defaults.ConcurrencyLevel, capacity, EqualityComparer<K>.Default)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the ClassicLru class with the specified concurrencyLevel, capacity and equality comparer.
+        /// </summary>
+        /// <param name="concurrencyLevel">The concurrency level.</param>
+        /// <param name="capacity">The capacity.</param>
+        /// <param name="comparer">The key comparer</param>
+        /// <exception cref="ArgumentOutOfRangeException"></exception>
+        /// <exception cref="ArgumentNullException"></exception>
+        public ClassicLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
+        {
+            if (capacity < 3)
+                Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
+
+            if (comparer == null)
+                Throw.ArgNull(ExceptionArgument.comparer);
+
+            this.capacity = capacity;
+            int dictionaryCapacity = ConcurrentDictionarySize.Estimate(capacity);
+            this.dictionary = new ConcurrentDictionary<K, LinkedListNode<LruItem>>(concurrencyLevel, dictionaryCapacity, comparer);
+            this.policy = new CachePolicy(new Optional<IBoundedPolicy>(this), Optional<ITimePolicy>.None());
+        }
+
+        ///<inheritdoc/>
+        public int Count => this.linkedList.Count;
+
+        ///<inheritdoc/>
+        public int Capacity => this.capacity;
+
+        ///<inheritdoc/>
+        public Optional<ICacheMetrics> Metrics => new(this.metrics);
+
+        ///<inheritdoc/>
+        public Optional<ICacheEvents<K, V>> Events => Optional<ICacheEvents<K, V>>.None();
+
+        ///<inheritdoc/>
+        public CachePolicy Policy => this.policy;
+
+        /// <summary>
+        /// Gets a collection containing the keys in the cache.
+        /// </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)
+        {
+            Interlocked.Increment(ref this.metrics.requestTotalCount);
+
+            if (dictionary.TryGetValue(key, out var node))
+            {
+                LockAndMoveToEnd(node);
+                Interlocked.Increment(ref this.metrics.requestHitCount);
+                value = node.Value.Value;
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+
+        private bool TryAdd(K key, V value)
+        {
+            var node = new LinkedListNode<LruItem>(new LruItem(key, value));
+
+            if (this.dictionary.TryAdd(key, node))
+            {
+                LinkedListNode<LruItem> first = null;
+
+                lock (this.linkedList)
+                {
+                    if (linkedList.Count >= capacity)
+                    {
+                        first = linkedList.First;
+                        linkedList.RemoveFirst();
+                    }
+
+                    linkedList.AddLast(node);
+                }
+
+                // Remove from the dictionary outside the lock. This means that the dictionary at this moment
+                // contains an item that is not in the linked list. If another thread fetches this item, 
+                // LockAndMoveToEnd will ignore it, since it is detached. This means we potentially 'lose' an 
+                // item just as it was about to move to the back of the LRU list and be preserved. The next request
+                // for the same key will be a miss. Dictionary and list are eventually consistent.
+                // However, all operations inside the lock are extremely fast, so contention is minimized.
+                if (first != null)
+                {
+                    dictionary.TryRemove(first.Value.Key, out var removed);
+
+                    Interlocked.Increment(ref this.metrics.evictedCount);
+                    Disposer<V>.Dispose(removed.Value.Value);
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        ///<inheritdoc/>
+        public V GetOrAdd(K key, Func<K, V> valueFactory)
+        {
+            if (this.TryGet(key, out var value))
+            {
+                return value;
+            }
+
+            value = valueFactory(key);
+
+            if (TryAdd(key, value))
+            {
+                return value;
+            }
+
+            return this.GetOrAdd(key, valueFactory);
+        }
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
+        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
+        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
+        /// in the cache, or the new value if the key was not in the cache.</returns>
+        public V GetOrAdd<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument)
+        {
+            if (this.TryGet(key, out var value))
+            {
+                return value;
+            }
+
+            value = valueFactory(key, factoryArgument);
+
+            if (TryAdd(key, value))
+            {
+                return value;
+            }
+
+            return this.GetOrAdd(key, valueFactory, factoryArgument);
+        }
+
+        ///<inheritdoc/>
+        public async ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
+        {
+            if (this.TryGet(key, out var value))
+            {
+                return value;
+            }
+
+            value = await valueFactory(key).ConfigureAwait(false);
+
+            if (TryAdd(key, value))
+            {
+                return value;
+            }
+
+            return await this.GetOrAddAsync(key, valueFactory).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
+        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
+        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
+        public async ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valueFactory, TArg factoryArgument)
+        {
+            if (this.TryGet(key, out var value))
+            {
+                return value;
+            }
+
+            value = await valueFactory(key, factoryArgument).ConfigureAwait(false);
+
+            if (TryAdd(key, value))
+            {
+                return value;
+            }
+
+            return await this.GetOrAddAsync(key, valueFactory, factoryArgument).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Attempts to remove the specified key value pair.
         /// </summary>
         /// <param name="item">The item to remove.</param>
-        /// <returns>true if the item was removed successfully; otherwise, false.</returns>
-        public bool TryRemove(KeyValuePair<K, V> item)
-        {
+        /// <returns>true if the item was removed successfully; otherwise, false.</returns>
+        public bool TryRemove(KeyValuePair<K, V> item)
+        {
             if (this.dictionary.TryGetValue(item.Key, out var node))
             {
                 if (EqualityComparer<V>.Default.Equals(node.Value.Value, item.Value))
@@ -258,13 +258,13 @@ public bool TryRemove(KeyValuePair<K, V> item)
                     if (((ICollection<KeyValuePair<K, LinkedListNode<LruItem>>>)this.dictionary).Remove(kvp))
 #endif
                     {
-                        OnRemove(node);
-                        return true;
+                        OnRemove(node);
+                        return true;
                     }
                 }
             }
 
-            return false;
+            return false;
         }
 
         /// <summary>
@@ -272,25 +272,25 @@ public bool TryRemove(KeyValuePair<K, V> item)
         /// </summary>
         /// <param name="key">The key of the element to remove.</param>
         /// <param name="value">When this method returns, contains the object removed, or the default value of the value type if key does not exist.</param>
-        /// <returns>true if the object was removed successfully; otherwise, false.</returns>
-        public bool TryRemove(K key, out V value)
-        {
-            if (dictionary.TryRemove(key, out var node))
-            {
-                OnRemove(node);
-                value = node.Value.Value;
-                return true;
+        /// <returns>true if the object was removed successfully; otherwise, false.</returns>
+        public bool TryRemove(K key, out V value)
+        {
+            if (dictionary.TryRemove(key, out var node))
+            {
+                OnRemove(node);
+                value = node.Value.Value;
+                return true;
             }
 
-            value = default;
+            value = default;
             return false;
 
-        }
-
-        ///<inheritdoc/>
-        public bool TryRemove(K key)
-        {
-            return TryRemove(key, out var _);
+        }
+
+        ///<inheritdoc/>
+        public bool TryRemove(K key)
+        {
+            return TryRemove(key, out var _);
         }
 
         private void OnRemove(LinkedListNode<LruItem> node)
@@ -309,185 +309,185 @@ private void OnRemove(LinkedListNode<LruItem> node)
                 }
             }
 
-            Disposer<V>.Dispose(node.Value.Value);
-        }
-
-        ///<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;
-                Interlocked.Increment(ref this.metrics.updatedCount);
-                return true;
-            }
-
-            return false;
-        }
-
-        ///<inheritdoc/>
-        ///<remarks>Note: Updates to existing items do not affect LRU order. Added items are at the top of the LRU.</remarks>
-        public void AddOrUpdate(K key, V value)
-        {
-            // first, try to update
-            if (this.dictionary.TryGetValue(key, out var existingNode))
-            {
-                existingNode.Value.Value = value;
-                Interlocked.Increment(ref this.metrics.updatedCount);
-                return;
-            }
-
-            // then try add
-            var newNode = new LinkedListNode<LruItem>(new LruItem(key, value));
-
-            if (this.dictionary.TryAdd(key, newNode))
-            {
-                LinkedListNode<LruItem> first = null;
-
-                lock (this.linkedList)
-                {
-                    if (linkedList.Count >= capacity)
-                    {
-                        first = linkedList.First;
-                        linkedList.RemoveFirst();
-                    }
-
-                    linkedList.AddLast(newNode);
-                }
-
-                // Remove from the dictionary outside the lock. This means that the dictionary at this moment
-                // contains an item that is not in the linked list. If another thread fetches this item, 
-                // LockAndMoveToEnd will ignore it, since it is detached. This means we potentially 'lose' an 
-                // item just as it was about to move to the back of the LRU list and be preserved. The next request
-                // for the same key will be a miss. Dictionary and list are eventually consistent.
-                // However, all operations inside the lock are extremely fast, so contention is minimized.
-                if (first != null)
-                {
-                    dictionary.TryRemove(first.Value.Key, out var removed);
-
-                    Interlocked.Increment(ref this.metrics.evictedCount);
-                    Disposer<V>.Dispose(removed.Value.Value);
-                }
-
-                return;
-            }
-
-            // if both update and add failed there was a race, try again
-            AddOrUpdate(key, value);
-        }
-
-        ///<inheritdoc/>
-        public void Clear()
-        {
-            // take a key snapshot
-            var keys = this.dictionary.Keys.ToList();
-
-            // remove all keys in the snapshot - this correctly handles disposable values
-            foreach (var key in keys)
-            {
-                TryRemove(key);
-            }
-        }
-
-        ///<inheritdoc/>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="itemCount"/> is less than 0./</exception>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="itemCount"/> is greater than capacity./</exception>
-        public void Trim(int itemCount)
-        {
-            if (itemCount < 1 || itemCount > this.capacity)
-            {
-                Throw.ArgOutOfRange(nameof(itemCount), "itemCount must be greater than or equal to one, and less than the capacity of the cache.");
-            }
-
-            for (int i = 0; i < itemCount; i++)
-            {
-                LinkedListNode<LruItem> first = null;
-
-                lock (this.linkedList)
-                {
-                    if (linkedList.Count > 0)
-                    {
-                        first = linkedList.First;
-                        linkedList.RemoveFirst();
-                    }
-                }
-
-                if (first != null)
-                {
-                    dictionary.TryRemove(first.Value.Key, out var removed);
-                    Disposer<V>.Dispose(removed.Value.Value);
-                }
-            }
-        }
-
-        // 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)
-        {
-            // If the node has already been removed from the list, ignore.
-            // E.g. thread A reads x from the dictionary. Thread B adds a new item, removes x from 
-            // the List & Dictionary. Now thread A will try to move x to the end of the list.
-            if (node.List == null)
-            {
-                return;
-            }
-
-            lock (this.linkedList)
-            {
-                if (node.List == null)
-                {
-                    return;
-                }
-
-                linkedList.Remove(node);
-                linkedList.AddLast(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)
-            {
-                Key = k;
-                Value = v;
-            }
-
-            public K Key { get; }
-
-            public V Value { get; set; }
-        }
-
-        private class CacheMetrics : ICacheMetrics
-        {
-            public long requestHitCount;
-            public long requestTotalCount;
-            public long updatedCount;
-            public long evictedCount;
-
-            public double HitRatio => (double)requestHitCount / (double)requestTotalCount;
-
-            public long Total => requestTotalCount;
-
-            public long Hits => requestHitCount;
-
-            public long Misses => requestTotalCount - requestHitCount;
-
-            public long Evicted => evictedCount;
-
-            public long Updated => updatedCount;
-        }
-    }
-}
+            Disposer<V>.Dispose(node.Value.Value);
+        }
+
+        ///<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;
+                Interlocked.Increment(ref this.metrics.updatedCount);
+                return true;
+            }
+
+            return false;
+        }
+
+        ///<inheritdoc/>
+        ///<remarks>Note: Updates to existing items do not affect LRU order. Added items are at the top of the LRU.</remarks>
+        public void AddOrUpdate(K key, V value)
+        {
+            // first, try to update
+            if (this.dictionary.TryGetValue(key, out var existingNode))
+            {
+                existingNode.Value.Value = value;
+                Interlocked.Increment(ref this.metrics.updatedCount);
+                return;
+            }
+
+            // then try add
+            var newNode = new LinkedListNode<LruItem>(new LruItem(key, value));
+
+            if (this.dictionary.TryAdd(key, newNode))
+            {
+                LinkedListNode<LruItem> first = null;
+
+                lock (this.linkedList)
+                {
+                    if (linkedList.Count >= capacity)
+                    {
+                        first = linkedList.First;
+                        linkedList.RemoveFirst();
+                    }
+
+                    linkedList.AddLast(newNode);
+                }
+
+                // Remove from the dictionary outside the lock. This means that the dictionary at this moment
+                // contains an item that is not in the linked list. If another thread fetches this item, 
+                // LockAndMoveToEnd will ignore it, since it is detached. This means we potentially 'lose' an 
+                // item just as it was about to move to the back of the LRU list and be preserved. The next request
+                // for the same key will be a miss. Dictionary and list are eventually consistent.
+                // However, all operations inside the lock are extremely fast, so contention is minimized.
+                if (first != null)
+                {
+                    dictionary.TryRemove(first.Value.Key, out var removed);
+
+                    Interlocked.Increment(ref this.metrics.evictedCount);
+                    Disposer<V>.Dispose(removed.Value.Value);
+                }
+
+                return;
+            }
+
+            // if both update and add failed there was a race, try again
+            AddOrUpdate(key, value);
+        }
+
+        ///<inheritdoc/>
+        public void Clear()
+        {
+            // take a key snapshot
+            var keys = this.dictionary.Keys.ToList();
+
+            // remove all keys in the snapshot - this correctly handles disposable values
+            foreach (var key in keys)
+            {
+                TryRemove(key);
+            }
+        }
+
+        ///<inheritdoc/>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="itemCount"/> is less than 0./</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="itemCount"/> is greater than capacity./</exception>
+        public void Trim(int itemCount)
+        {
+            if (itemCount < 1 || itemCount > this.capacity)
+            {
+                Throw.ArgOutOfRange(nameof(itemCount), "itemCount must be greater than or equal to one, and less than the capacity of the cache.");
+            }
+
+            for (int i = 0; i < itemCount; i++)
+            {
+                LinkedListNode<LruItem> first = null;
+
+                lock (this.linkedList)
+                {
+                    if (linkedList.Count > 0)
+                    {
+                        first = linkedList.First;
+                        linkedList.RemoveFirst();
+                    }
+                }
+
+                if (first != null)
+                {
+                    dictionary.TryRemove(first.Value.Key, out var removed);
+                    Disposer<V>.Dispose(removed.Value.Value);
+                }
+            }
+        }
+
+        // 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)
+        {
+            // If the node has already been removed from the list, ignore.
+            // E.g. thread A reads x from the dictionary. Thread B adds a new item, removes x from 
+            // the List & Dictionary. Now thread A will try to move x to the end of the list.
+            if (node.List == null)
+            {
+                return;
+            }
+
+            lock (this.linkedList)
+            {
+                if (node.List == null)
+                {
+                    return;
+                }
+
+                linkedList.Remove(node);
+                linkedList.AddLast(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)
+            {
+                Key = k;
+                Value = v;
+            }
+
+            public K Key { get; }
+
+            public V Value { get; set; }
+        }
+
+        private class CacheMetrics : ICacheMetrics
+        {
+            public long requestHitCount;
+            public long requestTotalCount;
+            public long updatedCount;
+            public long evictedCount;
+
+            public double HitRatio => (double)requestHitCount / (double)requestTotalCount;
+
+            public long Total => requestTotalCount;
+
+            public long Hits => requestHitCount;
+
+            public long Misses => requestTotalCount - requestHitCount;
+
+            public long Evicted => evictedCount;
+
+            public long Updated => updatedCount;
+        }
+    }
+}
diff --git a/BitFaster.Caching/Throw.cs b/BitFaster.Caching/Throw.cs
index 10fe2767..7f0aa070 100644
--- a/BitFaster.Caching/Throw.cs
+++ b/BitFaster.Caching/Throw.cs
@@ -1,85 +1,85 @@
-using System;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-
-namespace BitFaster.Caching
-{
-    internal static class Throw
-    {
-#if NETCOREAPP3_0_OR_GREATER
-        [DoesNotReturn]
-#endif
+using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace BitFaster.Caching
+{
+    internal static class Throw
+    {
+#if NETCOREAPP3_0_OR_GREATER
+        [DoesNotReturn]
+#endif
         public static void ArgNull(ExceptionArgument arg) => throw CreateArgumentNullException(arg);
 
-#if NETCOREAPP3_0_OR_GREATER
-        [DoesNotReturn]
-#endif
+#if NETCOREAPP3_0_OR_GREATER
+        [DoesNotReturn]
+#endif
         public static void ArgOutOfRange(string paramName) => throw CreateArgumentOutOfRangeException(paramName);
 
-#if NETCOREAPP3_0_OR_GREATER
-        [DoesNotReturn]
-#endif
-        public static void ArgOutOfRange(string paramName, string message) => throw CreateArgumentOutOfRangeException(paramName, message);
-
-        [ExcludeFromCodeCoverage]
-#if NETCOREAPP3_0_OR_GREATER
-        [DoesNotReturn]
-#endif
+#if NETCOREAPP3_0_OR_GREATER
+        [DoesNotReturn]
+#endif
+        public static void ArgOutOfRange(string paramName, string message) => throw CreateArgumentOutOfRangeException(paramName, message);
+
+        [ExcludeFromCodeCoverage]
+#if NETCOREAPP3_0_OR_GREATER
+        [DoesNotReturn]
+#endif
         public static void InvalidOp(string message) => throw CreateInvalidOperationException(message);
 
-#if NETCOREAPP3_0_OR_GREATER
-        [DoesNotReturn]
-#endif
-        public static void ScopedRetryFailure() => throw CreateScopedRetryFailure();
-
-#if NETCOREAPP3_0_OR_GREATER
-        [DoesNotReturn]
-#endif
-        public static void Disposed<T>() => throw CreateObjectDisposedException<T>();
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private static ArgumentNullException CreateArgumentNullException(ExceptionArgument arg) => new ArgumentNullException(GetArgumentString(arg));
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private static ArgumentOutOfRangeException CreateArgumentOutOfRangeException(string paramName) => new ArgumentOutOfRangeException(paramName);
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private static ArgumentOutOfRangeException CreateArgumentOutOfRangeException(string paramName, string message) => new ArgumentOutOfRangeException(paramName, message);
-
-        [ExcludeFromCodeCoverage]
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private static InvalidOperationException CreateInvalidOperationException(string message) => new InvalidOperationException(message);
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private static InvalidOperationException CreateScopedRetryFailure() => new InvalidOperationException(ScopedCacheDefaults.RetryFailureMessage);
-        
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private static ObjectDisposedException CreateObjectDisposedException<T>() => new ObjectDisposedException(typeof(T).Name);
-
-        [ExcludeFromCodeCoverage]
-        private static string GetArgumentString(ExceptionArgument argument)
-        {
-            switch (argument)
-            {
-                case ExceptionArgument.cache: return nameof(ExceptionArgument.cache);
-                case ExceptionArgument.comparer: return nameof(ExceptionArgument.comparer);
-                case ExceptionArgument.scoped: return nameof(ExceptionArgument.scoped);
-                case ExceptionArgument.capacity: return nameof(ExceptionArgument.capacity);
-                case ExceptionArgument.node: return nameof(ExceptionArgument.node);
-                default:
-                    Debug.Fail("The ExceptionArgument value is not defined.");
-                    return string.Empty;
-            }
-        }
-    }
-
-    internal enum ExceptionArgument
-    {
-        cache,
-        comparer,
-        scoped,
-        capacity,
-        node,
-    }
-}
+#if NETCOREAPP3_0_OR_GREATER
+        [DoesNotReturn]
+#endif
+        public static void ScopedRetryFailure() => throw CreateScopedRetryFailure();
+
+#if NETCOREAPP3_0_OR_GREATER
+        [DoesNotReturn]
+#endif
+        public static void Disposed<T>() => throw CreateObjectDisposedException<T>();
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static ArgumentNullException CreateArgumentNullException(ExceptionArgument arg) => new ArgumentNullException(GetArgumentString(arg));
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static ArgumentOutOfRangeException CreateArgumentOutOfRangeException(string paramName) => new ArgumentOutOfRangeException(paramName);
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static ArgumentOutOfRangeException CreateArgumentOutOfRangeException(string paramName, string message) => new ArgumentOutOfRangeException(paramName, message);
+
+        [ExcludeFromCodeCoverage]
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static InvalidOperationException CreateInvalidOperationException(string message) => new InvalidOperationException(message);
+
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static InvalidOperationException CreateScopedRetryFailure() => new InvalidOperationException(ScopedCacheDefaults.RetryFailureMessage);
+        
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static ObjectDisposedException CreateObjectDisposedException<T>() => new ObjectDisposedException(typeof(T).Name);
+
+        [ExcludeFromCodeCoverage]
+        private static string GetArgumentString(ExceptionArgument argument)
+        {
+            switch (argument)
+            {
+                case ExceptionArgument.cache: return nameof(ExceptionArgument.cache);
+                case ExceptionArgument.comparer: return nameof(ExceptionArgument.comparer);
+                case ExceptionArgument.scoped: return nameof(ExceptionArgument.scoped);
+                case ExceptionArgument.capacity: return nameof(ExceptionArgument.capacity);
+                case ExceptionArgument.node: return nameof(ExceptionArgument.node);
+                default:
+                    Debug.Fail("The ExceptionArgument value is not defined.");
+                    return string.Empty;
+            }
+        }
+    }
+
+    internal enum ExceptionArgument
+    {
+        cache,
+        comparer,
+        scoped,
+        capacity,
+        node,
+    }
+}