Skip to content

Commit

Permalink
Merge pull request #4 from felsokning/feature/CollectionExtensions_Ad…
Browse files Browse the repository at this point in the history 
…ditions

Adding More Extensions for Collections to Chain Queries
  • Loading branch information
@felsokning
felsokning authored Jan 30, 2024
2 parents cd31e0d + 91ab635 commit 18e4c1d
Show file tree
Hide file tree
Showing 2 changed files with 270 additions and 0 deletions.
150 changes: 150 additions & 0 deletions Felsökning.Tests/CollectionExtensionsTests.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -52,5 +52,155 @@ public async Task EnumerableOfType_ToAsyncEnumerable_ShouldReturnIAsyncEnumerabl
item.Should().BeGreaterThan(0);
}
}

[TestMethod]
public void CollectionOfType_OrderByChained_ShouldReturnIOrderedEnumerable()
{
var list = new Collection<SampleJson>
{
new() { Id = 1, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "B Test Title", UserId = 1 },
};

var sut = (ICollection<SampleJson>)list;
var result = sut.OrderByChained([x => x.Id, x => x.UserId]);
result.Should().NotBeEmpty();
var resultingList = result.ToList();
var firstRow = resultingList[0];
firstRow.Id.Should().Be(1);
firstRow.UserId.Should().Be(0);
var secondRow = resultingList[1];
secondRow.Id.Should().Be(2);
secondRow.UserId.Should().Be(0);
var thirdRow = resultingList[2];
thirdRow.Id.Should().Be(2);
thirdRow.UserId.Should().Be(1);
}

[TestMethod]
public void EnumerableOfType_OrderByChained_ShouldReturnIOrderedEnumerable()
{
var list = new List<SampleJson>
{
new() { Id = 1, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "B Test Title", UserId = 1 },
};

var sut = (IEnumerable<SampleJson>)list;

var result = sut.OrderByChained([x => x.Id, x => x.UserId]);
result.Should().NotBeEmpty();
var resultingList = result.ToList();
var firstRow = resultingList[0];
firstRow.Id.Should().Be(1);
firstRow.UserId.Should().Be(0);
var secondRow = resultingList[1];
secondRow.Id.Should().Be(2);
secondRow.UserId.Should().Be(0);
var thirdRow = resultingList[2];
thirdRow.Id.Should().Be(2);
thirdRow.UserId.Should().Be(1);
}

[TestMethod]
public void ListOfType_OrderByChained_ShouldReturnIOrderedEnumerable()
{
var list = new List<SampleJson>
{
new() { Id = 1, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "B Test Title", UserId = 1 },
};

var result = list.OrderByChained([x => x.Id, x => x.UserId]);
result.Should().NotBeEmpty();
var resultingList = result.ToList();
var firstRow = resultingList[0];
firstRow.Id.Should().Be(1);
firstRow.UserId.Should().Be(0);
var secondRow = resultingList[1];
secondRow.Id.Should().Be(2);
secondRow.UserId.Should().Be(0);
var thirdRow = resultingList[2];
thirdRow.Id.Should().Be(2);
thirdRow.UserId.Should().Be(1);
}

[TestMethod]
public void CollectionOfType_OrderByDescendingChained_ShouldReturnIOrderedEnumerable()
{
var list = new Collection<SampleJson>
{
new() { Id = 1, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "B Test Title", UserId = 1 },
};

var sut = (ICollection<SampleJson>)list;
var result = sut.OrderByDescendingChained([x => x.Id, x => x.UserId]);
result.Should().NotBeEmpty();
var resultingList = result.ToList();
var firstRow = resultingList[0];
firstRow.Id.Should().Be(2);
firstRow.UserId.Should().Be(1);
var secondRow = resultingList[1];
secondRow.Id.Should().Be(2);
secondRow.UserId.Should().Be(0);
var thirdRow = resultingList[2];
thirdRow.Id.Should().Be(1);
thirdRow.UserId.Should().Be(0);
}

