Add Pairs method to EnumerableExtensions for generating unique unordered pairs from a sequence

Author: Necas209

DotNetExtensions/Collections/Pairs.cs

@@ -0,0 +1,57 @@
+namespace DotNetExtensions.Collections;
+
+public static partial class EnumerableExtensions
+{
+    /// <summary>
+    /// Returns all unique unordered pairs from <paramref name="source"/> where each pair contains
+    /// two distinct elements from the sequence. The order within each pair follows the original
+    /// sequence order (first comes before second).
+    /// </summary>
+    /// <typeparam name="T">The element type of the sequence.</typeparam>
+    /// <param name="source">The input sequence from which pairs are generated.</param>
+    /// <returns>
+    /// An <see cref="IEnumerable{T}"/> of tuples where each tuple contains two distinct elements
+    /// from the source: (First, Second).
+    /// </returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="source"/> is null.</exception>
+    public static IEnumerable<(T First, T Second)> Pairs<T>(this IEnumerable<T> source)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        switch (source)
+        {
+            case IList<T> list:
+            {
+                return PairsInternal(list);
+            }
+            case ICollection<T> coll:
+            {
+                var array = new T[coll.Count];
+                coll.CopyTo(array, 0);
+                return PairsInternal(array);
+            }
+            default:
+            {
+                var buffered = source.ToList();
+                return PairsInternal(buffered);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Internal implementation that enumerates all unique unordered index pairs from an indexed buffer.
+    /// </summary>
+    /// <typeparam name="T">The element type of the buffer.</typeparam>
+    /// <param name="buffer">An indexed collection (e.g. <see cref="IList{T}"/>) to enumerate pairs from.</param>
+    /// <returns>An <see cref="IEnumerable{T}"/> of tuples (First, Second) for every pair where First precedes Second.</returns>
+    private static IEnumerable<(T First, T Second)> PairsInternal<T>(IList<T> buffer)
+    {
+        for (var i = 0; i < buffer.Count; i++)
+        {
+            for (var j = i + 1; j < buffer.Count; j++)
+            {
+                yield return (buffer[i], buffer[j]);
+            }
+        }
+    }
+}

DotNetExtensions/DotNetExtensions.csproj

@@ -13,7 +13,7 @@
     </PropertyGroup>
 
     <PropertyGroup>
-        <Version>5.9.0</Version>
+        <Version>5.10.0</Version>
         <Authors>Diogo Medeiros</Authors>
         <Company>Diogo Medeiros</Company>
         <Description>This is a collection of extension methods for .NET Core.</Description>

DotNetExtensionsTests/Collections/EnumerableExtensionsTests.cs

@@ -169,4 +169,39 @@ public void Product_SourceIsEmpty_ThrowsInvalidOperationException()
         int[] source = [];
         Assert.ThrowsExactly<InvalidOperationException>(() => source.Product());
     }
+    
+    [TestMethod]
+    public void Pairs_SourceHasMultipleElements_ReturnsExpectedPairs()
+    {
+        AssertPairsAreExpected(DefaultSource);
+    }
+    
+    [TestMethod]
+    public void Pairs_SourceIsCollection_ReturnsExpectedPairs()
+    {
+        AssertPairsAreExpected(DefaultSource.ToHashSet());
+    }
+
+    [TestMethod]
+    public void Pairs_SourceIsEnumerable_ReturnsExpectedPairs()
+    {
+        AssertPairsAreExpected(Enumerable.Range(1, 5).Select(i => i));
+    }
+
+    private static void AssertPairsAreExpected(IEnumerable<int> source)
+    {
+        var result = source.Pairs().ToList();
+
+        Assert.HasCount(10, result);
+        Assert.AreEqual((1, 2), result[0]);
+        Assert.AreEqual((1, 3), result[1]);
+        Assert.AreEqual((1, 4), result[2]);
+        Assert.AreEqual((1, 5), result[3]);
+        Assert.AreEqual((2, 3), result[4]);
+        Assert.AreEqual((2, 4), result[5]);
+        Assert.AreEqual((2, 5), result[6]);
+        Assert.AreEqual((3, 4), result[7]);
+        Assert.AreEqual((3, 5), result[8]);
+        Assert.AreEqual((4, 5), result[9]);
+    }
 }