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);
}
}
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);
}
}
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);
}
async Task IMultiplexingEnumerableOpen.Open()
{
if (Interlocked.CompareExchange(ref isOpen, 1, 0) != 0)
{
throw new InvalidOperationException("Can not open twice");
}
enumerator = await inner.GetEnumerator();
awaitedEnumerators = totalEnumerators;
open.SetResult(1);
}
async ValueTask <SearchResultMessage> ISearchingParser.GetNext()
{
if (enumerator == null)
{
enumerator = await impl.GetEnumerator();
}
if (!await enumerator.MoveNext())
{
return(new SearchResultMessage());
}
return(enumerator.Current);
}
public async Task <bool> MoveNextAsync(CancellationToken cancellationToken)
{
if (!_initialized)
{
_data = await _dataProvider(cancellationToken);
_source = _parserProvider(_data).GetEnumerator();
_initialized = true;
}
return(await _source.MoveNextAsync(cancellationToken));
}
public DictionaryAsync(IEnumerableAsync <TElement> enumerable,
Func <TElement, TKey> keySelector,
Func <TElement, TValue> valueSelector,
Func <TKey, TKey, bool> comparison = default(Func <TKey, TKey, bool>))
{
this.enumerable = enumerable;
this.dictionary = new Dictionary <TKey, TValue>();
this.keySelector = keySelector;
this.valueSelector = valueSelector;
this.tryNextEnumerator = enumerable.GetEnumerator();
this.dictionaryLock = new AutoResetEvent(true);
if (comparison.IsDefaultOrNull())
{
comparison = (key1, key2) => key1.Equals(key2);
}
this.comparison = comparison;
}
public static IEnumerableAsync <Tuple <T1, T2> > Zip <T1, T2>(this IEnumerableAsync <T1> input1, IEnumerableAsync <T2> input2)
{
return(Produce <Tuple <T1, T2> >(async yieldAsync =>
{
IEnumeratorAsync <T1> enum1 = NullEnumerator <T1> .Instance;
IEnumeratorAsync <T2> enum2 = NullEnumerator <T2> .Instance;
await TryFinallyAsync(
async() =>
{
enum1 = await input1.GetEnumerator();
enum2 = await input2.GetEnumerator();
while (AllTrue(await Task.WhenAll(enum1.MoveNext(), enum2.MoveNext())))
{
await yieldAsync.YieldAsync(Tuple.Create(enum1.Current, enum2.Current));
}
return 0;
},
() => Task.WhenAll(enum1.Dispose(), enum2.Dispose())
);
}));
}
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 async Task <bool> MoveNextAsync()
{
while (_asyncEnumerators.Count > 0)
{
T currentValue = default(T);
var hasValue = false;
List <IEnumeratorAsync <T> > completedEnums = null;
if (firstPass)
{
foreach (IEnumeratorAsync <T> enumerator in _asyncEnumerators)
{
if (!await enumerator.MoveNextAsync())
{
if (completedEnums == null)
{
completedEnums = new List <IEnumeratorAsync <T> >();
}
completedEnums.Add(enumerator);
}
else
{
if (!hasValue || _orderingComparer.Compare(currentValue, enumerator.Current) > 0)
{
hasValue = true;
currentValue = enumerator.Current;
_currentEnumeratorAsync = enumerator;
}
}
}
firstPass = false;
}
else
{
foreach (IEnumeratorAsync <T> enumerator in _asyncEnumerators)
{
bool hasNext = true;
if (enumerator == _lastAwaitedEnumeratorAsync)
{
hasNext = await enumerator.MoveNextAsync();
if (!hasNext)
{
if (completedEnums == null)
{
completedEnums = new List <IEnumeratorAsync <T> >();
}
completedEnums.Add(enumerator);
}
}
if (hasNext && (!hasValue || _orderingComparer.Compare(currentValue, enumerator.Current) > 0))
{
hasValue = true;
currentValue = enumerator.Current;
_currentEnumeratorAsync = enumerator;
}
}
}
_lastAwaitedEnumeratorAsync = _currentEnumeratorAsync;
//Remove all the enums that don't have a next value
if (completedEnums != null)
{
_asyncEnumerators.RemoveAll(obj => completedEnums.Contains(obj));
}
if (hasValue)
{
if (_seen.Add(currentValue))
{
return(true);
}
}
}
return(false);
}
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 WhereEnumerator(IEnumeratorAsync <TSource> source, Func <TSource, bool> predicate)
{
_source = source;
_predicate = predicate;
}
public FuncEnumerator(IEnumeratorAsync <TSource> source, Func <TSource, TResult> func)
{
_source = source;
_func = func;
}
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));
}
