Add GroupJoin overload returning IGrouping<TOuter, TInner>

src/libraries/System.Linq.Queryable/ref/System.Linq.Queryable.cs

@@ -108,6 +108,7 @@ public static partial class Queryable
         public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
         public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult>> resultSelector) { throw null; }
         public static System.Linq.IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, TKey>> keySelector, System.Linq.Expressions.Expression<System.Func<TSource, TElement>> elementSelector, System.Linq.Expressions.Expression<System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        public static System.Linq.IQueryable<System.Linq.IGrouping<TOuter, TInner>> GroupJoin<TOuter, TInner, TKey>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector) { throw null; }
         public static System.Linq.IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult>> resultSelector) { throw null; }
         public static System.Linq.IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Linq.IQueryable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Linq.Expressions.Expression<System.Func<TOuter, TKey>> outerKeySelector, System.Linq.Expressions.Expression<System.Func<TInner, TKey>> innerKeySelector, System.Linq.Expressions.Expression<System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
         public static System.Linq.IQueryable<(int Index, TSource Item)> Index<TSource>(this System.Linq.IQueryable<TSource> source) { throw null; }

src/libraries/System.Linq.Queryable/src/System/Linq/Queryable.cs

@@ -408,6 +408,21 @@ public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this IQuer
                     outer.Expression, GetSourceExpression(inner), Expression.Quote(outerKeySelector), Expression.Quote(innerKeySelector), Expression.Quote(resultSelector), Expression.Constant(comparer, typeof(IEqualityComparer<TKey>))));
         }
 
+        [DynamicDependency("GroupJoin`3", typeof(Enumerable))]
+        public static IQueryable<IGrouping<TOuter, TInner>> GroupJoin<TOuter, TInner, TKey>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector)
+        {
+            ArgumentNullException.ThrowIfNull(outer);
+            ArgumentNullException.ThrowIfNull(inner);
+            ArgumentNullException.ThrowIfNull(outerKeySelector);
+            ArgumentNullException.ThrowIfNull(innerKeySelector);
+
+            return outer.Provider.CreateQuery<IGrouping<TOuter, TInner>>(
+                Expression.Call(
+                    null,
+                    new Func<IQueryable<TOuter>, IEnumerable<TInner>, Expression<Func<TOuter, TKey>>, Expression<Func<TInner, TKey>>, IQueryable<IGrouping<TOuter, TInner>>>(GroupJoin).Method,
+                    outer.Expression, GetSourceExpression(inner), Expression.Quote(outerKeySelector), Expression.Quote(innerKeySelector)));
+        }
+
         [DynamicDependency("GroupJoin`4", typeof(Enumerable))]
         public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, IEnumerable<TInner>, TResult>> resultSelector)
         {

src/libraries/System.Linq.Queryable/tests/GroupJoinTests.cs

@@ -287,5 +287,54 @@ public void GroupJoin2()
             var count = new[] { 0, 1, 2 }.AsQueryable().GroupJoin(new[] { 1, 2, 3 }, n1 => n1, n2 => n2, (n1, n2) => n1, EqualityComparer<int>.Default).Count();
             Assert.Equal(3, count);
         }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector()
+        {
+            var result = new[] { 0, 1, 2 }.AsQueryable().GroupJoin(new[] { 1, 2, 3 }, n1 => n1, n2 => n2).ToList();
+            Assert.Equal(3, result.Count);
+            Assert.Equal(0, result[0].Key);
+            Assert.Empty(result[0]);
+            Assert.Equal(1, result[1].Key);
+            Assert.Single(result[1]);
+            Assert.Equal(2, result[2].Key);
+            Assert.Single(result[2]);
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_OuterNull()
+        {
+            IQueryable<int> outer = null;
+            int[] inner = { 1, 2, 3 };
+
+            AssertExtensions.Throws<ArgumentNullException>("outer", () => outer.GroupJoin(inner.AsQueryable(), n1 => n1, n2 => n2));
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_InnerNull()
+        {
+            int[] outer = { 0, 1, 2 };
+            IQueryable<int> inner = null;
+
+            AssertExtensions.Throws<ArgumentNullException>("inner", () => outer.AsQueryable().GroupJoin(inner, n1 => n1, n2 => n2));
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_OuterKeySelectorNull()
+        {
+            int[] outer = { 0, 1, 2 };
+            int[] inner = { 1, 2, 3 };
+
+            AssertExtensions.Throws<ArgumentNullException>("outerKeySelector", () => outer.AsQueryable().GroupJoin(inner.AsQueryable(), null, n2 => n2));
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_InnerKeySelectorNull()
+        {
+            int[] outer = { 0, 1, 2 };
+            int[] inner = { 1, 2, 3 };
+
+            AssertExtensions.Throws<ArgumentNullException>("innerKeySelector", () => outer.AsQueryable().GroupJoin<int, int, int>(inner.AsQueryable(), n1 => n1, null));
+        }
     }
 }

src/libraries/System.Linq/ref/System.Linq.cs

@@ -81,6 +81,7 @@ public static System.Collections.Generic.IEnumerable<
         public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
         public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult> resultSelector) { throw null; }
         public static System.Collections.Generic.IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, TKey> keySelector, System.Func<TSource, TElement> elementSelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TElement>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
+        public static System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TOuter, TInner>> GroupJoin<TOuter, TInner, TKey>(this System.Collections.Generic.IEnumerable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector) { throw null; }
         public static System.Collections.Generic.IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IEnumerable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult> resultSelector) { throw null; }
         public static System.Collections.Generic.IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this System.Collections.Generic.IEnumerable<TOuter> outer, System.Collections.Generic.IEnumerable<TInner> inner, System.Func<TOuter, TKey> outerKeySelector, System.Func<TInner, TKey> innerKeySelector, System.Func<TOuter, System.Collections.Generic.IEnumerable<TInner>, TResult> resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) { throw null; }
         public static System.Collections.Generic.IEnumerable<(int Index, TSource Item)> Index<TSource>(this System.Collections.Generic.IEnumerable<TSource> source) { throw null; }

