diff --git a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryCacheTests.cs b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryCacheTests.cs
index f4ab92cb..8c047ec6 100644
--- a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryCacheTests.cs
+++ b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryCacheTests.cs
@@ -13,11 +13,18 @@ namespace BitFaster.Caching.UnitTests.Atomic
     public class AtomicFactoryCacheTests
     {
         private const int capacity = 6;
-        private readonly AtomicFactoryCache<int, int> cache = new(new ConcurrentLru<int, AtomicFactory<int, int>>(capacity));
+        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()
         {
@@ -70,10 +77,52 @@ public void WhenRemovedEventHandlerIsRegisteredItIsFired()
             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();
         }
 
-// backcompat: remove conditional compile
-#if NETCOREAPP3_0_OR_GREATER
         [Fact]
         public void WhenUpdatedEventHandlerIsRegisteredItIsFired()
         {
diff --git a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryTests.cs b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryTests.cs
index d3c72caf..85987dfe 100644
--- a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryTests.cs
+++ b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryTests.cs
@@ -63,6 +63,58 @@ public void WhenValueCreatedArgGetValueReturnsOriginalValue()
             a.GetValue(1, (k, a) => k + a, 9).Should().Be(8);
         }
 
+        [Fact]
+        public void WhenValueNotCreatedHashCodeIsZero()
+        {
+            new AtomicFactory<int, int>()
+                .GetHashCode()
+                .Should().Be(0);
+        }
+
+        [Fact]
+        public void WhenValueCreatedHashCodeIsValueHashCode()
+        {
+            new AtomicFactory<int, int>(1)
+                .GetHashCode()
+                .Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenValueNotCreatedEqualsFalse()
+        {
+            var a = new AtomicFactory<int, int>();
+            var b = new AtomicFactory<int, int>();
+
+            a.Equals(b).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenOtherValueNotCreatedEqualsFalse()
+        {
+            var a = new AtomicFactory<int, int>(1);
+            var b = new AtomicFactory<int, int>();
+
+            a.Equals(b).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenArgNullEqualsFalse()
+        {
+            new AtomicFactory<int, int>(1)
+                .Equals(null)
+                .Should().BeFalse();
+        }
+
+        [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()
         {
diff --git a/BitFaster.Caching.UnitTests/CacheTests.cs b/BitFaster.Caching.UnitTests/CacheTests.cs
index b9ae6b5f..1840e301 100644
--- a/BitFaster.Caching.UnitTests/CacheTests.cs
+++ b/BitFaster.Caching.UnitTests/CacheTests.cs
@@ -1,5 +1,6 @@
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using FluentAssertions;
 using Moq;
@@ -25,6 +26,28 @@ public void WhenCacheInterfaceDefaultGetOrAddFallback()
                 1, 
                 (k, a) => k + a, 
                 2).Should().Be(3);
+        }
+
+        [Fact]
+        public void WhenCacheInterfaceDefaultTryRemoveKeyThrows()
+        {
+            var cache = new Mock<ICache<int, int>>();
+            cache.CallBase = true;
+
+            Action tryRemove = () => { cache.Object.TryRemove(1, out var value); };
+
+            tryRemove.Should().Throw<NotSupportedException>();
+        }
+
+        [Fact]
+        public void WhenCacheInterfaceDefaultTryRemoveKeyValueThrows()
+        {
+            var cache = new Mock<ICache<int, int>>();
+            cache.CallBase = true;
+
+            Action tryRemove = () => { cache.Object.TryRemove(new KeyValuePair<int, int>(1, 1)); };
+
+            tryRemove.Should().Throw<NotSupportedException>();
         }
 
         [Fact]
diff --git a/BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs b/BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs
index 73e9c762..453a77a6 100644
--- a/BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs
+++ b/BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs
@@ -582,12 +582,39 @@ public void WhenItemDoesNotExistUpdatedAddsItem()
         }
 
         [Fact]
-        public void WhenItemIsRemovedItIsRemoved()
+        public void WhenKeyExistsTryRemoveRemovesItem()
         {
             cache.GetOrAdd(1, k => k);
 
             cache.TryRemove(1).Should().BeTrue();
-            cache.TryGet(1, out var value).Should().BeFalse();
+            cache.TryGet(1, out _).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenKeyExistsTryRemoveReturnsValue()
+        {
+            cache.GetOrAdd(1, valueFactory.Create);
+
+            cache.TryRemove(1, out var value).Should().BeTrue();
+            value.Should().Be(1);
+        }
+
+        [Fact]
+        public void WhenItemExistsTryRemoveRemovesItem()
+        {
+            cache.GetOrAdd(1, k => k);
+
+            cache.TryRemove(new KeyValuePair<int, int>(1, 1)).Should().BeTrue();
+            cache.TryGet(1, out _).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenItemDoesntMatchTryRemoveDoesNotRemove()
+        {
+            cache.GetOrAdd(1, k => k);
+
+            cache.TryRemove(new KeyValuePair<int, int>(1, 2)).Should().BeFalse();
+            cache.TryGet(1, out var value).Should().BeTrue();
         }
 
         [Fact]
diff --git a/BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs b/BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs
index def8a864..9141759b 100644
--- a/BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs
+++ b/BitFaster.Caching.UnitTests/Lru/ClassicLruTests.cs
@@ -362,6 +362,33 @@ public void WhenKeyExistsTryRemoveRemovesItemAndReturnsTrue()
             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 WhenItemExistsTryRemovesItemAndReturnsTrue()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryRemove(new KeyValuePair<int, string>(1, "1")).Should().BeTrue();
+            lru.TryGet(1, out var value).Should().BeFalse();
+        }
+
+        [Fact]
+        public void WhenTryRemoveKvpDoesntMatchItemNotRemovedAndReturnsFalse()
+        {
+            lru.GetOrAdd(1, valueFactory.Create);
+
+            lru.TryRemove(new KeyValuePair<int, string>(1, "2")).Should().BeFalse();
+            lru.TryGet(1, out var value).Should().BeTrue();
+        }
+
         [Fact]
         public void WhenItemIsRemovedItIsDisposed()
         {
diff --git a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs
index ed2bf960..74f7800f 100644
--- a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs
+++ b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruTests.cs
@@ -634,6 +634,15 @@ public void WhenKeyExistsTryRemoveRemovesItemAndReturnsTrue()
 
             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]
@@ -1196,6 +1205,26 @@ await Threaded.Run(4, () => {
             }
         }
 
+        [Fact]
+        public async Task WhenSoakConcurrentGetAndRemoveKvpCacheEndsInConsistentState()
+        {
+            for (int i = 0; i < 10; i++)
+            {
+                await Threaded.Run(4, () => {
+                    for (int i = 0; i < 100000; i++)
+                    {
+                        lru.TryRemove(new KeyValuePair<int, string>(i + 1, (i + 1).ToString()));
+                        lru.GetOrAdd(i + 1, i => i.ToString());
+                    }
+                });
+
+                this.testOutputHelper.WriteLine($"{lru.HotCount} {lru.WarmCount} {lru.ColdCount}");
+                this.testOutputHelper.WriteLine(string.Join(" ", lru.Keys));
+
+                RunIntegrityCheck();
+            }
+        }
+
         [Fact]
         public async Task WhenSoakConcurrentGetAndUpdateCacheEndsInConsistentState()
         {
diff --git a/BitFaster.Caching/Atomic/AtomicFactory.cs b/BitFaster.Caching/Atomic/AtomicFactory.cs
index aeb96a67..d2f93677 100644
--- a/BitFaster.Caching/Atomic/AtomicFactory.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactory.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading;
 
@@ -11,7 +12,7 @@ namespace BitFaster.Caching.Atomic
     /// <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>
+    public sealed class AtomicFactory<K, V> : IEquatable<AtomicFactory<K, V>>
     {
         private Initializer initializer;
 
@@ -102,8 +103,36 @@ private V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : s
             }
 
             return value;
-        }
-
+        }
+
+        ///<inheritdoc/>
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as AtomicFactory<K, V>);
+        }
+
+        ///<inheritdoc/>
+        public bool Equals(AtomicFactory<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 class Initializer
         {
             private readonly object syncLock = new();
@@ -129,6 +158,6 @@ public V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : st
                     return value;
                 }
             }
-        }
+        }
     }
 }
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
index f814ee80..6af07f8c 100644
--- a/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
+++ b/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
@@ -2,7 +2,8 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
-
+using System.Linq.Expressions;
+
 namespace BitFaster.Caching.Atomic
 {
     /// <summary>
@@ -100,9 +101,38 @@ public bool TryGet(K key, out V value)
                 return true;
             }
 
