private static IOrderedAsyncEnumerable <TSource> ThenByShim <TSource, TKey>(
IOrderedAsyncEnumerable <TSource> source, Func <TSource, TKey> expression, OrderingDirection orderingDirection)
{
return(orderingDirection == OrderingDirection.Asc
? source.ThenBy(expression)
: source.ThenByDescending(expression));
}
/// <summary>
/// Performs a subsequent ordering of the elements in a sequence in ascending order by using a specified comparer.
/// </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">An ordered async-enumerable sequence that contains elements to sort.</param>
/// <param name="keySelector">A function to extract a key from each element.</param>
/// <param name="comparer">A comparer to compare keys.</param>
/// <returns>An ordered async-enumerable whose elements are sorted according to a key.</returns>
/// <exception cref="ArgumentNullException"><paramref name="source"/> or <paramref name="keySelector"/> is null.</exception>
public static IOrderedAsyncEnumerable <TSource> ThenBy <TSource, TKey>(this IOrderedAsyncEnumerable <TSource> source, Func <TSource, TKey> keySelector, IComparer <TKey> comparer)
{
if (source == null)
{
throw Error.ArgumentNull(nameof(source));
}
return(source.CreateOrderedEnumerable(keySelector, comparer, descending: false));
}
public static IOrderedAsyncEnumerable <T> ThenBy <T>(this IOrderedAsyncEnumerable <T> source, string column,
SortDirection direction, IEnumerable <string>?extraAllowedColumns = null)
{
var lambda = CreatePropertySelector <T>(column, extraAllowedColumns);
if (direction == SortDirection.Descending)
{
return(source.ThenByDescending(lambda));
}
return(source.ThenBy(lambda));
}
public static IOrderedAsyncEnumerable <TSource> ThenBy <TSource, TKey>(this IOrderedAsyncEnumerable <TSource> source, Func <TSource, TKey> keySelector)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (keySelector == null)
{
throw new ArgumentNullException(nameof(keySelector));
}
return(source.ThenBy(keySelector, Comparer <TKey> .Default));
}
/// <summary>
/// Sort a sequence in ascending order, based on a particular key
/// </summary>
/// <typeparam name="TSource">The type of elements in the sequence</typeparam>
/// <typeparam name="TKey">The type of key</typeparam>
/// <param name="source">The sequence of elements</param>
/// <param name="keySelector">The function to extract a key value from an element</param>
/// <returns>The sorted sequence</returns>
public static IOrderedAsyncEnumerable <TSource> ThenByDescending <TSource, TKey>(
this IOrderedAsyncEnumerable <TSource> source,
Func <TSource, ValueTask <TKey> > keySelector)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (keySelector == null)
{
throw new ArgumentNullException(nameof(keySelector));
}
return(source.CreateOrderedEnumerable(keySelector, null, true));
}
/// <summary>
/// Sort a sequence in ascending order, based on a particular key
/// </summary>
/// <typeparam name="TSource">The type of elements in the sequence</typeparam>
/// <typeparam name="TKey">The type of key</typeparam>
/// <param name="source">The sequence of elements</param>
/// <param name="keySelector">The function to extract a key value from an element</param>
/// <param name="comparer">The function to use to compare keys</param>
/// <returns>The sorted sequence</returns>
public static IOrderedAsyncEnumerable <TSource> ThenBy <TSource, TKey>(
this IOrderedAsyncEnumerable <TSource> source,
Func <TSource, ValueTask <TKey> > keySelector,
IComparer <TKey> comparer)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (keySelector == null)
{
throw new ArgumentNullException(nameof(keySelector));
}
return(source.CreateOrderedEnumerable(keySelector, comparer, false));
}
private static IOrderedAsyncEnumerable <TValue> ThenByCore <TKey, TValue>(IOrderedAsyncEnumerable <TValue> enumerable, Func <TValue, Task <TKey> > keySelector, IComparer <TKey> comparer, bool descending)
{
if (enumerable == null)
{
throw new ArgumentNullException("enumerable");
}
if (keySelector == null)
{
throw new ArgumentNullException("keySelector");
}
if (comparer == null)
{
throw new ArgumentNullException("comparer");
}
return(enumerable.CreateOrderedEnumerable(keySelector, comparer, descending));
}
private async Task OnClientSelected()
{
IsBusy = true;
try
{
Projects.Clear();
if (selectedClient != null)
{
IOrderedAsyncEnumerable <ProjectModel> list = harvestClient.Projects
.ListAsync(selectedClient.Id, true)
.Select(i => new ProjectModel(i))
.OrderBy(i => i.Code);
await foreach (var project in list)
{
Projects.Add(project);
}
}
}
finally
{
IsBusy = false;
}
}
private static IOrderedAsyncEnumerable <T> ThenByDescending <T>(this IOrderedAsyncEnumerable <T> source, string propertyName)
{
return(ApplyOrder <T>(source, propertyName, nameof(AsyncEnumerable.ThenByDescending)));
}
private static IOrderedAsyncEnumerable <TSource> ThenByDescendingAwaitWithCancellationCore <TSource, TKey>(this IOrderedAsyncEnumerable <TSource> source, Func <TSource, CancellationToken, ValueTask <TKey> > keySelector, IComparer <TKey> comparer)
{
if (source == null)
{
throw Error.ArgumentNull(nameof(source));
}
return(source.CreateOrderedEnumerable(keySelector, comparer, descending: true));
}
private static IOrderedAsyncEnumerable <TSource> ThenByDescendingAwaitCore <TSource, TKey>(this IOrderedAsyncEnumerable <TSource> source, Func <TSource, ValueTask <TKey> > keySelector)
{
if (source == null)
{
throw Error.ArgumentNull(nameof(source));
}
return(source.CreateOrderedEnumerable(keySelector, comparer: default(IComparer <TKey>), descending: true));
}
public static IOrderedAsyncEnumerable <TValue> ThenBy <TKey, TValue>(this IOrderedAsyncEnumerable <TValue> enumerable, Func <TValue, Task <TKey> > keySelector, IComparer <TKey> comparer)
{
return(ThenByCore(enumerable, keySelector, comparer, false));
}
private static async Task <FileStream> PopulateCsvStreamAsync(FileStream fileStream, string separator, IOrderedAsyncEnumerable <AggregatedResult> aggregatedResults)
{
var headers = new List <string> {
"#", "Username", "Total Score", "Total tie breaks", "Average Performance", "Max Rating", "Title", "Ranks", "Scores", "Tie breaks"
};
using var sw = new StreamWriter(fileStream);
sw.WriteLine(string.Join(separator, headers));
var internalSeparator = separator == ";" ? ", " : "; ";
string aggregate <T>(IEnumerable <T> items) => $"[{string.Join(internalSeparator, items)}]";
await foreach (var aggregatedResult in aggregatedResults.Select((value, i) => new { i, value }))
{
var result = aggregatedResult.value;
var columns = new string[] { (aggregatedResult.i + 1).ToString(), result.Username, result.TotalScores.ToString(), result.TotalTieBreaks.ToString(), result.AveragePerformance.ToString("F"), result.MaxRating.ToString(), result.Title, aggregate(result.Ranks), aggregate(result.Scores), aggregate(result.TieBreaks) };
sw.WriteLine(string.Join(separator, columns));
}
return(fileStream);
}
public static IOrderedAsyncEnumerable <TSource> ThenByDescending <TSource, TKey>(this IOrderedAsyncEnumerable <TSource> source, Func <TSource, TKey> keySelector, IComparer <TKey> comparer) => LinqEnumerable.ThenByDescending(source, keySelector, comparer);
public static IOrderedAsyncEnumerable <TSource> ThenBy <TSource, TKey>(this IOrderedAsyncEnumerable <TSource> source, Func <TSource, TKey> keySelector) => LinqEnumerable.ThenBy(source, keySelector);
internal static IOrderedAsyncEnumerable <TSource> _ThenBy <TSource, TKey>(
IOrderedAsyncEnumerable <TSource> source, Func <TSource, TKey> expression, OrderingDirection orderingDirection)
=> orderingDirection == OrderingDirection.Asc
? source.ThenBy(expression)
: source.ThenByDescending(expression);
public static IOrderedAsyncEnumerable <TValue> ThenByDescending <TKey, TValue>(this IOrderedAsyncEnumerable <TValue> enumerable, Func <TValue, Task <TKey> > keySelector)
{
return(ThenByCore(enumerable, keySelector, Comparer <TKey> .Default, true));
}