[TestMethod]
public void EnumerableOfType_OrderByDescendingChained_ShouldReturnIOrderedEnumerable()
{
var list = new List<SampleJson>
{
new() { Id = 1, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "B Test Title", UserId = 1 },
};

var sut = (IEnumerable<SampleJson>)list;

var result = sut.OrderByDescendingChained([x => x.Id, x => x.UserId]);
result.Should().NotBeEmpty();
var resultingList = result.ToList();
var firstRow = resultingList[0];
firstRow.Id.Should().Be(2);
firstRow.UserId.Should().Be(1);
var secondRow = resultingList[1];
secondRow.Id.Should().Be(2);
secondRow.UserId.Should().Be(0);
var thirdRow = resultingList[2];
thirdRow.Id.Should().Be(1);
thirdRow.UserId.Should().Be(0);
}

[TestMethod]
public void ListOfType_OrderByDescendingChained_ShouldReturnIOrderedEnumerable()
{
var list = new List<SampleJson>
{
new() { Id = 1, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "A Test Title", UserId = 0 },
new() { Id = 2, Completed = true, Title = "B Test Title", UserId = 1 },
};

var result = list.OrderByDescendingChained([x => x.Id, x => x.UserId]);
result.Should().NotBeEmpty();
var resultingList = result.ToList();
var firstRow = resultingList[0];
firstRow.Id.Should().Be(2);
firstRow.UserId.Should().Be(1);
var secondRow = resultingList[1];
secondRow.Id.Should().Be(2);
secondRow.UserId.Should().Be(0);
var thirdRow = resultingList[2];
thirdRow.Id.Should().Be(1);
thirdRow.UserId.Should().Be(0);
}
}
}
120 changes: 120 additions & 0 deletions Felsökning/CollectionExtensions.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -55,5 +55,125 @@ public static async IAsyncEnumerable<T> ToIAsyncEnumerable<T>(this IList<T> valu
yield return item;
}
}

/// <summary>
/// Sorts the elements of a sequence in ascending order.
/// </summary>
/// <typeparam name="TSource">The type of the elements of source.</typeparam>
/// <typeparam name="TKey">The type of the key returned by keySelector.</typeparam>
/// <param name="source">A sequence of values to order.</param>
/// <param name="keySelectors">An array of functions to extract a key from an element.</param>
/// <returns>An <see cref="IOrderedEnumerable{TElement}"/> whose elements are sorted in ascending order according to multiple keys.</returns>
public static IOrderedEnumerable<TSource> OrderByChained<TSource, TKey>(this ICollection<TSource> source, Func<TSource, TKey>[] keySelectors)
{
IOrderedEnumerable<TSource> result = source.OrderBy(keySelectors[0]);
foreach (var keySelector in keySelectors)
{
// For some reason, if we don't do Func<TSource, TKey>[0], again, it is ignored.
result = result.CreateOrderedEnumerable<TKey>(keySelector, null, false);
}

return result;
}

/// <summary>
/// Sorts the elements of a sequence in ascending order.
/// </summary>
/// <typeparam name="TSource">The type of the elements of source.</typeparam>
/// <typeparam name="TKey">The type of the key returned by keySelector.</typeparam>
/// <param name="source">A sequence of values to order.</param>
/// <param name="keySelectors">An array of functions to extract a key from an element.</param>
/// <returns>An <see cref="IOrderedEnumerable{TElement}"/> whose elements are sorted in ascending order according to multiple keys.</returns>
public static IOrderedEnumerable<TSource> OrderByChained<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey>[] keySelectors)
{
IOrderedEnumerable<TSource> result = source.OrderBy(keySelectors[0]);
foreach (var keySelector in keySelectors)
{
// For some reason, if we don't do Func<TSource, TKey>[0], again, it is ignored.
result = result.CreateOrderedEnumerable<TKey>(keySelector, null, false);
}

return result;
}

