diff --git a/src/libraries/System.Collections/ref/System.Collections.cs b/src/libraries/System.Collections/ref/System.Collections.cs
index 3625b253780b12..bdf0bc4949acd4 100644
--- a/src/libraries/System.Collections/ref/System.Collections.cs
+++ b/src/libraries/System.Collections/ref/System.Collections.cs
@@ -618,16 +618,12 @@ namespace System.Collections.Generic
     public static partial class CollectionExtensions
     {
         public static void AddRange<T>(this System.Collections.Generic.List<T> list, params System.ReadOnlySpan<T> source) { }
-        public static System.Collections.Generic.Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey> GetAlternateLookup<TKey, TValue, TAlternateKey>(this System.Collections.Generic.Dictionary<TKey, TValue> dictionary) where TKey : notnull where TAlternateKey : notnull, allows ref struct { throw null; }
-        public static System.Collections.Generic.HashSet<T>.AlternateLookup<TAlternate> GetAlternateLookup<T, TAlternate>(this System.Collections.Generic.HashSet<T> set) where TAlternate : allows ref struct { throw null; }
         public static void CopyTo<T>(this System.Collections.Generic.List<T> list, System.Span<T> destination) { }
         public static TValue? GetValueOrDefault<TKey, TValue>(this System.Collections.Generic.IReadOnlyDictionary<TKey, TValue> dictionary, TKey key) { throw null; }
         public static TValue GetValueOrDefault<TKey, TValue>(this System.Collections.Generic.IReadOnlyDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue) { throw null; }
         public static void InsertRange<T>(this System.Collections.Generic.List<T> list, int index, params System.ReadOnlySpan<T> source) { }
         public static bool Remove<TKey, TValue>(this System.Collections.Generic.IDictionary<TKey, TValue> dictionary, TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
         public static bool TryAdd<TKey, TValue>(this System.Collections.Generic.IDictionary<TKey, TValue> dictionary, TKey key, TValue value) { throw null; }
-        public static bool TryGetAlternateLookup<TKey, TValue, TAlternateKey>(this System.Collections.Generic.Dictionary<TKey, TValue> dictionary, out System.Collections.Generic.Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey> lookup) where TKey : notnull where TAlternateKey : notnull, allows ref struct { throw null; }
-        public static bool TryGetAlternateLookup<T, TAlternate>(this System.Collections.Generic.HashSet<T> set, out System.Collections.Generic.HashSet<T>.AlternateLookup<TAlternate> lookup) where TAlternate : allows ref struct { throw null; }
         public static System.Collections.ObjectModel.ReadOnlyCollection<T> AsReadOnly<T>(this IList<T> list) { throw null; }
         public static System.Collections.ObjectModel.ReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary) where TKey : notnull { throw null; }
     }
@@ -675,6 +671,7 @@ public void Clear() { }
         public bool ContainsKey(TKey key) { throw null; }
         public bool ContainsValue(TValue value) { throw null; }
         public int EnsureCapacity(int capacity) { throw null; }
