More arities for tuple returning zip extension method

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

@@ -162,6 +162,7 @@ public static partial class Queryable
         public static System.Linq.IQueryable<TSource> Where<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, bool>> predicate) { throw null; }
         public static System.Linq.IQueryable<TSource> Where<TSource>(this System.Linq.IQueryable<TSource> source, System.Linq.Expressions.Expression<System.Func<TSource, int, bool>> predicate) { throw null; }
         public static System.Linq.IQueryable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this System.Linq.IQueryable<TFirst> source1, System.Collections.Generic.IEnumerable<TSecond> source2) { throw null; }
+        public static System.Linq.IQueryable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this System.Linq.IQueryable<TFirst> source1, System.Collections.Generic.IEnumerable<TSecond> source2, System.Collections.Generic.IEnumerable<TThird> source3) { throw null; }
         public static System.Linq.IQueryable<TResult> Zip<TFirst, TSecond, TResult>(this System.Linq.IQueryable<TFirst> source1, System.Collections.Generic.IEnumerable<TSecond> source2, System.Linq.Expressions.Expression<System.Func<TFirst, TSecond, TResult>> resultSelector) { throw null; }
     }
 }

src/libraries/System.Linq.Queryable/src/ILLink/ILLink.Suppressions.xml

@@ -637,6 +637,12 @@
       <property name="Scope">member</property>
       <property name="Target">M:System.Linq.CachedReflectionInfo.Zip_TFirst_TSecond_TResult_3(System.Type,System.Type,System.Type)</property>
     </attribute>
+    <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
+      <argument>ILLink</argument>
+      <argument>IL2060</argument>
+      <property name="Scope">member</property>
+      <property name="Target">M:System.Linq.CachedReflectionInfo.Zip_TFirst_TSecond_TThird_3(System.Type,System.Type,System.Type)</property>
+    </attribute>
     <attribute fullname="System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
       <argument>ILLink</argument>
       <argument>IL2060</argument>
@@ -662,4 +668,4 @@
       <property name="Target">M:System.Linq.TypeHelper.GetStaticMethods(System.Type)</property>
     </attribute>
   </assembly>
-</linker>
+</linker>

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

@@ -843,6 +843,13 @@ public static MethodInfo Zip_TFirst_TSecond_TResult_3(Type TFirst, Type TSecond,
              (s_Zip_TFirst_TSecond_TResult_3 = new Func<IQueryable<object>, IEnumerable<object>, Expression<Func<object, object, object>>, IQueryable<object>>(Queryable.Zip).GetMethodInfo().GetGenericMethodDefinition()))
               .MakeGenericMethod(TFirst, TSecond, TResult);
 
+        private static MethodInfo? s_Zip_TFirst_TSecond_TThird_3;
+
+        public static MethodInfo Zip_TFirst_TSecond_TThird_3(Type TFirst, Type TSecond, Type TThird) =>
+             (s_Zip_TFirst_TSecond_TThird_3 ??
+             (s_Zip_TFirst_TSecond_TThird_3 = new Func<IQueryable<object>, IEnumerable<object>, IEnumerable<object>, IQueryable<(object, object, object)>>(Queryable.Zip).GetMethodInfo().GetGenericMethodDefinition()))
+              .MakeGenericMethod(TFirst, TSecond, TThird);
+
 
         private static MethodInfo? s_SkipLast_TSource_2;
 

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

@@ -666,6 +666,33 @@ public static IQueryable<TResult> Zip<TFirst, TSecond, TResult>(this IQueryable<
                     ));
         }
 
+        /// <summary>
+        /// Produces a sequence of tuples with elements from the three specified sequences.
+        /// </summary>
+        /// <typeparam name="TFirst">The type of the elements of the first input sequence.</typeparam>
+        /// <typeparam name="TSecond">The type of the elements of the second input sequence.</typeparam>
+        /// <typeparam name="TThird">The type of the elements of the third input sequence.</typeparam>
+        /// <param name="source1">The first sequence to merge.</param>
+        /// <param name="source2">The second sequence to merge.</param>
+        /// <param name="source3">The third sequence to merge.</param>
+        /// <returns>A sequence of tuples with elements taken from the first, second and third sequences, in that order.</returns>
+        [DynamicDependency("Zip`3", typeof(Enumerable))]
+        public static IQueryable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, IEnumerable<TThird> source3)
+        {
+            if (source1 == null)
+                throw Error.ArgumentNull(nameof(source1));
+            if (source2 == null)
+                throw Error.ArgumentNull(nameof(source2));
+            if (source3 == null)
+                throw Error.ArgumentNull(nameof(source3));
+            return source1.Provider.CreateQuery<(TFirst, TSecond, TThird)>(
+                Expression.Call(
+                    null,
+                    CachedReflectionInfo.Zip_TFirst_TSecond_TThird_3(typeof(TFirst), typeof(TSecond), typeof(TThird)),
+                    source1.Expression, GetSourceExpression(source2), GetSourceExpression(source3)
+                    ));
+        }
+
         [DynamicDependency("Union`1", typeof(Enumerable))]
         public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2)
         {

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

@@ -90,5 +90,55 @@ public void TupleNames()
             Assert.Equal(tuple.Item1, tuple.First);
             Assert.Equal(tuple.Item2, tuple.Second);
         }
