Add new shared SelectXXXAsArray helpers

src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared.Test/EnumerableExtensionsTests.cs

@@ -140,4 +140,24 @@ IEnumerator IEnumerable.GetEnumerator()
         public static CustomReadOnlyCollection Create(ReadOnlySpan<int> span)
             => new(span);
     }
+
+    [Fact]
+    public void SelectAsArray()
+    {
+        IEnumerable<int> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        ImmutableArray<int> expected = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20];
+
+        var actual = data.SelectAsArray(static x => x * 2);
+        Assert.Equal<int>(expected, actual);
+    }
+
+    [Fact]
+    public void SelectAsArray_Index()
+    {
+        IEnumerable<int> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        ImmutableArray<int> expected = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+
+        var actual = data.SelectAsArray(static (x, index) => x + index);
+        Assert.Equal<int>(expected, actual);
+    }
 }

src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared.Test/EnumerableOrderingTests.cs

@@ -17,31 +17,31 @@ public class EnumerableOrderingTests : EnumerableOrderingTestBase
     public void OrderAsArray(IEnumerable<int> data, ImmutableArray<int> expected)
     {
         var sorted = data.OrderAsArray();
-        Assert.Equal<int>(expected, sorted);
+        AssertEqual(expected, sorted);
     }
 
     [Theory]
     [MemberData(nameof(OrderTestData_OddBeforeEven))]
     public void OrderAsArray_OddBeforeEven(IEnumerable<int> data, ImmutableArray<int> expected)
     {
         var sorted = data.OrderAsArray(OddBeforeEven);
-        Assert.Equal<int>(expected, sorted);
+        AssertEqual(expected, sorted);
     }
 
     [Theory]
     [MemberData(nameof(OrderDescendingTestData))]
     public void OrderDescendingAsArray(IEnumerable<int> data, ImmutableArray<int> expected)
     {
         var sorted = data.OrderDescendingAsArray();
-        Assert.Equal<int>(expected, sorted);
+        AssertEqual(expected, sorted);
     }
 
     [Theory]
     [MemberData(nameof(OrderDescendingTestData_OddBeforeEven))]
     public void OrderDescendingAsArray_OddBeforeEven(IEnumerable<int> data, ImmutableArray<int> expected)
     {
         var sorted = data.OrderDescendingAsArray(OddBeforeEven);
-        Assert.Equal<int>(expected, sorted);
+        AssertEqual(expected, sorted);
     }
 
     [Theory]
@@ -76,6 +76,70 @@ public void OrderByDescendingAsArray_OddBeforeEven(IEnumerable<ValueHolder<int>>
         AssertEqual(expected, sorted);
     }
 
