diff --git a/BitFaster.Caching/Lfu/ConcurrentLfuCore.cs b/BitFaster.Caching/Lfu/ConcurrentLfuCore.cs
index bf12000f..b6d5be4a 100644
--- a/BitFaster.Caching/Lfu/ConcurrentLfuCore.cs
+++ b/BitFaster.Caching/Lfu/ConcurrentLfuCore.cs
@@ -1033,12 +1033,15 @@ internal AlternateLookup(ConcurrentLfuCore<K, V, N, P> lfu)
                 Debug.Assert(lfu.dictionary.IsCompatibleKey<TAlternateKey, K, N>());
                 this.Lfu = lfu;
                 this.Alternate = lfu.dictionary.GetAlternateLookup<TAlternateKey>();
+                this.Comparer = lfu.dictionary.GetAlternateComparer<TAlternateKey, K, N>();
             }
 
             internal ConcurrentLfuCore<K, V, N, P> Lfu { get; }
 
             internal ConcurrentDictionary<K, N>.AlternateLookup<TAlternateKey> Alternate { get; }
 
+            internal IAlternateEqualityComparer<TAlternateKey, K> Comparer { get; }
+
             public bool TryGet(TAlternateKey key, [MaybeNullWhen(false)] out V value)
             {
                 if (this.Alternate.TryGetValue(key, out var node))
@@ -1091,7 +1094,7 @@ public void AddOrUpdate(TAlternateKey key, V value)
 
                     if (!hasActualKey)
                     {
-                        actualKey = this.Lfu.dictionary.GetAlternateComparer<TAlternateKey, K, N>().Create(key);
+                        actualKey = this.Comparer.Create(key);
                         hasActualKey = true;
                     }
 
@@ -1111,7 +1114,7 @@ public V GetOrAdd(TAlternateKey key, Func<K, V> valueFactory)
                         return value;
                     }
 
-                    K actualKey = this.Lfu.dictionary.GetAlternateComparer<TAlternateKey, K, N>().Create(key);
+                    K actualKey = this.Comparer.Create(key);
 
                     value = valueFactory(actualKey);
                     if (this.Lfu.TryAdd(actualKey, value))
@@ -1130,7 +1133,7 @@ public V GetOrAdd<TArg>(TAlternateKey key, Func<K, TArg, V> valueFactory, TArg f
                         return value;
                     }
 
-                    K actualKey = this.Lfu.dictionary.GetAlternateComparer<TAlternateKey, K, N>().Create(key);
+                    K actualKey = this.Comparer.Create(key);
 
                     value = valueFactory(actualKey, factoryArgument);
                     if (this.Lfu.TryAdd(actualKey, value))
@@ -1147,7 +1150,7 @@ public ValueTask<V> GetOrAddAsync(TAlternateKey key, Func<K, Task<V>> valueFacto
                     return new ValueTask<V>(value);
                 }
 
-                K actualKey = this.Lfu.dictionary.GetAlternateComparer<TAlternateKey, K, N>().Create(key);
+                K actualKey = this.Comparer.Create(key);
                 Task<V> task = valueFactory(actualKey);
 
                 return GetOrAddAsyncSlow(actualKey, task);
@@ -1160,7 +1163,7 @@ public ValueTask<V> GetOrAddAsync<TArg>(TAlternateKey key, Func<K, TArg, Task<V>
                     return new ValueTask<V>(value);
                 }
 
-                K actualKey = this.Lfu.dictionary.GetAlternateComparer<TAlternateKey, K, N>().Create(key);
+                K actualKey = this.Comparer.Create(key);
                 Task<V> task = valueFactory(actualKey, factoryArgument);
 
                 return GetOrAddAsyncSlow(actualKey, task);
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
index 6a90f68d..b132ca40 100644
--- a/BitFaster.Caching/Lru/ClassicLru.cs
+++ b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -536,10 +536,12 @@ internal AlternateLookup(ClassicLru<K, V> lru)
                 Debug.Assert(lru.dictionary.IsCompatibleKey<TAlternateKey, K, LinkedListNode<LruItem>>());
                 this.lru = lru;
                 this.alternate = lru.dictionary.GetAlternateLookup<TAlternateKey>();
+                this.comparer = lru.dictionary.GetAlternateComparer<TAlternateKey, K, LinkedListNode<LruItem>>();
             }
 
             private readonly ClassicLru<K, V> lru;
             private readonly ConcurrentDictionary<K, LinkedListNode<LruItem>>.AlternateLookup<TAlternateKey> alternate;
+            private readonly IAlternateEqualityComparer<TAlternateKey, K> comparer;
 
             public bool TryGet(TAlternateKey key, [MaybeNullWhen(false)] out V value)
             {
@@ -590,7 +592,7 @@ public void AddOrUpdate(TAlternateKey key, V value)
 
                     if (!hasActualKey)
                     {
-                        actualKey = this.lru.dictionary.GetAlternateComparer<TAlternateKey, K, LinkedListNode<LruItem>>().Create(key);
+                        actualKey = this.comparer.Create(key);
                         hasActualKey = true;
                     }
 
@@ -610,7 +612,7 @@ public V GetOrAdd(TAlternateKey key, Func<K, V> valueFactory)
                         return value;
                     }
 