+
+        [Fact]
+        public void Zip3_CorrectResults()
+        {
+            int[] first = new int[] { 1, 3, 5 };
+            int[] second = new int[] { 2, 6, 8 };
+            int[] third = new int[] { 1, 7, 2 };
+            var expected = new (int, int, int)[] { (1, 2, 1), (3, 6, 7), (5, 8, 2) };
+            Assert.Equal(expected, first.AsQueryable().Zip(second.AsQueryable(), third.AsQueryable()));
+        }
+
+
+        [Fact]
+        public void Zip3_FirstIsNull()
+        {
+            IQueryable<int> first = null;
+            int[] second = new int[] { 2, 6, 8 };
+            int[] third = new int[] { 1, 7, 2 };
+            AssertExtensions.Throws<ArgumentNullException>("source1", () => first.Zip(second.AsQueryable(), third.AsQueryable()));
+        }
+
+        [Fact]
+        public void Zip3_SecondIsNull()
+        {
+            int[] first = new int[] { 1, 3, 5 };
+            IQueryable<int> second = null;
+            int[] third = new int[] { 1, 7, 2 };
+            AssertExtensions.Throws<ArgumentNullException>("source2", () => first.AsQueryable().Zip(second, third.AsQueryable()));
+        }
+
+        [Fact]
+        public void Zip3_ThirdIsNull()
+        {
+            int[] first = new int[] { 1, 3, 5 };
+            int[] second = new int[] { 2, 6, 8 };
+            IQueryable<int> third = null;
+            AssertExtensions.Throws<ArgumentNullException>("source3", () => first.AsQueryable().Zip(second.AsQueryable(), third));
+        }
+
+        [Fact]
+        public void Zip3_TupleNames()
+        {
+            int[] first = new int[] { 1 };
+            int[] second = new int[] { 2 };
+            int[] third = new int[] { 3 };
+            var tuple = first.AsQueryable().Zip(second.AsQueryable(), third.AsQueryable()).First();
+            Assert.Equal(tuple.Item1, tuple.First);
+            Assert.Equal(tuple.Item2, tuple.Second);
+            Assert.Equal(tuple.Item3, tuple.Third);
+        }
     }
 }

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

@@ -193,6 +193,7 @@ public static System.Collections.Generic.IEnumerable<
         public static System.Collections.Generic.IEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, bool> predicate) { throw null; }
         public static System.Collections.Generic.IEnumerable<TSource> Where<TSource>(this System.Collections.Generic.IEnumerable<TSource> source, System.Func<TSource, int, bool> predicate) { throw null; }
         public static System.Collections.Generic.IEnumerable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst> first, System.Collections.Generic.IEnumerable<TSecond> second) { throw null; }
+        public static System.Collections.Generic.IEnumerable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this System.Collections.Generic.IEnumerable<TFirst> first, System.Collections.Generic.IEnumerable<TSecond> second, System.Collections.Generic.IEnumerable<TThird> third) { throw null; }
         public static System.Collections.Generic.IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst> first, System.Collections.Generic.IEnumerable<TSecond> second, System.Func<TFirst, TSecond, TResult> resultSelector) { throw null; }
     }
     public partial interface IGrouping<out TKey, out TElement> : System.Collections.Generic.IEnumerable<TElement>, System.Collections.IEnumerable

src/libraries/System.Linq/src/System/Linq/ThrowHelper.cs

@@ -50,6 +50,7 @@ private static string GetArgumentString(ExceptionArgument argument)
                 case ExceptionArgument.second: return nameof(ExceptionArgument.second);
                 case ExceptionArgument.selector: return nameof(ExceptionArgument.selector);
                 case ExceptionArgument.source: return nameof(ExceptionArgument.source);
+                case ExceptionArgument.third: return nameof(ExceptionArgument.third);
                 default:
                     Debug.Fail("The ExceptionArgument value is not defined.");
                     return string.Empty;
@@ -76,5 +77,6 @@ internal enum ExceptionArgument
         second,
         selector,
         source,
+        third,
     }
 }

src/libraries/System.Linq/src/System/Linq/Zip.cs