+            value = default;
+            return false;
+        }
+
+        // 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, 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)
diff --git a/BitFaster.Caching/ICache.cs b/BitFaster.Caching/ICache.cs
index 33ff16de..00e16c96 100644
--- a/BitFaster.Caching/ICache.cs
+++ b/BitFaster.Caching/ICache.cs
@@ -66,6 +66,21 @@ public interface ICache<K, V> : IEnumerable<KeyValuePair<K, V>>
         /// <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();
+
+        /// <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>
diff --git a/BitFaster.Caching/Lfu/ConcurrentLfu.cs b/BitFaster.Caching/Lfu/ConcurrentLfu.cs
index 223735ba..5d4a3bc7 100644
--- a/BitFaster.Caching/Lfu/ConcurrentLfu.cs
+++ b/BitFaster.Caching/Lfu/ConcurrentLfu.cs
@@ -316,21 +316,64 @@ public bool TryGet(K key, out V value)
 
             value = default;
             return 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)
+        {
+            if (this.dictionary.TryGetValue(item.Key, out var node))
+            {
+                if (EqualityComparer<V>.Default.Equals(node.Value, item.Value))
+                {
+                    var kvp = new KeyValuePair<K, LfuNode<K,V>>(item.Key, node);
+
+#if NET6_0_OR_GREATER
+                    if (this.dictionary.TryRemove(kvp))
+#else
+                    // https://devblogs.microsoft.com/pfxteam/little-known-gems-atomic-conditional-removals-from-concurrentdictionary/
+                    if (((ICollection<KeyValuePair<K, LfuNode<K, V>>>)this.dictionary).Remove(kvp))
+#endif
+                    {
+                        node.WasRemoved = true;
+                        AfterWrite(node);
+                        return true;
+                    }
+                }
+            }
 
-        ///<inheritdoc/>
-        public bool TryRemove(K key)
+            return false;
+        }
+
+        /// <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>
+        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)
         {
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
index 5950bb93..1b777691 100644
--- a/BitFaster.Caching/Lru/ClassicLru.cs
+++ b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -235,33 +235,80 @@ public async ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valu
             }
 
             return await this.GetOrAddAsync(key, valueFactory, factoryArgument);
