New SkipAtOrDefault extension method, SkipAt now behaves similar to existing ElementAt LINQ extension method

Author: Necas209

DotNetExtensions/Collections/SkipAt.cs

@@ -4,6 +4,7 @@ public static partial class EnumerableExtensions
 {
     /// <summary>
     /// Returns a new sequence that skips the element at the specified index.
+    /// Throws <see cref="ArgumentOutOfRangeException"/> if the index is negative or outside the bounds of the source.
     /// </summary>
     /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
     /// <param name="source">The source sequence.</param>
@@ -15,7 +16,7 @@ public static partial class EnumerableExtensions
     /// Thrown if the <paramref name="source"/> is <c>null</c>.
     /// </exception>
     /// <exception cref="ArgumentOutOfRangeException">
-    /// Thrown if the <paramref name="index"/> is negative.
+    /// Thrown if the <paramref name="index"/> is negative or outside the bounds of the source.
     /// </exception>
     public static IEnumerable<T> SkipAt<T>(this IEnumerable<T> source, int index)
     {
@@ -26,6 +27,46 @@ public static IEnumerable<T> SkipAt<T>(this IEnumerable<T> source, int index)
     }
 
     private static IEnumerable<T> SkipAtInternal<T>(IEnumerable<T> source, int index)
+    {
+        using var enumerator = source.GetEnumerator();
+        var i = 0;
+        var found = false;
+
+        while (enumerator.MoveNext())
+        {
+            if (i++ == index)
+            {
+                found = true;
+                continue;
+            }
+
+            yield return enumerator.Current;
+        }
+
+        if (!found)
+            throw new ArgumentOutOfRangeException(nameof(index), "Index is out of range of the source sequence.");
+    }
+
+    /// <summary>
+    /// Returns a new sequence that skips the element at the specified index.
+    /// If the index is negative or outside the bounds of the source, the original sequence is returned unchanged.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the source sequence.</typeparam>
+    /// <param name="source">The source sequence.</param>
+    /// <param name="index">The index of the element to skip.</param>
+    /// <returns>
+    /// A new sequence without the element at the specified index, or the original sequence if the index is out of range.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">
+    /// Thrown if the <paramref name="source"/> is <c>null</c>.
+    /// </exception>
+    public static IEnumerable<T> SkipAtOrDefault<T>(this IEnumerable<T> source, int index)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+        return index < 0 ? source : SkipAtOrDefaultInternal(source, index);
+    }
+
+    private static IEnumerable<T> SkipAtOrDefaultInternal<T>(IEnumerable<T> source, int index)
     {
         using var enumerator = source.GetEnumerator();
         var i = 0;

DotNetExtensions/DotNetExtensions.csproj

@@ -8,7 +8,7 @@
     </PropertyGroup>
 
     <PropertyGroup>
-        <Version>5.3.0</Version>
+        <Version>5.4.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

@@ -32,7 +32,7 @@ public void TestPairwiseWithOneElement()
     public void TestPairwiseWithNoElements()
     {
         int[] source = [];
-        var result = source.Pairwise().ToImmutableArray();
+        var result = source.Pairwise().ToArray();
 
         Assert.AreEqual(0, result.Length);
     }
@@ -55,33 +55,103 @@ public void TestAdjacentWithInvalidLength()
         int[] source = [1, 2, 3, 4, 5];
         var result = source.Adjacent(6).ToArray();
 
-        Assert.AreEqual(0, result.Length);
+        Assert.AreEqual([], result);
+    }
+
+    [TestMethod]
+    public void TestAdjacentWithZeroLength()
+    {
+        int[] source = [1, 2, 3, 4, 5];
+        var result = source.Adjacent(0).ToArray();
+
+        Assert.AreEqual([], result);
+    }
+
+    [TestMethod]
+    public void TestAdjacentWithLengthOne()
+    {
+        int[] source = [1, 2, 3, 4, 5];
+        var result = source.Adjacent(1).ToArray();
+
+        var expected = ImmutableArray.Create<int[]>([1], [2], [3], [4], [5]);
+        CollectionAssert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void TestAdjacentWithLengthEqualToSource()
+    {
+        int[] source = [1, 2, 3, 4, 5];
+        var result = source.Adjacent(5).ToArray();
+
+        Assert.AreEqual(1, result.Length);
+        CollectionAssert.AreEqual(source, result[0]);
     }
 
     [TestMethod]
     public void TestSkipAtWithValidIndex()
     {
         int[] source = [1, 2, 3, 4, 5];
-        var result = source.SkipAt(4).ToImmutableArray();
+        var result = source.SkipAt(4).ToArray();
+        var expected = ImmutableArray.Create(1, 2, 3, 4);
 
-        Assert.AreEqual(4, result.Length);
-        Assert.AreEqual(1, result[0]);
-        Assert.AreEqual(2, result[1]);
-        Assert.AreEqual(3, result[2]);
-        Assert.AreEqual(4, result[3]);
+        CollectionAssert.AreEqual(expected, result);
     }
 
     [TestMethod]
     public void TestSkipAtWithInvalidIndex()
     {
         int[] source = [1, 2, 3, 4, 5];
-        var result = source.SkipAt(5).ToImmutableArray();
-
-        Assert.AreEqual(5, result.Length);
-        Assert.AreEqual(1, result[0]);
-        Assert.AreEqual(2, result[1]);
-        Assert.AreEqual(3, result[2]);
-        Assert.AreEqual(4, result[3]);
-        Assert.AreEqual(5, result[4]);
+        Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => source.SkipAt(5).ToArray());
+    }
+
+    [TestMethod]
+    public void TestSkipAtWithNegativeIndex()
+    {
+        int[] source = [1, 2, 3, 4, 5];
+        Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => source.SkipAt(-1).ToArray());
+    }
+
+    [TestMethod]
+    public void TestSkipAtWithEmptySource()
+    {
+        int[] source = [];
+        Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => source.SkipAt(0).ToArray());
+    }
+
+    [TestMethod]
+    public void TestSkipAtOrDefaultWithValidIndex()
+    {
+        int[] source = [1, 2, 3, 4, 5];
+        var result = source.SkipAtOrDefault(2).ToArray();
+        var expected = new[] { 1, 2, 4, 5 };
+
+        CollectionAssert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void TestSkipAtOrDefaultWithNegativeIndex()
+    {
+        int[] source = [1, 2, 3, 4, 5];
+        var result = source.SkipAtOrDefault(-1).ToArray();
+
+        CollectionAssert.AreEqual(source, result);
+    }
+
+    [TestMethod]
+    public void TestSkipAtOrDefaultWithOutOfRangeIndex()
+    {
+        int[] source = [1, 2, 3, 4, 5];
+        var result = source.SkipAtOrDefault(5).ToArray();
+
+        CollectionAssert.AreEqual(source, result);
+    }
+
+    [TestMethod]
+    public void TestSkipAtOrDefaultWithEmptySource()
+    {
+        int[] source = [];
+        var result = source.SkipAtOrDefault(0).ToArray();
+
+        Assert.AreEqual(source, result);
     }
 }