+        public System.Collections.Generic.Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey> GetAlternateLookup<TAlternateKey>() where TAlternateKey : notnull, allows ref struct { throw null; }
         public System.Collections.Generic.Dictionary<TKey, TValue>.Enumerator GetEnumerator() { throw null; }
         [System.ObsoleteAttribute("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId = "SYSLIB0051", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
@@ -696,6 +693,7 @@ void System.Collections.IDictionary.Remove(object key) { }
         public void TrimExcess() { }
         public void TrimExcess(int capacity) { }
         public bool TryAdd(TKey key, TValue value) { throw null; }
+        public bool TryGetAlternateLookup<TAlternateKey>(out System.Collections.Generic.Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey> lookup) where TAlternateKey : notnull, allows ref struct { throw null; }
         public bool TryGetValue(TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
         public readonly partial struct AlternateLookup<TAlternateKey> where TAlternateKey : notnull, allows ref struct
         {
@@ -812,6 +810,7 @@ public void CopyTo(T[] array, int arrayIndex, int count) { }
         public static System.Collections.Generic.IEqualityComparer<System.Collections.Generic.HashSet<T>> CreateSetComparer() { throw null; }
         public int EnsureCapacity(int capacity) { throw null; }
         public void ExceptWith(System.Collections.Generic.IEnumerable<T> other) { }
+        public System.Collections.Generic.HashSet<T>.AlternateLookup<TAlternate> GetAlternateLookup<TAlternate>() where TAlternate : allows ref struct { throw null; }
         public System.Collections.Generic.HashSet<T>.Enumerator GetEnumerator() { throw null; }
         [System.ObsoleteAttribute("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId = "SYSLIB0051", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")]
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
@@ -832,6 +831,7 @@ void System.Collections.Generic.ICollection<T>.Add(T item) { }
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
         public void TrimExcess() { }
         public void TrimExcess(int capacity) { }
+        public bool TryGetAlternateLookup<TAlternate>(out System.Collections.Generic.HashSet<T>.AlternateLookup<TAlternate> lookup) where TAlternate : allows ref struct { throw null; }
         public bool TryGetValue(T equalValue, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out T actualValue) { throw null; }
         public void UnionWith(System.Collections.Generic.IEnumerable<T> other) { }
         public readonly partial struct AlternateLookup<TAlternate> where TAlternate : allows ref struct
diff --git a/src/libraries/System.Collections/tests/Generic/CollectionExtensionsTests.cs b/src/libraries/System.Collections/tests/Generic/CollectionExtensionsTests.cs
index b43f5affdaee59..d07e031f0e7acf 100644
--- a/src/libraries/System.Collections/tests/Generic/CollectionExtensionsTests.cs
+++ b/src/libraries/System.Collections/tests/Generic/CollectionExtensionsTests.cs
@@ -141,252 +141,6 @@ public void AsReadOnly_NullIDictionary_ThrowsArgumentNullException()
             Assert.Throws<ArgumentNullException>("dictionary", () => dictionary.AsReadOnly());
         }
 
-        [Fact]
-        public void GetAlternateLookup_ThrowsWhenNull()
-        {
-            AssertExtensions.Throws<ArgumentNullException>("dictionary", () => CollectionExtensions.GetAlternateLookup<int, int, long>((Dictionary<int, int>)null));
-            AssertExtensions.Throws<ArgumentNullException>("dictionary", () => CollectionExtensions.TryGetAlternateLookup<int, int, long>((Dictionary<int, int>)null, out _));
-
-            AssertExtensions.Throws<ArgumentNullException>("set", () => CollectionExtensions.GetAlternateLookup<int, long>((HashSet<int>)null));
-            AssertExtensions.Throws<ArgumentNullException>("set", () => CollectionExtensions.TryGetAlternateLookup<int, long>((HashSet<int>)null, out _));
-        }
-
-        [Fact]
-        public void GetAlternateLookup_FailsWhenIncompatible()
-        {
-            var dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
-            var hashSet = new HashSet<string>(StringComparer.Ordinal);
-
-            dictionary.GetAlternateLookup<string, string, ReadOnlySpan<char>>();
-            Assert.True(dictionary.TryGetAlternateLookup<string, string, ReadOnlySpan<char>>(out _));
-
-            hashSet.GetAlternateLookup<string, ReadOnlySpan<char>>();
-            Assert.True(hashSet.TryGetAlternateLookup<string, ReadOnlySpan<char>>(out _));
-
-            Assert.Throws<InvalidOperationException>(() => dictionary.GetAlternateLookup<string, string, ReadOnlySpan<byte>>());
-            Assert.Throws<InvalidOperationException>(() => dictionary.GetAlternateLookup<string, string, string>());
-            Assert.Throws<InvalidOperationException>(() => dictionary.GetAlternateLookup<string, string, int>());
-
-            Assert.False(dictionary.TryGetAlternateLookup<string, string, ReadOnlySpan<byte>>(out _));
-            Assert.False(dictionary.TryGetAlternateLookup<string, string, string>(out _));
-            Assert.False(dictionary.TryGetAlternateLookup<string, string, int>(out _));
-
-            Assert.Throws<InvalidOperationException>(() => hashSet.GetAlternateLookup<string, ReadOnlySpan<byte>>());
-            Assert.Throws<InvalidOperationException>(() => hashSet.GetAlternateLookup<string, string>());
-            Assert.Throws<InvalidOperationException>(() => hashSet.GetAlternateLookup<string, int>());
-
-            Assert.False(hashSet.TryGetAlternateLookup<string, ReadOnlySpan<byte>>(out _));
-            Assert.False(hashSet.TryGetAlternateLookup<string, string>(out _));
-            Assert.False(hashSet.TryGetAlternateLookup<string, int>(out _));
-        }
-
-        public static IEnumerable<object[]> Dictionary_GetAlternateLookup_OperationsMatchUnderlyingDictionary_MemberData()
-        {
-            yield return new object[] { EqualityComparer<string>.Default };
-            yield return new object[] { StringComparer.Ordinal };
-            yield return new object[] { StringComparer.OrdinalIgnoreCase };
-            yield return new object[] { StringComparer.InvariantCulture };
-            yield return new object[] { StringComparer.InvariantCultureIgnoreCase };
-            yield return new object[] { StringComparer.CurrentCulture };
-            yield return new object[] { StringComparer.CurrentCultureIgnoreCase };
-        }
-
-        [Theory]
-        [MemberData(nameof(Dictionary_GetAlternateLookup_OperationsMatchUnderlyingDictionary_MemberData))]
-        public void Dictionary_GetAlternateLookup_OperationsMatchUnderlyingDictionary(IEqualityComparer<string> comparer)
-        {
-            // Test with a variety of comparers to ensure that the alternate lookup is consistent with the underlying dictionary
-            Dictionary<string, int> dictionary = new(comparer);
-            Dictionary<string, int>.AlternateLookup<ReadOnlySpan<char>> lookup = dictionary.GetAlternateLookup<string, int, ReadOnlySpan<char>>();
-            Assert.Same(dictionary, lookup.Dictionary);
-            Assert.Same(lookup.Dictionary, lookup.Dictionary);
-
-            string actualKey;
-            int value;
-
-            // Add to the dictionary and validate that the lookup reflects the changes
-            dictionary["123"] = 123;
-            Assert.True(lookup.ContainsKey("123".AsSpan()));
-            Assert.True(lookup.TryGetValue("123".AsSpan(), out value));
-            Assert.Equal(123, value);
-            Assert.Equal(123, lookup["123".AsSpan()]);
-            Assert.False(lookup.TryAdd("123".AsSpan(), 321));
-            Assert.True(lookup.Remove("123".AsSpan()));
-            Assert.False(dictionary.ContainsKey("123"));
-            Assert.Throws<KeyNotFoundException>(() => lookup["123".AsSpan()]);
-
-            // Add via the lookup and validate that the dictionary reflects the changes
-            Assert.True(lookup.TryAdd("123".AsSpan(), 123));
-            Assert.True(dictionary.ContainsKey("123"));
-            lookup.TryGetValue("123".AsSpan(), out value);
-            Assert.Equal(123, value);
-            Assert.False(lookup.Remove("321".AsSpan(), out actualKey, out value));
-            Assert.Null(actualKey);
-            Assert.Equal(0, value);
-            Assert.True(lookup.Remove("123".AsSpan(), out actualKey, out value));
-            Assert.Equal("123", actualKey);
-            Assert.Equal(123, value);
-
-            // Ensure that case-sensitivity of the comparer is respected
-            lookup["a".AsSpan()] = 42;
-            if (dictionary.Comparer.Equals(EqualityComparer<string>.Default) ||
-                dictionary.Comparer.Equals(StringComparer.Ordinal) ||
-                dictionary.Comparer.Equals(StringComparer.InvariantCulture) ||
-                dictionary.Comparer.Equals(StringComparer.CurrentCulture))
-            {
-                Assert.True(lookup.TryGetValue("a".AsSpan(), out actualKey, out value));
-                Assert.Equal("a", actualKey);
-                Assert.Equal(42, value);
-                Assert.True(lookup.TryAdd("A".AsSpan(), 42));
-                Assert.True(lookup.Remove("a".AsSpan()));
-                Assert.False(lookup.Remove("a".AsSpan()));
-                Assert.True(lookup.Remove("A".AsSpan()));
-            }
-            else
-            {
-                Assert.True(lookup.TryGetValue("A".AsSpan(), out actualKey, out value));
-                Assert.Equal("a", actualKey);
-                Assert.Equal(42, value);
-                Assert.False(lookup.TryAdd("A".AsSpan(), 42));
-                Assert.True(lookup.Remove("A".AsSpan()));
-                Assert.False(lookup.Remove("a".AsSpan()));
-                Assert.False(lookup.Remove("A".AsSpan()));
-            }
-
-            // Validate overwrites
-            lookup["a".AsSpan()] = 42;
-            Assert.Equal(42, dictionary["a"]);
-            lookup["a".AsSpan()] = 43;
-            Assert.True(lookup.Remove("a".AsSpan(), out actualKey, out value));
-            Assert.Equal("a", actualKey);
-            Assert.Equal(43, value);
-
-            // Test adding multiple entries via the lookup
-            for (int i = 0; i < 10; i++)
-            {
-                Assert.Equal(i, dictionary.Count);
-                Assert.True(lookup.TryAdd(i.ToString().AsSpan(), i));
-                Assert.False(lookup.TryAdd(i.ToString().AsSpan(), i));
-            }
-
-            Assert.Equal(10, dictionary.Count);
-
-            // Test that the lookup and the dictionary agree on what's in and not in
-            for (int i = -1; i <= 10; i++)
-            {
-                Assert.Equal(dictionary.TryGetValue(i.ToString(), out int dv), lookup.TryGetValue(i.ToString().AsSpan(), out int lv));
-                Assert.Equal(dv, lv);
-            }
-
-            // Test removing multiple entries via the lookup
-            for (int i = 9; i >= 0; i--)
-            {
-                Assert.True(lookup.Remove(i.ToString().AsSpan(), out actualKey, out value));
-                Assert.Equal(i.ToString(), actualKey);
-                Assert.Equal(i, value);
-                Assert.False(lookup.Remove(i.ToString().AsSpan(), out actualKey, out value));
-                Assert.Null(actualKey);
-                Assert.Equal(0, value);
-                Assert.Equal(i, dictionary.Count);
-            }
-        }
-
-        [Theory]
-        [InlineData(0)]
-        [InlineData(1)]
-        [InlineData(2)]
-        [InlineData(3)]
-        [InlineData(4)]
-        [InlineData(5)]
-        public void HashSet_GetAlternateLookup_OperationsMatchUnderlyingSet(int mode)
-        {
-            // Test with a variety of comparers to ensure that the alternate lookup is consistent with the underlying set
-            HashSet<string> set = new(mode switch
-            {
-                0 => StringComparer.Ordinal,
-                1 => StringComparer.OrdinalIgnoreCase,
-                2 => StringComparer.InvariantCulture,
-                3 => StringComparer.InvariantCultureIgnoreCase,
-                4 => StringComparer.CurrentCulture,
-                5 => StringComparer.CurrentCultureIgnoreCase,
-                _ => throw new ArgumentOutOfRangeException(nameof(mode))
-            });
-            HashSet<string>.AlternateLookup<ReadOnlySpan<char>> lookup = set.GetAlternateLookup<string, ReadOnlySpan<char>>();
-            Assert.Same(set, lookup.Set);
-            Assert.Same(lookup.Set, lookup.Set);
-
-            // Add to the set and validate that the lookup reflects the changes
-            Assert.True(set.Add("123"));
-            Assert.True(lookup.Contains("123".AsSpan()));
-            Assert.False(lookup.Add("123".AsSpan()));
-            Assert.True(lookup.Remove("123".AsSpan()));
-            Assert.False(set.Contains("123"));
-
-            // Add via the lookup and validate that the set reflects the changes
-            Assert.True(lookup.Add("123".AsSpan()));
-            Assert.True(set.Contains("123"));
-            lookup.TryGetValue("123".AsSpan(), out string value);
-            Assert.Equal("123", value);
-            Assert.False(lookup.Remove("321".AsSpan()));
-            Assert.True(lookup.Remove("123".AsSpan()));
-
-            // Ensure that case-sensitivity of the comparer is respected
-            Assert.True(lookup.Add("a"));
-            if (set.Comparer.Equals(StringComparer.Ordinal) ||
-                set.Comparer.Equals(StringComparer.InvariantCulture) ||
-                set.Comparer.Equals(StringComparer.CurrentCulture))
-            {
-                Assert.True(lookup.Add("A".AsSpan()));
-                Assert.True(lookup.Remove("a".AsSpan()));
-                Assert.False(lookup.Remove("a".AsSpan()));
-                Assert.True(lookup.Remove("A".AsSpan()));
-            }
-            else
-            {
-                Assert.False(lookup.Add("A".AsSpan()));
-                Assert.True(lookup.Remove("A".AsSpan()));
-                Assert.False(lookup.Remove("a".AsSpan()));
-                Assert.False(lookup.Remove("A".AsSpan()));
-            }
-
-            // Test the behavior of null vs "" in the set and lookup
-            Assert.True(set.Add(null));
-            Assert.True(set.Add(string.Empty));
-            Assert.True(set.Contains(null));
-            Assert.True(set.Contains(""));
-            Assert.True(lookup.Contains("".AsSpan()));
-            Assert.True(lookup.Remove("".AsSpan()));
-            Assert.Equal(1, set.Count);
-            Assert.False(lookup.Remove("".AsSpan()));
-            Assert.True(set.Remove(null));
-            Assert.Equal(0, set.Count);
-
-            // Test adding multiple entries via the lookup
-            for (int i = 0; i < 10; i++)
-            {
-                Assert.Equal(i, set.Count);
-                Assert.True(lookup.Add(i.ToString().AsSpan()));
-                Assert.False(lookup.Add(i.ToString().AsSpan()));
-            }
-
-            Assert.Equal(10, set.Count);
-
-            // Test that the lookup and the set agree on what's in and not in
-            for (int i = -1; i <= 10; i++)
-            {
-                Assert.Equal(set.TryGetValue(i.ToString(), out string dv), lookup.TryGetValue(i.ToString().AsSpan(), out string lv));
-                Assert.Equal(dv, lv);
-            }
-
-            // Test removing multiple entries via the lookup
-            for (int i = 9; i >= 0; i--)
-            {
-                Assert.True(lookup.Remove(i.ToString().AsSpan()));
-                Assert.False(lookup.Remove(i.ToString().AsSpan()));
-                Assert.Equal(i, set.Count);
-            }
-        }
-
         [Fact]
         public void Dictionary_NotCorruptedByThrowingComparer()
         {
@@ -394,7 +148,7 @@ public void Dictionary_NotCorruptedByThrowingComparer()
 
             Assert.Equal(0, dict.Count);
 
-            Assert.Throws<FormatException>(() => dict.GetAlternateLookup<string, string, ReadOnlySpan<char>>().TryAdd("123".AsSpan(), "123"));
+            Assert.Throws<FormatException>(() => dict.GetAlternateLookup<ReadOnlySpan<char>>().TryAdd("123".AsSpan(), "123"));
             Assert.Equal(0, dict.Count);
 
             dict.Add("123", "123");
@@ -408,7 +162,7 @@ public void Dictionary_NotCorruptedByNullReturningComparer()
 
             Assert.Equal(0, dict.Count);
 
-            Assert.ThrowsAny<ArgumentException>(() => dict.GetAlternateLookup<string, string, ReadOnlySpan<char>>().TryAdd("123".AsSpan(), "123"));
+            Assert.ThrowsAny<ArgumentException>(() => dict.GetAlternateLookup<ReadOnlySpan<char>>().TryAdd("123".AsSpan(), "123"));
             Assert.Equal(0, dict.Count);
 
             dict.Add("123", "123");
@@ -422,7 +176,7 @@ public void HashSet_NotCorruptedByThrowingComparer()
 
             Assert.Equal(0, set.Count);
 
-            Assert.Throws<FormatException>(() => set.GetAlternateLookup<string, ReadOnlySpan<char>>().Add("123".AsSpan()));
+            Assert.Throws<FormatException>(() => set.GetAlternateLookup<ReadOnlySpan<char>>().Add("123".AsSpan()));
             Assert.Equal(0, set.Count);
 
             set.Add("123");
diff --git a/src/libraries/System.Collections/tests/Generic/Dictionary/Dictionary.Generic.Tests.cs b/src/libraries/System.Collections/tests/Generic/Dictionary/Dictionary.Generic.Tests.cs
index aa6133538895d4..470312be885c26 100644
--- a/src/libraries/System.Collections/tests/Generic/Dictionary/Dictionary.Generic.Tests.cs
+++ b/src/libraries/System.Collections/tests/Generic/Dictionary/Dictionary.Generic.Tests.cs
@@ -643,6 +643,136 @@ public void TrimExcess_Generic_DoesInvalidateEnumeration()
 
         #endregion
 
+        #region GetAlternateComparer
+        [Fact]
+        public void GetAlternateLookup_FailsWhenIncompatible()
+        {
+            var dictionary = new Dictionary<string, string>(StringComparer.Ordinal);
+
+            dictionary.GetAlternateLookup<ReadOnlySpan<char>>();
+            Assert.True(dictionary.TryGetAlternateLookup<ReadOnlySpan<char>>(out _));
+
+            Assert.Throws<InvalidOperationException>(() => dictionary.GetAlternateLookup<ReadOnlySpan<byte>>());
+            Assert.Throws<InvalidOperationException>(() => dictionary.GetAlternateLookup<string>());
+            Assert.Throws<InvalidOperationException>(() => dictionary.GetAlternateLookup<int>());
+
+            Assert.False(dictionary.TryGetAlternateLookup<ReadOnlySpan<byte>>(out _));
+            Assert.False(dictionary.TryGetAlternateLookup<string>(out _));
+            Assert.False(dictionary.TryGetAlternateLookup<int>(out _));
+        }
+
+        public static IEnumerable<object[]> Dictionary_GetAlternateLookup_OperationsMatchUnderlyingDictionary_MemberData()
+        {
+            yield return new object[] { EqualityComparer<string>.Default };
+            yield return new object[] { StringComparer.Ordinal };
+            yield return new object[] { StringComparer.OrdinalIgnoreCase };
+            yield return new object[] { StringComparer.InvariantCulture };
+            yield return new object[] { StringComparer.InvariantCultureIgnoreCase };
+            yield return new object[] { StringComparer.CurrentCulture };
+            yield return new object[] { StringComparer.CurrentCultureIgnoreCase };
+        }
+
+        [Theory]
+        [MemberData(nameof(Dictionary_GetAlternateLookup_OperationsMatchUnderlyingDictionary_MemberData))]
+        public void Dictionary_GetAlternateLookup_OperationsMatchUnderlyingDictionary(IEqualityComparer<string> comparer)
+        {
+            // Test with a variety of comparers to ensure that the alternate lookup is consistent with the underlying dictionary
+            Dictionary<string, int> dictionary = new(comparer);
+            Dictionary<string, int>.AlternateLookup<ReadOnlySpan<char>> lookup = dictionary.GetAlternateLookup<ReadOnlySpan<char>>();
+            Assert.Same(dictionary, lookup.Dictionary);
+            Assert.Same(lookup.Dictionary, lookup.Dictionary);
+
+            string actualKey;
+            int value;
+
+            // Add to the dictionary and validate that the lookup reflects the changes
+            dictionary["123"] = 123;
+            Assert.True(lookup.ContainsKey("123".AsSpan()));
+            Assert.True(lookup.TryGetValue("123".AsSpan(), out value));
+            Assert.Equal(123, value);
+            Assert.Equal(123, lookup["123".AsSpan()]);
+            Assert.False(lookup.TryAdd("123".AsSpan(), 321));
+            Assert.True(lookup.Remove("123".AsSpan()));
+            Assert.False(dictionary.ContainsKey("123"));
+            Assert.Throws<KeyNotFoundException>(() => lookup["123".AsSpan()]);
+
+            // Add via the lookup and validate that the dictionary reflects the changes
+            Assert.True(lookup.TryAdd("123".AsSpan(), 123));
+            Assert.True(dictionary.ContainsKey("123"));
+            lookup.TryGetValue("123".AsSpan(), out value);
+            Assert.Equal(123, value);
+            Assert.False(lookup.Remove("321".AsSpan(), out actualKey, out value));
+            Assert.Null(actualKey);
+            Assert.Equal(0, value);
+            Assert.True(lookup.Remove("123".AsSpan(), out actualKey, out value));
+            Assert.Equal("123", actualKey);
+            Assert.Equal(123, value);
+
+            // Ensure that case-sensitivity of the comparer is respected
+            lookup["a".AsSpan()] = 42;
+            if (dictionary.Comparer.Equals(EqualityComparer<string>.Default) ||
+                dictionary.Comparer.Equals(StringComparer.Ordinal) ||
+                dictionary.Comparer.Equals(StringComparer.InvariantCulture) ||
+                dictionary.Comparer.Equals(StringComparer.CurrentCulture))
+            {
+                Assert.True(lookup.TryGetValue("a".AsSpan(), out actualKey, out value));
+                Assert.Equal("a", actualKey);
+                Assert.Equal(42, value);
+                Assert.True(lookup.TryAdd("A".AsSpan(), 42));
+                Assert.True(lookup.Remove("a".AsSpan()));
+                Assert.False(lookup.Remove("a".AsSpan()));
+                Assert.True(lookup.Remove("A".AsSpan()));
+            }
+            else
+            {
+                Assert.True(lookup.TryGetValue("A".AsSpan(), out actualKey, out value));
+                Assert.Equal("a", actualKey);
+                Assert.Equal(42, value);
+                Assert.False(lookup.TryAdd("A".AsSpan(), 42));
+                Assert.True(lookup.Remove("A".AsSpan()));
+                Assert.False(lookup.Remove("a".AsSpan()));
+                Assert.False(lookup.Remove("A".AsSpan()));
+            }
+
+            // Validate overwrites
+            lookup["a".AsSpan()] = 42;
+            Assert.Equal(42, dictionary["a"]);
+            lookup["a".AsSpan()] = 43;
+            Assert.True(lookup.Remove("a".AsSpan(), out actualKey, out value));
+            Assert.Equal("a", actualKey);
+            Assert.Equal(43, value);
+
+            // Test adding multiple entries via the lookup
+            for (int i = 0; i < 10; i++)
+            {
+                Assert.Equal(i, dictionary.Count);
+                Assert.True(lookup.TryAdd(i.ToString().AsSpan(), i));
+                Assert.False(lookup.TryAdd(i.ToString().AsSpan(), i));
+            }
+
+            Assert.Equal(10, dictionary.Count);
+
+            // Test that the lookup and the dictionary agree on what's in and not in
+            for (int i = -1; i <= 10; i++)
+            {
+                Assert.Equal(dictionary.TryGetValue(i.ToString(), out int dv), lookup.TryGetValue(i.ToString().AsSpan(), out int lv));
+                Assert.Equal(dv, lv);
+            }
+
+            // Test removing multiple entries via the lookup
+            for (int i = 9; i >= 0; i--)
+            {
+                Assert.True(lookup.Remove(i.ToString().AsSpan(), out actualKey, out value));
+                Assert.Equal(i.ToString(), actualKey);
+                Assert.Equal(i, value);
+                Assert.False(lookup.Remove(i.ToString().AsSpan(), out actualKey, out value));
+                Assert.Null(actualKey);
+                Assert.Equal(0, value);
+                Assert.Equal(i, dictionary.Count);
+            }
+        }
+        #endregion
+
         #region Non-randomized comparers
         [Fact]
         public void Dictionary_Comparer_NonRandomizedStringComparers()
diff --git a/src/libraries/System.Collections/tests/Generic/Dictionary/HashCollisionScenarios/OutOfBoundsRegression.cs b/src/libraries/System.Collections/tests/Generic/Dictionary/HashCollisionScenarios/OutOfBoundsRegression.cs
index 12e979cf40da27..e131d4bb25ee5d 100644
--- a/src/libraries/System.Collections/tests/Generic/Dictionary/HashCollisionScenarios/OutOfBoundsRegression.cs
+++ b/src/libraries/System.Collections/tests/Generic/Dictionary/HashCollisionScenarios/OutOfBoundsRegression.cs
@@ -17,7 +17,7 @@ public class InternalHashCodeTests_Dictionary_NullComparer : InternalHashCodeTes
         protected override void AddKey(Dictionary<string, string> collection, string key) => collection.Add(key, key);
         protected override bool ContainsKey(Dictionary<string, string> collection, string key) => collection.ContainsKey(key);
         protected override bool ContainsKey(Dictionary<string, string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, string, ReadOnlySpan<char>>().ContainsKey(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().ContainsKey(key);
         protected override IEqualityComparer<string> GetComparer(Dictionary<string, string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
@@ -61,7 +61,7 @@ public class InternalHashCodeTests_Dictionary_DefaultComparer : InternalHashCode
         protected override void AddKey(Dictionary<string, string> collection, string key) => collection.Add(key, key);
         protected override bool ContainsKey(Dictionary<string, string> collection, string key) => collection.ContainsKey(key);
         protected override bool ContainsKey(Dictionary<string, string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, string, ReadOnlySpan<char>>().ContainsKey(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().ContainsKey(key);
         protected override IEqualityComparer<string> GetComparer(Dictionary<string, string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
@@ -75,7 +75,7 @@ public class InternalHashCodeTests_Dictionary_OrdinalComparer : InternalHashCode
         protected override void AddKey(Dictionary<string, string> collection, string key) => collection.Add(key, key);
         protected override bool ContainsKey(Dictionary<string, string> collection, string key) => collection.ContainsKey(key);
         protected override bool ContainsKey(Dictionary<string, string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, string, ReadOnlySpan<char>>().ContainsKey(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().ContainsKey(key);
         protected override IEqualityComparer<string> GetComparer(Dictionary<string, string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
@@ -89,7 +89,7 @@ public class InternalHashCodeTests_Dictionary_OrdinalIgnoreCaseComparer : Intern
         protected override void AddKey(Dictionary<string, string> collection, string key) => collection.Add(key, key);
         protected override bool ContainsKey(Dictionary<string, string> collection, string key) => collection.ContainsKey(key);
         protected override bool ContainsKey(Dictionary<string, string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, string, ReadOnlySpan<char>>().ContainsKey(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().ContainsKey(key);
         protected override IEqualityComparer<string> GetComparer(Dictionary<string, string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalIgnoreCaseComparerType;
@@ -103,7 +103,7 @@ public class InternalHashCodeTests_Dictionary_LinguisticComparer : InternalHashC
         protected override void AddKey(Dictionary<string, string> collection, string key) => collection.Add(key, key);
         protected override bool ContainsKey(Dictionary<string, string> collection, string key) => collection.ContainsKey(key);
         protected override bool ContainsKey(Dictionary<string, string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, string, ReadOnlySpan<char>>().ContainsKey(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().ContainsKey(key);
         protected override IEqualityComparer<string> GetComparer(Dictionary<string, string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => StringComparer.InvariantCulture.GetType();
@@ -119,7 +119,7 @@ public class InternalHashCodeTests_Dictionary_GetValueRefOrAddDefault : Internal
         protected override void AddKey(Dictionary<string, string> collection, string key) => CollectionsMarshal.GetValueRefOrAddDefault(collection, key, out _) = null;
         protected override bool ContainsKey(Dictionary<string, string> collection, string key) => collection.ContainsKey(key);
         protected override bool ContainsKey(Dictionary<string, string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, string, ReadOnlySpan<char>>().ContainsKey(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().ContainsKey(key);
         protected override IEqualityComparer<string> GetComparer(Dictionary<string, string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
@@ -135,7 +135,7 @@ public class InternalHashCodeTests_HashSet_NullComparer : InternalHashCodeTests<
         protected override void AddKey(HashSet<string> collection, string key) => collection.Add(key);
         protected override bool ContainsKey(HashSet<string> collection, string key) => collection.Contains(key);
         protected override bool ContainsKey(HashSet<string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, ReadOnlySpan<char>>().Contains(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().Contains(key);
         protected override IEqualityComparer<string> GetComparer(HashSet<string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
@@ -149,7 +149,7 @@ public class InternalHashCodeTests_HashSet_DefaultComparer : InternalHashCodeTes
         protected override void AddKey(HashSet<string> collection, string key) => collection.Add(key);
         protected override bool ContainsKey(HashSet<string> collection, string key) => collection.Contains(key);
         protected override bool ContainsKey(HashSet<string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, ReadOnlySpan<char>>().Contains(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().Contains(key);
         protected override IEqualityComparer<string> GetComparer(HashSet<string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
@@ -163,7 +163,7 @@ public class InternalHashCodeTests_HashSet_OrdinalComparer : InternalHashCodeTes
         protected override void AddKey(HashSet<string> collection, string key) => collection.Add(key);
         protected override bool ContainsKey(HashSet<string> collection, string key) => collection.Contains(key);
         protected override bool ContainsKey(HashSet<string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, ReadOnlySpan<char>>().Contains(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().Contains(key);
         protected override IEqualityComparer<string> GetComparer(HashSet<string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalComparerType;
@@ -177,7 +177,7 @@ public class InternalHashCodeTests_HashSet_OrdinalIgnoreCaseComparer : InternalH
         protected override void AddKey(HashSet<string> collection, string key) => collection.Add(key);
         protected override bool ContainsKey(HashSet<string> collection, string key) => collection.Contains(key);
         protected override bool ContainsKey(HashSet<string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, ReadOnlySpan<char>>().Contains(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().Contains(key);
         protected override IEqualityComparer<string> GetComparer(HashSet<string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => nonRandomizedOrdinalIgnoreCaseComparerType;
@@ -191,7 +191,7 @@ public class InternalHashCodeTests_HashSet_LinguisticComparer : InternalHashCode
         protected override void AddKey(HashSet<string> collection, string key) => collection.Add(key);
         protected override bool ContainsKey(HashSet<string> collection, string key) => collection.Contains(key);
         protected override bool ContainsKey(HashSet<string> collection, ReadOnlySpan<char> key) =>
-            collection.GetAlternateLookup<string, ReadOnlySpan<char>>().Contains(key);
+            collection.GetAlternateLookup<ReadOnlySpan<char>>().Contains(key);
         protected override IEqualityComparer<string> GetComparer(HashSet<string> collection) => collection.Comparer;
 
         protected override Type ExpectedInternalComparerTypeBeforeCollisionThreshold => StringComparer.InvariantCulture.GetType();
diff --git a/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.Generic.Tests.cs b/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.Generic.Tests.cs
index 30b387a486fbd1..e3d4829cdaba17 100644
--- a/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.Generic.Tests.cs
+++ b/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.Generic.Tests.cs
@@ -416,6 +416,121 @@ public void SetComparer_SequenceEqualTests()
 
         #endregion
 
+        #region GetAlternateLookup
+        [Fact]
+        public void GetAlternateLookup_FailsWhenIncompatible()
+        {
+            var hashSet = new HashSet<string>(StringComparer.Ordinal);
+
+            hashSet.GetAlternateLookup<ReadOnlySpan<char>>();
+            Assert.True(hashSet.TryGetAlternateLookup<ReadOnlySpan<char>>(out _));
+
+            Assert.Throws<InvalidOperationException>(() => hashSet.GetAlternateLookup<ReadOnlySpan<byte>>());
+            Assert.Throws<InvalidOperationException>(() => hashSet.GetAlternateLookup<string>());
+            Assert.Throws<InvalidOperationException>(() => hashSet.GetAlternateLookup<int>());
+
+            Assert.False(hashSet.TryGetAlternateLookup<ReadOnlySpan<byte>>(out _));
+            Assert.False(hashSet.TryGetAlternateLookup<string>(out _));
+            Assert.False(hashSet.TryGetAlternateLookup<int>(out _));
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        [InlineData(4)]
+        [InlineData(5)]
+        public void HashSet_GetAlternateLookup_OperationsMatchUnderlyingSet(int mode)
+        {
+            // Test with a variety of comparers to ensure that the alternate lookup is consistent with the underlying set
+            HashSet<string> set = new(mode switch
+            {
+                0 => StringComparer.Ordinal,
+                1 => StringComparer.OrdinalIgnoreCase,
+                2 => StringComparer.InvariantCulture,
+                3 => StringComparer.InvariantCultureIgnoreCase,
+                4 => StringComparer.CurrentCulture,
+                5 => StringComparer.CurrentCultureIgnoreCase,
+                _ => throw new ArgumentOutOfRangeException(nameof(mode))
+            });
+            HashSet<string>.AlternateLookup<ReadOnlySpan<char>> lookup = set.GetAlternateLookup<ReadOnlySpan<char>>();
+            Assert.Same(set, lookup.Set);
+            Assert.Same(lookup.Set, lookup.Set);
+
+            // Add to the set and validate that the lookup reflects the changes
+            Assert.True(set.Add("123"));
+            Assert.True(lookup.Contains("123".AsSpan()));
+            Assert.False(lookup.Add("123".AsSpan()));
+            Assert.True(lookup.Remove("123".AsSpan()));
+            Assert.False(set.Contains("123"));
+
+            // Add via the lookup and validate that the set reflects the changes
+            Assert.True(lookup.Add("123".AsSpan()));
+            Assert.True(set.Contains("123"));
+            lookup.TryGetValue("123".AsSpan(), out string value);
+            Assert.Equal("123", value);
+            Assert.False(lookup.Remove("321".AsSpan()));
+            Assert.True(lookup.Remove("123".AsSpan()));
+
+            // Ensure that case-sensitivity of the comparer is respected
+            Assert.True(lookup.Add("a"));
+            if (set.Comparer.Equals(StringComparer.Ordinal) ||
+                set.Comparer.Equals(StringComparer.InvariantCulture) ||
+                set.Comparer.Equals(StringComparer.CurrentCulture))
+            {
+                Assert.True(lookup.Add("A".AsSpan()));
+                Assert.True(lookup.Remove("a".AsSpan()));
+                Assert.False(lookup.Remove("a".AsSpan()));
+                Assert.True(lookup.Remove("A".AsSpan()));
+            }
+            else
+            {
+                Assert.False(lookup.Add("A".AsSpan()));
+                Assert.True(lookup.Remove("A".AsSpan()));
+                Assert.False(lookup.Remove("a".AsSpan()));
+                Assert.False(lookup.Remove("A".AsSpan()));
+            }
+
+            // Test the behavior of null vs "" in the set and lookup
+            Assert.True(set.Add(null));
+            Assert.True(set.Add(string.Empty));
+            Assert.True(set.Contains(null));
+            Assert.True(set.Contains(""));
+            Assert.True(lookup.Contains("".AsSpan()));
+            Assert.True(lookup.Remove("".AsSpan()));
+            Assert.Equal(1, set.Count);
+            Assert.False(lookup.Remove("".AsSpan()));
+            Assert.True(set.Remove(null));
+            Assert.Equal(0, set.Count);
+
+            // Test adding multiple entries via the lookup
+            for (int i = 0; i < 10; i++)
+            {
+                Assert.Equal(i, set.Count);
+                Assert.True(lookup.Add(i.ToString().AsSpan()));
+                Assert.False(lookup.Add(i.ToString().AsSpan()));
+            }
+
+            Assert.Equal(10, set.Count);
+
+            // Test that the lookup and the set agree on what's in and not in
+            for (int i = -1; i <= 10; i++)
+            {
+                Assert.Equal(set.TryGetValue(i.ToString(), out string dv), lookup.TryGetValue(i.ToString().AsSpan(), out string lv));
+                Assert.Equal(dv, lv);
+            }
+
+            // Test removing multiple entries via the lookup
+            for (int i = 9; i >= 0; i--)
+            {
+                Assert.True(lookup.Remove(i.ToString().AsSpan()));
+                Assert.False(lookup.Remove(i.ToString().AsSpan()));
+                Assert.Equal(i, set.Count);
+            }
+        }
+        #endregion
+
         [Fact]
         public void CanBeCastedToISet()
         {
diff --git a/src/libraries/System.Console/src/System/IO/KeyParser.cs b/src/libraries/System.Console/src/System/IO/KeyParser.cs
index 2b4cff2502c2c6..317c1a814beb06 100644
--- a/src/libraries/System.Console/src/System/IO/KeyParser.cs
+++ b/src/libraries/System.Console/src/System/IO/KeyParser.cs
@@ -63,7 +63,7 @@ private static bool TryParseTerminalInputSequence(char[] buffer, TerminalFormatS
         }
 
         Dictionary<string, ConsoleKeyInfo>.AlternateLookup<ReadOnlySpan<char>> terminfoDb = // the most important source of truth
-            terminalFormatStrings.KeyFormatToConsoleKey.GetAlternateLookup<string, ConsoleKeyInfo, ReadOnlySpan<char>>();
+            terminalFormatStrings.KeyFormatToConsoleKey.GetAlternateLookup<ReadOnlySpan<char>>();
         ConsoleModifiers modifiers = ConsoleModifiers.None;
         ConsoleKey key;
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/CollectionExtensions.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/CollectionExtensions.cs
index f2d3e45286042f..cf4256f546d59f 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/CollectionExtensions.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/CollectionExtensions.cs
@@ -160,127 +160,5 @@ public static void CopyTo<T>(this List<T> list, Span<T> destination)
 
             new ReadOnlySpan<T>(list._items, 0, list._size).CopyTo(destination);
         }
-
-        /// <summary>
-        /// Gets an instance of a type that may be used to perform operations on a <see cref="Dictionary{TKey, TValue}"/>
-        /// using a <typeparamref name="TAlternateKey"/> as a key instead of a <typeparamref name="TKey"/>.
-        /// </summary>
-        /// <typeparam name="TKey">The type of the keys used by the dictionary instance.</typeparam>
-        /// <typeparam name="TValue">The type of the values used by the dictionary instance.</typeparam>
-        /// <typeparam name="TAlternateKey">The alternate type of a key for performing lookups.</typeparam>
-        /// <param name="dictionary">The dictionary instance.</param>
-        /// <returns>The created lookup instance.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="dictionary"/> is null.</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="dictionary"/>'s comparer is not compatible with <typeparamref name="TAlternateKey"/>.</exception>
-        /// <remarks>
-        /// The supplied <paramref name="dictionary"/> must be using a comparer that implements <see cref="IAlternateEqualityComparer{TAlternateKey, TKey}"/> with
-        /// <typeparamref name="TAlternateKey"/> and <typeparamref name="TKey"/>. If it doesn't, an exception will be thrown.
-        /// </remarks>
-        public static Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey> GetAlternateLookup<TKey, TValue, TAlternateKey>(
-            this Dictionary<TKey, TValue> dictionary)
-            where TKey : notnull
-            where TAlternateKey : notnull, allows ref struct
-        {
-            ArgumentNullException.ThrowIfNull(dictionary);
-
-            if (!Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey>.IsCompatibleKey(dictionary))
-            {
-                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IncompatibleComparer);
-            }
-
-            return new Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey>(dictionary);
-        }
-
-        /// <summary>
-        /// Gets an instance of a type that may be used to perform operations on a <see cref="Dictionary{TKey, TValue}"/>
-        /// using a <typeparamref name="TAlternateKey"/> as a key instead of a <typeparamref name="TKey"/>.
-        /// </summary>
-        /// <typeparam name="TKey">The type of the keys used by the dictionary instance.</typeparam>
-        /// <typeparam name="TValue">The type of the values used by the dictionary instance.</typeparam>
-        /// <typeparam name="TAlternateKey">The alternate type of a key for performing lookups.</typeparam>
-        /// <param name="dictionary">The dictionary instance.</param>
-        /// <param name="lookup">The created lookup instance when the method returns true, or a default instance that should not be used if the method returns false.</param>
-        /// <returns>true if a lookup could be created; otherwise, false.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="dictionary"/> is null.</exception>
-        /// <remarks>
-        /// The supplied <paramref name="dictionary"/> must be using a comparer that implements <see cref="IAlternateEqualityComparer{TAlternateKey, TKey}"/> with
-        /// <typeparamref name="TAlternateKey"/> and <typeparamref name="TKey"/>. If it doesn't, the method will return false.
-        /// </remarks>
-        public static bool TryGetAlternateLookup<TKey, TValue, TAlternateKey>(
-            this Dictionary<TKey, TValue> dictionary,
-            out Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey> lookup)
-            where TKey : notnull
-            where TAlternateKey : notnull, allows ref struct
-        {
-            ArgumentNullException.ThrowIfNull(dictionary);
-
-            if (Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey>.IsCompatibleKey(dictionary))
-            {
-                lookup = new Dictionary<TKey, TValue>.AlternateLookup<TAlternateKey>(dictionary);
-                return true;
-            }
-
-            lookup = default;
-            return false;
-        }
-
-        /// <summary>
-        /// Gets an instance of a type that may be used to perform operations on a <see cref="HashSet{T}"/>
-        /// using a <typeparamref name="TAlternate"/> instead of a <typeparamref name="T"/>.
-        /// </summary>
-        /// <typeparam name="T">The type of the items used by the set instance.</typeparam>
-        /// <typeparam name="TAlternate">The alternate type of instance for performing lookups.</typeparam>
-        /// <param name="set">The set instance.</param>
-        /// <returns>The created lookup instance.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="set"/> is null.</exception>
-        /// <exception cref="InvalidOperationException"><paramref name="set"/>'s comparer is not compatible with <typeparamref name="TAlternate"/>.</exception>
-        /// <remarks>
-        /// The supplied <paramref name="set"/> must be using a comparer that implements <see cref="IAlternateEqualityComparer{TAlternate, T}"/> with
-        /// <typeparamref name="TAlternate"/> and <typeparamref name="T"/>. If it doesn't, an exception will be thrown.
-        /// </remarks>
-        public static HashSet<T>.AlternateLookup<TAlternate> GetAlternateLookup<T, TAlternate>(
-            this HashSet<T> set)
-            where TAlternate : allows ref struct
-        {
-            ArgumentNullException.ThrowIfNull(set);
-
-            if (!HashSet<T>.AlternateLookup<TAlternate>.IsCompatibleItem(set))
-            {
-                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IncompatibleComparer);
-            }
-
-            return new HashSet<T>.AlternateLookup<TAlternate>(set);
-        }
-
-        /// <summary>
-        /// Gets an instance of a type that may be used to perform operations on a <see cref="HashSet{T}"/>
-        /// using a <typeparamref name="TAlternate"/> instead of a <typeparamref name="T"/>.
-        /// </summary>
-        /// <typeparam name="T">The type of the items used by the set instance.</typeparam>
-        /// <typeparam name="TAlternate">The alternate type of instance for performing lookups.</typeparam>
-        /// <param name="set">The set instance.</param>
-        /// <param name="lookup">The created lookup instance when the method returns true, or a default instance that should not be used if the method returns false.</param>
-        /// <returns>true if a lookup could be created; otherwise, false.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="set"/> is null.</exception>
-        /// <remarks>
-        /// The supplied <paramref name="set"/> must be using a comparer that implements <see cref="IAlternateEqualityComparer{TAlternate, T}"/> with
-        /// <typeparamref name="TAlternate"/> and <typeparamref name="T"/>. If it doesn't, the method returns false.
-        /// </remarks>
-        public static bool TryGetAlternateLookup<T, TAlternate>(
-            this HashSet<T> set,
-            out HashSet<T>.AlternateLookup<TAlternate> lookup)
-            where TAlternate : allows ref struct
-        {
-            ArgumentNullException.ThrowIfNull(set);
-
-            if (HashSet<T>.AlternateLookup<TAlternate>.IsCompatibleItem(set))
-            {
-                lookup = new HashSet<T>.AlternateLookup<TAlternate>(set);
-                return true;
-            }
-
-            lookup = default;
-            return false;
-        }
     }
 }
diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/Dictionary.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/Dictionary.cs
index 87583ded8e4558..c7c17490268da7 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/Dictionary.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/Dictionary.cs
@@ -635,6 +635,53 @@ private bool TryInsert(TKey key, TValue value, InsertionBehavior behavior)
             return true;
         }
 
+        /// <summary>
+        /// Gets an instance of a type that may be used to perform operations on the current <see cref="Dictionary{TKey, TValue}"/>
+        /// using a <typeparamref name="TAlternateKey"/> as a key instead of a <typeparamref name="TKey"/>.
+        /// </summary>
+        /// <typeparam name="TAlternateKey">The alternate type of a key for performing lookups.</typeparam>
+        /// <returns>The created lookup instance.</returns>
+        /// <exception cref="InvalidOperationException">The dictionary's comparer is not compatible with <typeparamref name="TAlternateKey"/>.</exception>
+        /// <remarks>
+        /// The dictionary must be using a comparer that implements <see cref="IAlternateEqualityComparer{TAlternateKey, TKey}"/> with
+        /// <typeparamref name="TAlternateKey"/> and <typeparamref name="TKey"/>. If it doesn't, an exception will be thrown.
+        /// </remarks>
+        public AlternateLookup<TAlternateKey> GetAlternateLookup<TAlternateKey>()
+            where TAlternateKey : notnull, allows ref struct
+        {
+            if (!AlternateLookup<TAlternateKey>.IsCompatibleKey(this))
+            {
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IncompatibleComparer);
+            }
+
+            return new AlternateLookup<TAlternateKey>(this);
+        }
+
+        /// <summary>
+        /// Gets an instance of a type that may be used to perform operations on the current <see cref="Dictionary{TKey, TValue}"/>
+        /// using a <typeparamref name="TAlternateKey"/> as a key instead of a <typeparamref name="TKey"/>.
+        /// </summary>
+        /// <typeparam name="TAlternateKey">The alternate type of a key for performing lookups.</typeparam>
+        /// <param name="lookup">The created lookup instance when the method returns true, or a default instance that should not be used if the method returns false.</param>
+        /// <returns>true if a lookup could be created; otherwise, false.</returns>
+        /// <remarks>
+        /// The dictionary must be using a comparer that implements <see cref="IAlternateEqualityComparer{TAlternateKey, TKey}"/> with
+        /// <typeparamref name="TAlternateKey"/> and <typeparamref name="TKey"/>. If it doesn't, the method will return false.
+        /// </remarks>
+        public bool TryGetAlternateLookup<TAlternateKey>(
+            out AlternateLookup<TAlternateKey> lookup)
+            where TAlternateKey : notnull, allows ref struct
+        {
+            if (AlternateLookup<TAlternateKey>.IsCompatibleKey(this))
+            {
+                lookup = new AlternateLookup<TAlternateKey>(this);
+                return true;
+            }
+
+            lookup = default;
+            return false;
+        }
+
         /// <summary>
         /// Provides a type that may be used to perform operations on a <see cref="Dictionary{TKey, TValue}"/>
         /// using a <typeparamref name="TAlternateKey"/> as a key instead of a <typeparamref name="TKey"/>.
diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/HashSet.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/HashSet.cs
index ba6d497a29f890..621af08d72a840 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/HashSet.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/HashSet.cs
@@ -365,6 +365,52 @@ public bool Remove(T item)
 
         #region AlternateLookup
 
+        /// <summary>
+        /// Gets an instance of a type that may be used to perform operations on the current <see cref="HashSet{T}"/>
+        /// using a <typeparamref name="TAlternate"/> instead of a <typeparamref name="T"/>.
+        /// </summary>
+        /// <typeparam name="TAlternate">The alternate type of instance for performing lookups.</typeparam>
+        /// <returns>The created lookup instance.</returns>
+        /// <exception cref="InvalidOperationException">The set's comparer is not compatible with <typeparamref name="TAlternate"/>.</exception>
+        /// <remarks>
+        /// The set must be using a comparer that implements <see cref="IAlternateEqualityComparer{TAlternate, T}"/> with
+        /// <typeparamref name="TAlternate"/> and <typeparamref name="T"/>. If it doesn't, an exception will be thrown.
+        /// </remarks>
+        public AlternateLookup<TAlternate> GetAlternateLookup<TAlternate>()
+            where TAlternate : allows ref struct
+        {
+            if (!AlternateLookup<TAlternate>.IsCompatibleItem(this))
+            {
+                ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_IncompatibleComparer);
+            }
+
+            return new AlternateLookup<TAlternate>(this);
+        }
+
+        /// <summary>
+        /// Gets an instance of a type that may be used to perform operations on the current <see cref="HashSet{T}"/>
+        /// using a <typeparamref name="TAlternate"/> instead of a <typeparamref name="T"/>.
+        /// </summary>
+        /// <typeparam name="TAlternate">The alternate type of instance for performing lookups.</typeparam>
+        /// <param name="lookup">The created lookup instance when the method returns true, or a default instance that should not be used if the method returns false.</param>
+        /// <returns>true if a lookup could be created; otherwise, false.</returns>
+        /// <remarks>
+        /// The set must be using a comparer that implements <see cref="IAlternateEqualityComparer{TAlternate, T}"/> with
+        /// <typeparamref name="TAlternate"/> and <typeparamref name="T"/>. If it doesn't, the method returns false.
+        /// </remarks>
+        public bool TryGetAlternateLookup<TAlternate>(out AlternateLookup<TAlternate> lookup)
+            where TAlternate : allows ref struct
+        {
+            if (AlternateLookup<TAlternate>.IsCompatibleItem(this))
+            {
+                lookup = new AlternateLookup<TAlternate>(this);
+                return true;
+            }
+
+            lookup = default;
+            return false;
+        }
+
         /// <summary>
         /// Provides a type that may be used to perform operations on a <see cref="HashSet{T}"/>
         /// using a <typeparamref name="TAlternate"/> instead of a <typeparamref name="T"/>.
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/JsonHelpers.cs b/src/libraries/System.Text.Json/src/System/Text/Json/JsonHelpers.cs
index d6ade630a39864..f16e637835cf48 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/JsonHelpers.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/JsonHelpers.cs
@@ -223,7 +223,7 @@ public static bool TryLookupUtf8Key<TValue>(
             Debug.Assert(dictionary.Comparer is IAlternateEqualityComparer<ReadOnlySpan<char>, string>);
 
             Dictionary<string, TValue>.AlternateLookup<ReadOnlySpan<char>> spanLookup =
-                dictionary.GetAlternateLookup<string, TValue, ReadOnlySpan<char>>();
+                dictionary.GetAlternateLookup<ReadOnlySpan<char>>();
 
             char[]? rentedBuffer = null;
 
diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverter.cs
index e5006d23b84d4d..901cff255baa91 100644
--- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverter.cs
+++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Value/EnumConverter.cs
@@ -304,7 +304,7 @@ private bool TryParseNamedEnum(
             out T result)
         {
 #if NET9_0_OR_GREATER
-            Dictionary<string, EnumFieldInfo>.AlternateLookup<ReadOnlySpan<char>> lookup = _enumFieldInfoIndex.GetAlternateLookup<string, EnumFieldInfo, ReadOnlySpan<char>>();
+            Dictionary<string, EnumFieldInfo>.AlternateLookup<ReadOnlySpan<char>> lookup = _enumFieldInfoIndex.GetAlternateLookup<ReadOnlySpan<char>>();
             ReadOnlySpan<char> rest = source;
 #else
             Dictionary<string, EnumFieldInfo> lookup = _enumFieldInfoIndex;