-        }
-
-        ///<inheritdoc/>
-        public bool TryRemove(K key)
+        }
+
+        /// <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)
+        {
+            if (this.dictionary.TryGetValue(item.Key, out var node))
+            {
+                if (EqualityComparer<V>.Default.Equals(node.Value.Value, item.Value))
+                {
+                    var kvp = new KeyValuePair<K, LinkedListNode<LruItem>>(item.Key, node);
+
+#if NET6_0_OR_GREATER
+                    if (this.dictionary.TryRemove(kvp))
+#else
+                    // https://devblogs.microsoft.com/pfxteam/little-known-gems-atomic-conditional-removals-from-concurrentdictionary/
+                    if (((ICollection<KeyValuePair<K, LinkedListNode<LruItem>>>)this.dictionary).Remove(kvp))
+#endif
+                    {
+                        OnRemove(node);
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <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>
+        public bool TryRemove(K key, out V value)
         {
             if (dictionary.TryRemove(key, out var 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)
-                {
-                    lock (this.linkedList)
-                    {
-                        if (node.List != null)
-                        {
-                            linkedList.Remove(node);
-                        }
-                    }
-                }
-
-                Disposer<V>.Dispose(node.Value.Value);
-
+                OnRemove(node);
+                value = node.Value.Value;
                 return true;
-            }
+            }
+
+            value = default;
+            return false;
+
+        }
 
-            return false;
+        ///<inheritdoc/>
+        public bool TryRemove(K key)
+        {
+            return TryRemove(key, out var _);
+        }
+
+        private void OnRemove(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)
+            {
+                lock (this.linkedList)
+                {
+                    if (node.List != null)
+                    {
+                        linkedList.Remove(node);
+                    }
+                }
+            }
+
+            Disposer<V>.Dispose(node.Value.Value);
         }
 
         ///<inheritdoc/>
diff --git a/BitFaster.Caching/Lru/ConcurrentLruCore.cs b/BitFaster.Caching/Lru/ConcurrentLruCore.cs
index 4ee2eab6..59ec796c 100644
--- a/BitFaster.Caching/Lru/ConcurrentLruCore.cs
+++ b/BitFaster.Caching/Lru/ConcurrentLruCore.cs
@@ -293,45 +293,79 @@ public async ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valu
             }
         }
 
