private async Task PrintPackages(ListArgs listArgs, IEnumeratorAsync <IPackageSearchMetadata> asyncEnumerator) { bool hasPackages = false; if (asyncEnumerator != null) { if (listArgs.IsDetailed) { /*********************************************** * Package-Name * 1.0.0.2010 * This is the package Description * * Package-Name-Two * 2.0.0.2010 * This is the second package Description ***********************************************/ while (await asyncEnumerator.MoveNextAsync()) { var p = asyncEnumerator.Current; listArgs.PrintJustified(0, p.Identity.Id); listArgs.PrintJustified(1, p.Identity.Version.ToFullString()); listArgs.PrintJustified(1, p.Description); if (!string.IsNullOrEmpty(p.LicenseUrl?.OriginalString)) { listArgs.PrintJustified(1, string.Format( CultureInfo.InvariantCulture, listArgs.ListCommandLicenseUrl, p.LicenseUrl.OriginalString)); } Console.WriteLine(); hasPackages = true; } } else { /*********************************************** * Package-Name 1.0.0.2010 * Package-Name-Two 2.0.0.2010 ***********************************************/ while (await asyncEnumerator.MoveNextAsync()) { var p = asyncEnumerator.Current; listArgs.PrintJustified(0, p.Identity.Id + " " + p.Identity.Version.ToFullString()); hasPackages = true; } } } if (!hasPackages) { Console.WriteLine(listArgs.ListCommandNoPackages); } }
private static async Task <TResult> SelectOptionalAsync <TItem, TSelect, TCarry, TResult>(IEnumeratorAsync <TItem> enumerable, TCarry carry, IEnumerableAsync <TSelect> selecteds, Func <TSelect, Task> selectSelection, Func <TItem, TCarry, Func <TSelect, TCarry, Task <TResult> >, Func <TCarry, Task <TResult> >, Task <TResult> > selection, Func <IEnumerableAsync <TSelect>, TCarry, TResult> aggregation) { if (!await enumerable.MoveNextAsync()) { return(aggregation(selecteds, carry)); } return(await selection(enumerable.Current, carry, async (selected, carryUpdated) => { await selectSelection(selected); return await SelectOptionalAsync(enumerable, carryUpdated, selecteds, selectSelection, selection, aggregation); }, async (carryUpdated) => { return await SelectOptionalAsync(enumerable, carryUpdated, selecteds, selectSelection, selection, aggregation); })); }
public static async Task ForEachAsync <TSource>(this IEnumerableAsync <TSource> source, Func <TSource, Task> iterationAction, CancellationToken cancellationToken) { using (IEnumeratorAsync <TSource> en = source.GetEnumerator()) while (await en.MoveNextAsync(cancellationToken)) { await iterationAction(en.Current); } }
public async Task <bool> MoveNextAsync(CancellationToken cancellationToken) { bool result; while ((result = await _source.MoveNextAsync(cancellationToken)) && !_predicate(_source.Current)) { ; } return(result); }
public static async Task <List <T> > ToListAsync <T>(this IEnumeratorAsync <T> enumerator, CancellationToken cancellationToken = default(CancellationToken)) { var list = new List <T>(); while (await enumerator.MoveNextAsync(cancellationToken).ConfigureAwait(false)) { list.Add(enumerator.Current); } return(list); }
public async Task <bool> MoveNextAsync(CancellationToken cancellationToken) { if (!_initialized) { _data = await _dataProvider(cancellationToken); _source = _parserProvider(_data).GetEnumerator(); _initialized = true; } return(await _source.MoveNextAsync(cancellationToken)); }
private async Task <KeyValuePair <bool, TValue> > GetLockedValueAsync(TKey key) { dictionaryLock.WaitOne(); try { if (dictionary.ContainsKey(key)) { return(dictionary[key].PairWithKey(true)); } if (!isEnumerating) { return(default(TValue).PairWithKey(false)); } while (true) { if (!await tryNextEnumerator.MoveNextAsync()) { isEnumerating = false; return(default(TValue).PairWithKey(false)); } var element = tryNextEnumerator.Current; var elementKey = this.keySelector(element); var elementValue = this.valueSelector(element); dictionary.Add(elementKey, elementValue); if (!comparison(elementKey, key)) { continue; } return(elementValue.PairWithKey(true)); } } catch (Exception) { throw; } finally { dictionaryLock.Set(); } }
public static IObservable <T> ToObservable <T>(this IEnumeratorAsync <T> enumeratorAsync) { var nextItem = Observable.Defer(() => enumeratorAsync.MoveNextAsync().ToObservable()); return(nextItem.Repeat().TakeUntil(b => !b).Select(b => enumeratorAsync.Current)); }
public Task <bool> MoveNextAsync(CancellationToken cancellationToken) => _source.MoveNextAsync(cancellationToken);
public static async Task <T> FirstOrDefaultAsync <T>(this IEnumerableAsync <T> source, CancellationToken cancellationToken) { using (IEnumeratorAsync <T> en = source.GetEnumerator()) return(await en.MoveNextAsync(cancellationToken) ? en.Current : default(T)); }