Implement EqualityComparer<T>.Create with key selector parameters

Author: weitzhandler

src/libraries/System.Collections/ref/System.Collections.cs

@@ -756,6 +756,7 @@ public abstract partial class EqualityComparer<T> : System.Collections.Generic.I
     {
         protected EqualityComparer() { }
         public static System.Collections.Generic.EqualityComparer<T> Create(System.Func<T?, T?, bool> equals, System.Func<T, int>? getHashCode = null) { throw null; }
+        public static System.Collections.Generic.EqualityComparer<T> Create<TKey>(System.Func<T?, TKey?> keySelector, IEqualityComparer<TKey>? keyComparer = null) { throw null; }
         public static System.Collections.Generic.EqualityComparer<T> Default { get { throw null; } }
         public abstract bool Equals(T? x, T? y);
         public abstract int GetHashCode([System.Diagnostics.CodeAnalysis.DisallowNullAttribute] T obj);

src/libraries/System.Collections/tests/Generic/Comparers/EqualityComparer.Tests.cs

@@ -518,6 +518,50 @@ public void EqualityComparerCreate_DelegatesUsed()
             Assert.Equal(2, getHashCodeCalls);
         }
 
+        [Fact]
+        public void EqualityComparerCreate_KeySelectorNull_Throws()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("keySelector", () => EqualityComparer<string>.Create<int>(keySelector: null));
+        }
+
+        [Fact]
+        public void EqualityComparerCreate_KeySelectorUsed()
+        {
+            var original = "foo";
+            var otherEqualLen = "bar";
+            var otherLongerLen = "fooo";
+
+            var comparer = EqualityComparer<string>.Create(str => str.Length);
+
+            Assert.True(comparer.Equals(original, original));
+            Assert.True(comparer.Equals(original, otherEqualLen));
+            Assert.False(comparer.Equals(original, otherLongerLen));
+        }
+
+        [Fact]
+        public void EqualityComparerCreate_KeySelectorComparerUsed()
+        {
+            var evenLen1 = "12";
+            var evenLen2 = "1234";
+            var evenLen3 = "123456";
+            var oddLen1 = "1";
+            var oddLen2 = "123";
+
+            bool isEven(int len) => len % 2 == 0;
+
+            var evenOrOddComparer = EqualityComparer<int>.Create(equals: (len1, len2) => isEven(len1) == isEven(len2), getHashCode: len => isEven(len) ? 0 : 1);
+            var comparer = EqualityComparer<string>.Create(str => str.Length, keyComparer: evenOrOddComparer);
+
+            Assert.True(comparer.Equals(evenLen1, evenLen1));
+            Assert.True(comparer.Equals(evenLen1, evenLen2));
+            Assert.True(comparer.Equals(evenLen1, evenLen3));
+            Assert.True(comparer.Equals(oddLen1, oddLen2));
+
+            Assert.False(comparer.Equals(evenLen1, oddLen1));
+            Assert.False(comparer.Equals(evenLen1, oddLen2));
+            Assert.False(comparer.Equals(oddLen1, evenLen2));
+        }
+
         [Fact]
         public void EqualityComparerCreate_ArgsNotDereferenced()
         {

src/libraries/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.cs

@@ -34,6 +34,35 @@ public static EqualityComparer<T> Create(Func<T?, T?, bool> equals, Func<T, int>
             return new DelegateEqualityComparer<T>(equals, getHashCode);
         }
 
+        /// <summary>
+        /// Creates an <see cref="EqualityComparer{T}"/> by using the specified key selector and optional key comparer.
+        /// </summary>
+        /// <param name="keySelector">The delegate to use to select a comparison key from each element.</param>
+        /// <param name="keyComparer">An optional comparer to use when comparing keys. The default comparer of <typeparamref name="TKey"/> is used if none is specified.</param>
+        /// <returns>The new comparer.</returns>
+        /// <exception cref="ArgumentNullException">The <paramref name="keySelector"/> delegate was null.</exception>
+        public static EqualityComparer<T> Create<TKey>(Func<T?, TKey?> keySelector, IEqualityComparer<TKey>? keyComparer = null)
+        {
+            ArgumentNullException.ThrowIfNull(keySelector);
+
+            keyComparer ??= EqualityComparer<TKey>.Default;
+
+            return new DelegateEqualityComparer<T>(
+                equals: (itemX, itemY) =>
+                    keyComparer.Equals(x: keySelector(itemX), y: keySelector(itemY)),
+                getHashCode: obj =>
+                {
+                    if (obj is null)
+                    {
+                        return 0;
+                    }
+
+                    TKey? key = keySelector(obj);
+
+                    return key == null ? 0 : keyComparer.GetHashCode(key);
+                });
+        }
+
         public abstract bool Equals(T? x, T? y);
         public abstract int GetHashCode([DisallowNull] T obj);