-        ///<inheritdoc/>
-        public bool TryRemove(K key)
+        /// <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)
         {
-            while (true)
-            { 
-                if (this.dictionary.TryGetValue(key, out var existing))
+            if (this.dictionary.TryGetValue(item.Key, out var existing))
+            {
+                if (EqualityComparer<V>.Default.Equals(existing.Value, item.Value))
                 {
-                    var kvp = new KeyValuePair<K, I>(key, existing);
-
-                    // hidden atomic remove
+                    var kvp = new KeyValuePair<K, I>(item.Key, existing);
+#if NET6_0_OR_GREATER
+                    if (this.dictionary.TryRemove(kvp))
+#else
                     // https://devblogs.microsoft.com/pfxteam/little-known-gems-atomic-conditional-removals-from-concurrentdictionary/
                     if (((ICollection<KeyValuePair<K, I>>)this.dictionary).Remove(kvp))
+#endif
                     {
-                        // Mark as not accessed, it will later be cycled out of the queues because it can never be fetched 
-                        // from the dictionary. Note: Hot/Warm/Cold count will reflect the removed item until it is cycled 
-                        // from the queue.
-                        existing.WasAccessed = false;
-                        existing.WasRemoved = true;
+                        OnRemove(item.Key, kvp.Value);
+                        return true;
+                    }
+                }
 
-                        this.telemetryPolicy.OnItemRemoved(existing.Key, existing.Value, ItemRemovedReason.Removed);
+                // it existed, but we couldn't remove - this means value was replaced afer the TryGetValue (a race)
+            }
 
-                        // serialize dispose (common case dispose not thread safe)
-                        lock (existing)
-                        {
-                            Disposer<V>.Dispose(existing.Value);
-                        }
+            return false;
+        }
 
-                        return true;
-                    }
+        /// <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>
+        public bool TryRemove(K key, out V value)
+        {
+            if (this.dictionary.TryRemove(key, out var item))
+            {
+                OnRemove(key, item);
+                value = item.Value;
+                return true;
+            }
 
-                    // it existed, but we couldn't remove - this means value was replaced afer the TryGetValue (a race), try again
-                }
-                else
-                { 
-                    return false;
-                }
+            value = default;
+            return false;
+        }
+
+        ///<inheritdoc/>
+        public bool TryRemove(K key)
+        {
+            return TryRemove(key, out _);
+        }
+
+        private void OnRemove(K key, I item)
+        {
+            // Mark as not accessed, it will later be cycled out of the queues because it can never be fetched 
+            // from the dictionary. Note: Hot/Warm/Cold count will reflect the removed item until it is cycled 
+            // from the queue.
+            item.WasAccessed = false;
+            item.WasRemoved = true;
+
+            this.telemetryPolicy.OnItemRemoved(key, item.Value, ItemRemovedReason.Removed);
+
+            // serialize dispose (common case dispose not thread safe)
+            lock (item.Value)
+            {
+                Disposer<V>.Dispose(item.Value);
             }
         }
 
+
         ///<inheritdoc/>
         ///<remarks>Note: Calling this method does not affect LRU order.</remarks>
         public bool TryUpdate(K key, V value)