@@ -42,6 +42,36 @@ public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerabl
             return ZipIterator(first, second);
         }
 
+        /// <summary>
+        /// Produces a sequence of tuples with elements from the three specified sequences.
+        /// </summary>
+        /// <typeparam name="TFirst">The type of the elements of the first input sequence.</typeparam>
+        /// <typeparam name="TSecond">The type of the elements of the second input sequence.</typeparam>
+        /// <typeparam name="TThird">The type of the elements of the third input sequence.</typeparam>
+        /// <param name="first">The first sequence to merge.</param>
+        /// <param name="second">The second sequence to merge.</param>
+        /// <param name="third">The third sequence to merge.</param>
+        /// <returns>A sequence of tuples with elements taken from the first, second, and third sequences, in that order.</returns>
+        public static IEnumerable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third)
+        {
+            if (first is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.first);
+            }
+
+            if (second is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.second);
+            }
+
+            if (third is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.third);
+            }
+
+            return ZipIterator(first, second, third);
+        }
+
         private static IEnumerable<(TFirst First, TSecond Second)> ZipIterator<TFirst, TSecond>(IEnumerable<TFirst> first, IEnumerable<TSecond> second)
         {
             using (IEnumerator<TFirst> e1 = first.GetEnumerator())
@@ -65,5 +95,18 @@ private static IEnumerable<TResult> ZipIterator<TFirst, TSecond, TResult>(IEnume
                 }
             }
         }
+
+        private static IEnumerable<(TFirst First, TSecond Second, TThird Third)> ZipIterator<TFirst, TSecond, TThird>(IEnumerable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third)
+        {
+            using (IEnumerator<TFirst> e1 = first.GetEnumerator())
+            using (IEnumerator<TSecond> e2 = second.GetEnumerator())
+            using (IEnumerator<TThird> e3 = third.GetEnumerator())
+            {
+                while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
+                {
+                    yield return (e1.Current, e2.Current, e3.Current);
+                }
+            }
+        }
     }
 }

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

@@ -393,7 +393,7 @@ public void Zip2_ImplicitTypeParameters()
         {
             IEnumerable<int> first = new int[] { 1, 2, 3 };
             IEnumerable<int> second = new int[] { 2, 5, 9 };
-            IEnumerable<(int, int)> expected = new (int,int)[] { (1,2), (2,5), (3,9) };
+            IEnumerable<(int, int)> expected = new (int, int)[] { (1, 2), (2, 5), (3, 9) };
 
             Assert.Equal(expected, first.Zip(second));
         }
@@ -403,7 +403,7 @@ public void Zip2_ExplicitTypeParameters()
         {
             IEnumerable<int> first = new int[] { 1, 2, 3 };
             IEnumerable<int> second = new int[] { 2, 5, 9 };
-            IEnumerable<(int, int)> expected = new (int,int)[] { (1,2), (2,5), (3,9) };
+            IEnumerable<(int, int)> expected = new (int, int)[] { (1, 2), (2, 5), (3, 9) };
 
             Assert.Equal(expected, first.Zip<int, int>(second));
         }