/// <summary>
/// Sorts the elements of a sequence in ascending order.
/// </summary>
/// <typeparam name="TSource">The type of the elements of source.</typeparam>
/// <typeparam name="TKey">The type of the key returned by keySelector.</typeparam>
/// <param name="source">A sequence of values to order.</param>
/// <param name="keySelectors">An array of functions to extract a key from an element.</param>
/// <returns>An <see cref="IOrderedEnumerable{TElement}"/> whose elements are sorted in ascending order according to multiple keys.</returns>
public static IOrderedEnumerable<TSource> OrderByChained<TSource, TKey>(this IList<TSource> source, Func<TSource, TKey>[] keySelectors)
{
IOrderedEnumerable<TSource> result = source.OrderBy(keySelectors[0]);
foreach (var keySelector in keySelectors)
{
// For some reason, if we don't do Func<TSource, TKey>[0], again, it is ignored.
result = result.CreateOrderedEnumerable<TKey>(keySelector, null, false);
}

return result;
}

/// <summary>
/// Sorts the elements of a sequence in descending order.
/// </summary>
/// <typeparam name="TSource">The type of the elements of source.</typeparam>
/// <typeparam name="TKey">The type of the key returned by keySelector.</typeparam>
/// <param name="source">A sequence of values to order.</param>
/// <param name="keySelectors">An array of functions to extract a key from an element.</param>
/// <returns>An <see cref="IOrderedEnumerable{TElement}"/> whose elements are sorted in descending order according to multiple keys.</returns>
public static IOrderedEnumerable<TSource> OrderByDescendingChained<TSource, TKey>(this ICollection<TSource> source, Func<TSource, TKey>[] keySelectors)
{
IOrderedEnumerable<TSource> result = source.OrderByDescending(keySelectors[0]);
foreach (var keySelector in keySelectors)
{
// For some reason, if we don't do Func<TSource, TKey>[0], again, it is ignored.
result = result.CreateOrderedEnumerable<TKey>(keySelector, null, true);
}

return result;
}

/// <summary>
/// Sorts the elements of a sequence in descending order.
/// </summary>
/// <typeparam name="TSource">The type of the elements of source.</typeparam>
/// <typeparam name="TKey">The type of the key returned by keySelector.</typeparam>
/// <param name="source">A sequence of values to order.</param>
/// <param name="keySelectors">An array of functions to extract a key from an element.</param>
/// <returns>An <see cref="IOrderedEnumerable{TElement}"/> whose elements are sorted in descending order according to multiple keys.</returns>
public static IOrderedEnumerable<TSource> OrderByDescendingChained<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey>[] keySelectors)
{
IOrderedEnumerable<TSource> result = source.OrderByDescending(keySelectors[0]);
foreach (var keySelector in keySelectors)
{
// For some reason, if we don't do Func<TSource, TKey>[0], again, it is ignored.
result = result.CreateOrderedEnumerable<TKey>(keySelector, null, true);
}

return result;
}

/// <summary>
/// Sorts the elements of a sequence in descending order.
/// </summary>
/// <typeparam name="TSource">The type of the elements of source.</typeparam>
/// <typeparam name="TKey">The type of the key returned by keySelector.</typeparam>
/// <param name="source">A sequence of values to order.</param>
/// <param name="keySelectors">An array of functions to extract a key from an element.</param>
/// <returns>An <see cref="IOrderedEnumerable{TElement}"/> whose elements are sorted in descending order according to multiple keys.</returns>
public static IOrderedEnumerable<TSource> OrderByDescendingChained<TSource, TKey>(this IList<TSource> source, Func<TSource, TKey>[] keySelectors)
{
IOrderedEnumerable<TSource> result = source.OrderByDescending(keySelectors[0]);
foreach (var keySelector in keySelectors)
{
// For some reason, if we don't do Func<TSource, TKey>[0], again, it is ignored.
result = result.CreateOrderedEnumerable<TKey>(keySelector, null, true);
}

return result;
}
}
}

0 comments on commit 18e4c1d

Please sign in to comment.