+    [Theory]
+    [MemberData(nameof(SelectAndOrderTestData))]
+    public void SelectAndOrderAsArray(IEnumerable<int> data, ImmutableArray<string> expected, Func<int, string> selector)
+    {
+        var sorted = data.SelectAndOrderAsArray(selector);
+        AssertEqual(expected, sorted);
+    }
+
+    [Theory]
+    [MemberData(nameof(SelectAndOrderTestData_OddBeforeEven))]
+    public void SelectAndOrderAsArray_OddBeforeEven(IEnumerable<int> data, ImmutableArray<string> expected, Func<int, string> selector)
+    {
+        var sorted = data.SelectAndOrderAsArray(selector, OddBeforeEvenString);
+        AssertEqual(expected, sorted);
+    }
+
+    [Theory]
+    [MemberData(nameof(SelectAndOrderDescendingTestData))]
+    public void SelectAndOrderDescendingAsArray(IEnumerable<int> data, ImmutableArray<string> expected, Func<int, string> selector)
+    {
+        var sorted = data.SelectAndOrderDescendingAsArray(selector);
+        AssertEqual(expected, sorted);
+    }
+
+    [Theory]
+    [MemberData(nameof(SelectAndOrderDescendingTestData_OddBeforeEven))]
+    public void SelectAndOrderDescendingAsArray_OddBeforeEven(IEnumerable<int> data, ImmutableArray<string> expected, Func<int, string> selector)
+    {
+        var sorted = data.SelectAndOrderDescendingAsArray(selector, OddBeforeEvenString);
+        AssertEqual(expected, sorted);
+    }
+
+    [Theory]
+    [MemberData(nameof(SelectAndOrderByTestData))]
+    public void SelectAndOrderByAsArray(IEnumerable<ValueHolder<int>> data, ImmutableArray<ValueHolder<string>> expected, Func<ValueHolder<int>, ValueHolder<string>> selector)
+    {
+        var sorted = data.SelectAndOrderByAsArray(selector, static x => x.Value);
+        AssertEqual(expected, sorted);
+    }
+
+    [Theory]
+    [MemberData(nameof(SelectAndOrderByTestData_OddBeforeEven))]
+    public void SelectAndOrderByAsArray_OddBeforeEven(IEnumerable<ValueHolder<int>> data, ImmutableArray<ValueHolder<string>> expected, Func<ValueHolder<int>, ValueHolder<string>> selector)
+    {
+        var sorted = data.SelectAndOrderByAsArray(selector, static x => x.Value, OddBeforeEvenString);
+        AssertEqual(expected, sorted);
+    }
+
+    [Theory]
+    [MemberData(nameof(SelectAndOrderByDescendingTestData))]
+    public void SelectAndOrderByDescendingAsArray(IEnumerable<ValueHolder<int>> data, ImmutableArray<ValueHolder<string>> expected, Func<ValueHolder<int>, ValueHolder<string>> selector)
+    {
+        var sorted = data.SelectAndOrderByDescendingAsArray(selector, static x => x.Value);
+        AssertEqual(expected, sorted);
+    }
+
+    [Theory]
+    [MemberData(nameof(SelectAndOrderByDescendingTestData_OddBeforeEven))]
+    public void SelectAndOrderByDescendingAsArray_OddBeforeEven(IEnumerable<ValueHolder<int>> data, ImmutableArray<ValueHolder<string>> expected, Func<ValueHolder<int>, ValueHolder<string>> selector)
+    {
+        var sorted = data.SelectAndOrderByDescendingAsArray(selector, static x => x.Value, OddBeforeEvenString);
+        AssertEqual(expected, sorted);
+    }
+
 #if NET // Enumerable.Order(...) and Enumerable.OrderDescending(...) were introduced in .NET 7
 
     [Fact]

src/Shared/Microsoft.AspNetCore.Razor.Utilities.Shared.Test/ImmutableArrayExtensionsTests.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using Xunit;
 
@@ -36,4 +37,72 @@ public void GetMostRecentUniqueItems()
             },
             s => Assert.Equal("WoRlD", s));
     }
+
+    [Fact]
+    public void SelectAsArray()
+    {
+        ImmutableArray<int> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        ImmutableArray<int> expected = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20];
+
+        var actual = data.SelectAsArray(static x => x * 2);
+        Assert.Equal<int>(expected, actual);
+    }
+
+    [Fact]
+    public void SelectAsArray_ReadOnlyList()
+    {
+        ImmutableArray<int> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        ImmutableArray<int> expected = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20];
+
+        var list = (IReadOnlyList<int>)data;
+
+        var actual = list.SelectAsArray(static x => x * 2);
+        Assert.Equal<int>(expected, actual);
+    }
+
+    [Fact]
+    public void SelectAsArray_Enumerable()
+    {
+        ImmutableArray<int> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        ImmutableArray<int> expected = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20];
+
+        var enumerable = (IEnumerable<int>)data;
+
+        var actual = enumerable.SelectAsArray(static x => x * 2);
+        Assert.Equal<int>(expected, actual);
+    }
+
+    [Fact]
+    public void SelectAsArray_Index()
+    {
+        ImmutableArray<int> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        ImmutableArray<int> expected = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+
+        var actual = data.SelectAsArray(static (x, index) => x + index);
+        Assert.Equal<int>(expected, actual);
+    }
+
+    [Fact]
+    public void SelectAsArray_Index_ReadOnlyList()
+    {
+        ImmutableArray<int> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        ImmutableArray<int> expected = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+
+        var list = (IReadOnlyList<int>)data;
+
+        var actual = list.SelectAsArray(static (x, index) => x + index);
+        Assert.Equal<int>(expected, actual);
+    }
+
+    [Fact]
+    public void SelectAsArray_Index_Enumerable()
+    {
+        ImmutableArray<int> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        ImmutableArray<int> expected = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+
+        var enumerable = (IEnumerable<int>)data;
+
+        var actual = enumerable.SelectAsArray(static (x, index) => x + index);
+        Assert.Equal<int>(expected, actual);
+    }
 }