@@ -431,7 +431,7 @@ public void Zip2_ExceptionThrownFromFirstsEnumerator()
         {
             ThrowsOnMatchEnumerable<int> first = new ThrowsOnMatchEnumerable<int>(new int[] { 1, 3, 3 }, 2);
             IEnumerable<int> second = new int[] { 2, 4, 6 };
-            IEnumerable<(int, int)> expected = new (int,int)[] { (1,2), (3,4), (3,6) };
+            IEnumerable<(int, int)> expected = new (int, int)[] { (1, 2), (3, 4), (3, 6) };
 
             Assert.Equal(expected, first.Zip(second));
 
@@ -447,7 +447,7 @@ public void Zip2_ExceptionThrownFromSecondsEnumerator()
         {
             ThrowsOnMatchEnumerable<int> second = new ThrowsOnMatchEnumerable<int>(new int[] { 1, 3, 3 }, 2);
             IEnumerable<int> first = new int[] { 2, 4, 6 };
-            IEnumerable<(int, int)> expected = new (int,int)[] { (2,1), (4,3), (6,3) };
+            IEnumerable<(int, int)> expected = new (int, int)[] { (2, 1), (4, 3), (6, 3) };
 
             Assert.Equal(expected, first.Zip(second));
 
@@ -601,5 +601,123 @@ public void Zip2_TupleNames()
             Assert.Equal(t.Item1, t.First);
             Assert.Equal(t.Item2, t.Second);
         }
+
+        [Fact]
+        public void Zip3_FirstIsNull()
+        {
+            IEnumerable<int> first = null;
+            IEnumerable<int> second = new[] { 4, 5, 6 };
+            IEnumerable<int> third = new[] { 7, 8, 9 };
+
+            AssertExtensions.Throws<ArgumentNullException>("first", () => first.Zip(second, third));
+        }
+
+        [Fact]
+        public void Zip3_SecondIsNull()
+        {
+            IEnumerable<int> first = new[] { 1, 2, 3 };
+            IEnumerable<int> second = null;
+            IEnumerable<int> third = new[] { 4, 5, 6 };
+
+            AssertExtensions.Throws<ArgumentNullException>("second", () => first.Zip(second, third));
+        }
+
+        [Fact]
+        public void Zip3_ThirdIsNull()
+        {
+            IEnumerable<int> first = new[] { 1, 2, 3 };
+            IEnumerable<int> second = new[] { 4, 5, 6 };
+            IEnumerable<int> third = null;
+
+            AssertExtensions.Throws<ArgumentNullException>("third", () => first.Zip(second, third));
+        }
+
+        [Fact]
+        public void Zip3_ThirdEmpty()
+        {
+            IEnumerable<int> first = new[] { 1, 2, 3 };
+            IEnumerable<int> second = new[] { 4, 5, 6 };
+            IEnumerable<int> third = new int[] { };
+            IEnumerable<(int, int, int)> expected = new (int, int, int)[] { };
+
+            Assert.Equal(expected, first.Zip(second, third));
+        }
+
+        [Fact]
+        public void Zip3_ImplicitTypeParameters()
+        {
+            IEnumerable<int> first = new[] { 1, 2 };
+            IEnumerable<int> second = new[] { 3, 4 };
+            IEnumerable<int> third = new[] { 5, 6 };
+            IEnumerable<(int, int, int)> expected = new[] { (1, 3, 5), (2, 4, 6) };
+
+            Assert.Equal(expected, first.Zip(second, third));
+        }
+
+        [Fact]
+        public void Zip3_ExplicitTypeParameters()
+        {
+            IEnumerable<int> first = new[] { 1, 2 };
+            IEnumerable<int> second = new[] { 3, 4 };
+            IEnumerable<int> third = new[] { 5, 6 };
+            IEnumerable<(int, int, int)> expected = new[] { (1, 3, 5), (2, 4, 6) };
+
+            Assert.Equal(expected, first.Zip<int, int, int>(second, third));
+        }
+
+        [Fact]
+        public void Zip3_ThirdOneMore()
+        {
+            IEnumerable<int> first = new[] { 1, 2 };
+            IEnumerable<int> second = new[] { 3, 4 };
+            IEnumerable<int> third = new[] { 5, 6, 7 };
+            IEnumerable<(int, int, int)> expected = new[] { (1, 3, 5), (2, 4, 6) };
+
+            Assert.Equal(expected, first.Zip(second, third));
+        }
+
+        [Fact]
+        public void Zip3_ThirdManyMore()
+        {
+            IEnumerable<int> first = new[] { 1, 2 };
+            IEnumerable<int> second = new[] { 3, 4 };
+            IEnumerable<int> third = new[] { 5, 6, 7, 8 };
+            IEnumerable<(int, int, int)> expected = new[] { (1, 3, 5), (2, 4, 6) };
+
+            Assert.Equal(expected, first.Zip(second, third));
+        }
+
+        [Fact]
+        public void Zip3_ThirdOneLess()
+        {
+            IEnumerable<int> first = new[] { 1, 2 };
+            IEnumerable<int> second = new[] { 3, 4 };
+            IEnumerable<int> third = new[] { 5 };
+            IEnumerable<(int, int, int)> expected = new[] { (1, 3, 5) };
+
+            Assert.Equal(expected, first.Zip(second, third));
+        }
+
+        [Fact]
+        public void Zip3_ThirdManyLess()
+        {
+            IEnumerable<int> first = new[] { 1, 2, 3 };
+            IEnumerable<int> second = new[] { 3, 4, 5 };
+            IEnumerable<int> third = new[] { 5 };
+            IEnumerable<(int, int, int)> expected = new[] { (1, 3, 5) };
+
+            Assert.Equal(expected, first.Zip(second, third));
+        }
+
+        [Fact]
+        public void Zip3_RunOnce()
+        {
+            IEnumerable<int> first = new[] { 1, 2 };
+            IEnumerable<int> second = new[] { 3, 4 };
+            IEnumerable<int> third = new[] { 5, 6 };
+            IEnumerable<(int, int, int)> expected = new[] { (1, 3, 5), (2, 4, 6) };
+
+            Assert.Equal(expected, first.RunOnce().Zip(second.RunOnce(), third.RunOnce()));
+        }
     }
 }