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)); }