-                    K actualKey = this.lru.dictionary.GetAlternateComparer<TAlternateKey, K, LinkedListNode<LruItem>>().Create(key);
+                    K actualKey = this.comparer.Create(key);
 
                     value = valueFactory(actualKey);
                     if (this.lru.TryAdd(actualKey, value))
@@ -629,7 +631,7 @@ public V GetOrAdd<TArg>(TAlternateKey key, Func<K, TArg, V> valueFactory, TArg f
                         return value;
                     }
 
-                    K actualKey = this.lru.dictionary.GetAlternateComparer<TAlternateKey, K, LinkedListNode<LruItem>>().Create(key);
+                    K actualKey = this.comparer.Create(key);
 
                     value = valueFactory(actualKey, factoryArgument);
                     if (this.lru.TryAdd(actualKey, value))
@@ -646,7 +648,7 @@ public ValueTask<V> GetOrAddAsync(TAlternateKey key, Func<K, Task<V>> valueFacto
                     return new ValueTask<V>(value);
                 }
 
-                K actualKey = this.lru.dictionary.GetAlternateComparer<TAlternateKey, K, LinkedListNode<LruItem>>().Create(key);
+                K actualKey = this.comparer.Create(key);
                 Task<V> task = valueFactory(actualKey);
 
                 return GetOrAddAsyncSlow(actualKey, task);
@@ -659,7 +661,7 @@ public ValueTask<V> GetOrAddAsync<TArg>(TAlternateKey key, Func<K, TArg, Task<V>
                     return new ValueTask<V>(value);
                 }
 
-                K actualKey = this.lru.dictionary.GetAlternateComparer<TAlternateKey, K, LinkedListNode<LruItem>>().Create(key);
+                K actualKey = this.comparer.Create(key);
                 Task<V> task = valueFactory(actualKey, factoryArgument);
 
                 return GetOrAddAsyncSlow(actualKey, task);
diff --git a/BitFaster.Caching/Lru/ConcurrentLruCore.cs b/BitFaster.Caching/Lru/ConcurrentLruCore.cs
index 69630b24..cd8f6cd8 100644
--- a/BitFaster.Caching/Lru/ConcurrentLruCore.cs
+++ b/BitFaster.Caching/Lru/ConcurrentLruCore.cs
@@ -967,12 +967,15 @@ internal AlternateLookup(ConcurrentLruCore<K, V, I, P, T> lru)
                 Debug.Assert(lru.dictionary.IsCompatibleKey<TAlternateKey, K, I>());
                 this.Lru = lru;
                 this.Alternate = lru.dictionary.GetAlternateLookup<TAlternateKey>();
+                this.Comparer = lru.dictionary.GetAlternateComparer<TAlternateKey, K, I>();
             }
 
             internal ConcurrentLruCore<K, V, I, P, T> Lru { get; }
 
             internal ConcurrentDictionary<K, I>.AlternateLookup<TAlternateKey> Alternate { get; }
 
+            internal IAlternateEqualityComparer<TAlternateKey, K> Comparer { get; }
+
             public bool TryGet(TAlternateKey key, [MaybeNullWhen(false)] out V value)
             {
                 if (this.Alternate.TryGetValue(key, out var item))
@@ -1023,7 +1026,7 @@ public void AddOrUpdate(TAlternateKey key, V value)
 
                     if (!hasActualKey)
                     {
-                        actualKey = this.Lru.dictionary.GetAlternateComparer<TAlternateKey, K, I>().Create(key);
+                        actualKey = this.Comparer.Create(key);
                         hasActualKey = true;
                     }
 
@@ -1043,7 +1046,7 @@ public V GetOrAdd(TAlternateKey key, Func<K, V> valueFactory)
                         return value;
                     }
 
-                    K actualKey = this.Lru.dictionary.GetAlternateComparer<TAlternateKey, K, I>().Create(key);
+                    K actualKey = this.Comparer.Create(key);
 
                     value = valueFactory(actualKey);
                     if (this.Lru.TryAdd(actualKey, value))
@@ -1062,7 +1065,7 @@ public V GetOrAdd<TArg>(TAlternateKey key, Func<K, TArg, V> valueFactory, TArg f
                         return value;
                     }
 
-                    K actualKey = this.Lru.dictionary.GetAlternateComparer<TAlternateKey, K, I>().Create(key);
+                    K actualKey = this.Comparer.Create(key);
 
                     value = valueFactory(actualKey, factoryArgument);
                     if (this.Lru.TryAdd(actualKey, value))
@@ -1079,7 +1082,7 @@ public ValueTask<V> GetOrAddAsync(TAlternateKey key, Func<K, Task<V>> valueFacto
                     return new ValueTask<V>(value);
                 }
 
-                K actualKey = this.Lru.dictionary.GetAlternateComparer<TAlternateKey, K, I>().Create(key);
+                K actualKey = this.Comparer.Create(key);
                 Task<V> task = valueFactory(actualKey);
 
                 return GetOrAddAsyncSlow(actualKey, task);
@@ -1092,7 +1095,7 @@ public ValueTask<V> GetOrAddAsync<TArg>(TAlternateKey key, Func<K, TArg, Task<V>
                     return new ValueTask<V>(value);
                 }
 
-                K actualKey = this.Lru.dictionary.GetAlternateComparer<TAlternateKey, K, I>().Create(key);
+                K actualKey = this.Comparer.Create(key);
                 Task<V> task = valueFactory(actualKey, factoryArgument);
 
                 return GetOrAddAsyncSlow(actualKey, task);