src/libraries/System.Linq/src/System/Linq/GroupJoin.cs

@@ -1,12 +1,43 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections;
 using System.Collections.Generic;
 
 namespace System.Linq
 {
     public static partial class Enumerable
     {
+        public static IEnumerable<IGrouping<TOuter, TInner>> GroupJoin<TOuter, TInner, TKey>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector)
+        {
+            if (outer is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.outer);
+            }
+
+            if (inner is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.inner);
+            }
+
+            if (outerKeySelector is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.outerKeySelector);
+            }
+
+            if (innerKeySelector is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.innerKeySelector);
+            }
+
+            if (IsEmptyArray(outer))
+            {
+                return [];
+            }
+
+            return GroupJoinIterator(outer, inner, outerKeySelector, innerKeySelector, comparer: null);
+        }
+
         public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector) =>
             GroupJoin(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
 
@@ -45,6 +76,21 @@ public static IEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this
             return GroupJoinIterator(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
         }
 
+        private static IEnumerable<IGrouping<TOuter, TInner>> GroupJoinIterator<TOuter, TInner, TKey>(IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, IEqualityComparer<TKey>? comparer)
+        {
+            using IEnumerator<TOuter> e = outer.GetEnumerator();
+            if (e.MoveNext())
+            {
+                Lookup<TKey, TInner> lookup = Lookup<TKey, TInner>.CreateForJoin(inner, innerKeySelector, comparer);
+                do
+                {
+                    TOuter item = e.Current;
+                    yield return new GroupJoinGrouping<TOuter, TInner>(item, lookup[outerKeySelector(item)]);
+                }
+                while (e.MoveNext());
+            }
+        }
+
         private static IEnumerable<TResult> GroupJoinIterator<TOuter, TInner, TKey, TResult>(IEnumerable<TOuter> outer, IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector, IEqualityComparer<TKey>? comparer)
         {
             using IEnumerator<TOuter> e = outer.GetEnumerator();
@@ -60,4 +106,22 @@ private static IEnumerable<TResult> GroupJoinIterator<TOuter, TInner, TKey, TRes
             }
         }
     }
+
+    internal sealed class GroupJoinGrouping<TKey, TElement> : IGrouping<TKey, TElement>
+    {
+        private readonly TKey _key;
+        private readonly IEnumerable<TElement> _elements;
+
+        public GroupJoinGrouping(TKey key, IEnumerable<TElement> elements)
+        {
+            _key = key;
+            _elements = elements;
+        }
+
+        public TKey Key => _key;
+
+        public IEnumerator<TElement> GetEnumerator() => _elements.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
 }

src/libraries/System.Linq/tests/GroupJoinTests.cs

@@ -513,5 +513,151 @@ public void ForcedToEnumeratorDoesntEnumerate()
             var en = iterator as IEnumerator<IEnumerable<int>>;
             Assert.False(en is not null && en.MoveNext());
         }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_OuterEmptyInnerNonEmpty()
+        {
+            CustomerRec[] outer = [];
+            OrderRec[] inner =
+            [
+                new OrderRec{ orderID = 45321, custID = 98022, total = 50 },
+                new OrderRec{ orderID = 97865, custID = 32103, total = 25 }
+            ];
+            Assert.Empty(outer.GroupJoin(inner, e => e.custID, e => e.custID));
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_OuterNonEmptyInnerEmpty()
+        {
+            CustomerRec[] outer =
+            [
+                new CustomerRec{ name = "Tim", custID = 43434 },
+                new CustomerRec{ name = "Bob", custID = 34093 }
+            ];
+            OrderRec[] inner = [];
+
+            var result = outer.GroupJoin(inner, e => e.custID, e => e.custID).ToList();
+
+            Assert.Equal(2, result.Count);
+            Assert.Equal(outer[0], result[0].Key);
+            Assert.Empty(result[0]);
+            Assert.Equal(outer[1], result[1].Key);
+            Assert.Empty(result[1]);
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_SingleElementEachAndMatches()
+        {
+            CustomerRec[] outer = [new CustomerRec{ name = "Tim", custID = 43434 }];
+            OrderRec[] inner = [new OrderRec{ orderID = 97865, custID = 43434, total = 25 }];
+
+            var result = outer.GroupJoin(inner, e => e.custID, e => e.custID).ToList();
+
+            Assert.Single(result);
+            Assert.Equal(outer[0], result[0].Key);
+            Assert.Single(result[0]);
+            Assert.Equal(inner[0], result[0].First());
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_InnerSameKeyMoreThanOneElementAndMatches()
+        {
+            CustomerRec[] outer =
+            [
+                new CustomerRec{ name = "Tim", custID = 1234 },
+                new CustomerRec{ name = "Bob", custID = 9865 }
+            ];
+            OrderRec[] inner =
+            [
+                new OrderRec{ orderID = 97865, custID = 1234, total = 25 },
+                new OrderRec{ orderID = 34390, custID = 1234, total = 19 },
+                new OrderRec{ orderID = 34390, custID = 9865, total = 19 }
+            ];
+
+            var result = outer.GroupJoin(inner, e => e.custID, e => e.custID).ToList();
+
+            Assert.Equal(2, result.Count);
+            Assert.Equal(outer[0], result[0].Key);
+            Assert.Equal(2, result[0].Count());
+            Assert.Equal(outer[1], result[1].Key);
+            Assert.Single(result[1]);
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_OuterNull()
+        {
+            CustomerRec[] outer = null;
+            OrderRec[] inner =
+            [
+                new OrderRec{ orderID = 45321, custID = 98022, total = 50 }
+            ];
+
+            AssertExtensions.Throws<ArgumentNullException>("outer", () => outer.GroupJoin(inner, e => e.custID, e => e.custID));
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_InnerNull()
+        {
+            CustomerRec[] outer =
+            [
+                new CustomerRec{ name = "Tim", custID = 1234 }
+            ];
+            OrderRec[] inner = null;
+
+            AssertExtensions.Throws<ArgumentNullException>("inner", () => outer.GroupJoin(inner, e => e.custID, e => e.custID));
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_OuterKeySelectorNull()
+        {
+            CustomerRec[] outer =
+            [
+                new CustomerRec{ name = "Tim", custID = 1234 }
+            ];
+            OrderRec[] inner =
+            [
+                new OrderRec{ orderID = 45321, custID = 98022, total = 50 }
+            ];
+
+            AssertExtensions.Throws<ArgumentNullException>("outerKeySelector", () => outer.GroupJoin(inner, null, e => e.custID));
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_InnerKeySelectorNull()
+        {
+            CustomerRec[] outer =
+            [
+                new CustomerRec{ name = "Tim", custID = 1234 }
+            ];
+            OrderRec[] inner =
+            [
+                new OrderRec{ orderID = 45321, custID = 98022, total = 50 }
+            ];
+
+            AssertExtensions.Throws<ArgumentNullException>("innerKeySelector", () => outer.GroupJoin<CustomerRec, OrderRec, int?>(inner, e => e.custID, null));
+        }
+
+        [Fact]
+        public void GroupJoinWithoutResultSelector_CanIterateMultipleTimes()
+        {
+            CustomerRec[] outer =
+            [
+                new CustomerRec{ name = "Tim", custID = 1234 }
+            ];
+            OrderRec[] inner =
+            [
+                new OrderRec{ orderID = 97865, custID = 1234, total = 25 }
+            ];
+
+            var result = outer.GroupJoin(inner, e => e.custID, e => e.custID).ToList();
+
+            Assert.Single(result);
+
+            // Iterate the grouped elements multiple times
+            Assert.Single(result[0]);
+            Assert.Single(result[0]);
+            Assert.Equal(inner[0], result[0].First());
+            Assert.Equal(inner[0], result[0].First());
+        }
     }
 }