protected async Task <bool> LoadFromEnumerator(CancellationToken cancellationToken)
{
if (await enumerator.MoveNext(cancellationToken)
.ConfigureAwait(false))
{
current = enumerator.Current;
return(true);
}
enumerator?.Dispose();
enumerator = null;
return(false);
}
protected override void Cleanup()
{
try
{
m_chunkIterator?.Dispose();
}
finally
{
m_chunkIterator = null;
m_chunk = null;
m_outOfChunks = true;
m_currentOffsetInChunk = 0;
m_itemsRemainingInChunk = 0;
}
}
protected override async Task <bool> MoveNextCore(CancellationToken cancellationToken)
{
switch (state)
{
case AsyncIteratorState.Allocated:
queue = new Queue <IAsyncEnumerable <TSource> >();
queue.Enqueue(source);
state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
while (true)
{
if (enumerator == null)
{
if (queue.Count > 0)
{
var src = queue.Dequeue();
enumerator?.Dispose();
enumerator = src.GetEnumerator();
continue; // loop
}
break; // while
}
if (await enumerator.MoveNext(cancellationToken)
.ConfigureAwait(false))
{
var item = enumerator.Current;
var next = selector(item);
queue.Enqueue(next);
current = item;
return(true);
}
enumerator.Dispose();
enumerator = null;
}
break; // case
}
Dispose();
return(false);
}
protected override async Task <bool> MoveNextCore(CancellationToken cancellationToken)
{
switch (state)
{
case AsyncIteratorState.Allocated:
sourceEnumerator = source.GetEnumerator();
mode = State_Source;
state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
switch (mode)
{
case State_Source:
if (await sourceEnumerator.MoveNext(cancellationToken)
.ConfigureAwait(false))
{
resultEnumerator?.Dispose();
resultEnumerator = selector(sourceEnumerator.Current)
.GetEnumerator();
mode = State_Result;
goto case State_Result;
}
break;
case State_Result:
if (await resultEnumerator.MoveNext(cancellationToken)
.ConfigureAwait(false))
{
current = resultEnumerator.Current;
return(true);
}
mode = State_Source;
goto case State_Source; // loop
}
break;
}
Dispose();
return(false);
}
protected override async Task <bool> MoveNextCore(CancellationToken cancellationToken)
{
switch (state)
{
case AsyncIteratorState.Allocated:
_outerEnumerator = _source.GetEnumerator();
_mode = State_OuterNext;
state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
switch (_mode)
{
case State_OuterNext:
if (_outerEnumerator.MoveNext())
{
// make sure we dispose the previous one if we're about to replace it
_currentEnumerator?.Dispose();
_currentEnumerator = _outerEnumerator.Current.GetEnumerator();
_mode = State_While;
goto case State_While;
}
break;
case State_While:
if (await _currentEnumerator.MoveNext(cancellationToken)
.ConfigureAwait(false))
{
current = _currentEnumerator.Current;
return(true);
}
// No more on the inner enumerator, move to the next outer
goto case State_OuterNext;
}
Dispose();
break;
}
return(false);
}
internal static IAsyncEnumerator <T> GetEnumerator([NotNull] FdbAsyncSequenceQuery <T> sequence, AsyncIterationHint mode)
{
var generator = sequence.CompileSequence(sequence.Expression);
if (sequence.Transaction != null)
{
var source = generator(sequence.Transaction);
Contract.Assert(source != null);
return(source is IConfigurableAsyncEnumerable <T> configurable?configurable.GetAsyncEnumerator(sequence.Transaction.Cancellation, mode) : source.GetAsyncEnumerator());
}
//BUGBUG: how do we get a CancellationToken without a transaction?
var ct = CancellationToken.None;
IFdbTransaction trans = null;
IAsyncEnumerator <T> iterator = null;
bool success = true;
try
{
trans = sequence.Database.BeginTransaction(ct);
var source = generator(trans);
Contract.Assert(source != null);
iterator = source is IConfigurableAsyncEnumerable <T> configurable?configurable.GetAsyncEnumerator(ct, mode) : source.GetAsyncEnumerator();
return(new TransactionIterator(trans, iterator));
}
catch (Exception)
{
success = false;
throw;
}
finally
{
if (!success)
{
iterator?.Dispose();
trans?.Dispose();
}
}
}
public void Dispose()
{
source.Dispose();
}
public void Dispose() => _innerEnumerator.Dispose();
public void Dispose()
{
first.Dispose();
second.Dispose();
}
public override void Dispose() => _enumerator.Dispose();
public void Dispose()
{
asyncEnumerator.Dispose();
}
public void Dispose()
{
_enumerator.Dispose();
}
public void Dispose()
{
_sourceEnumerator?.Dispose();
_groupJoinAsyncEnumerable._innerGroupJoinInclude?.Dispose();
_groupJoinAsyncEnumerable._outerGroupJoinInclude?.Dispose();
}
public void Dispose() => m_inner.Dispose();
public void Dispose() => _sourceEnumerator?.Dispose();
public void Dispose()
{
_outer.Dispose();
}
public void Dispose()
{
_enumerator.Dispose();
_transaction?.Dispose();
}
public void Dispose()
{
_relatedValuesIterator.Dispose();
_enumerator.Dispose();
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual async Task IncludeCollectionAsync(
int includeId,
INavigation navigation,
INavigation inverseNavigation,
IEntityType targetEntityType,
IClrCollectionAccessor clrCollectionAccessor,
IClrPropertySetter inverseClrPropertySetter,
bool tracking,
object entity,
Func <IAsyncEnumerable <object> > relatedEntitiesFactory,
CancellationToken cancellationToken)
{
IDisposable untypedAsyncEnumerator = null;
IAsyncEnumerator <object> asyncEnumerator = null;
if (includeId == -1 ||
!_includedCollections.TryGetValue(includeId, out untypedAsyncEnumerator))
{
asyncEnumerator = relatedEntitiesFactory().GetEnumerator();
if (!await asyncEnumerator.MoveNext(cancellationToken))
{
asyncEnumerator.Dispose();
asyncEnumerator = null;
}
if (includeId != -1)
{
_includedCollections.Add(includeId, asyncEnumerator);
}
}
if (asyncEnumerator == null)
{
if (untypedAsyncEnumerator == null)
{
clrCollectionAccessor.GetOrCreate(entity);
return;
}
asyncEnumerator = (IAsyncEnumerator <object>)untypedAsyncEnumerator;
}
var relatedEntities = new List <object>();
// TODO: This should be done at query compile time and not require a VB unless there are shadow props
var keyComparer = CreateIncludeKeyComparer(entity, navigation);
while (true)
{
bool shouldInclude;
if (_valueBuffers.TryGetValue(asyncEnumerator.Current, out var relatedValueBuffer))
{
shouldInclude = keyComparer.ShouldInclude((ValueBuffer)relatedValueBuffer);
}
else
{
var entry = _dependencies.StateManager.TryGetEntry(asyncEnumerator.Current);
Debug.Assert(entry != null);
shouldInclude = keyComparer.ShouldInclude(entry);
}
if (shouldInclude)
{
relatedEntities.Add(asyncEnumerator.Current);
if (tracking)
{
StartTracking(asyncEnumerator.Current, targetEntityType);
}
if (inverseNavigation != null)
{
Debug.Assert(inverseClrPropertySetter != null);
inverseClrPropertySetter.SetClrValue(asyncEnumerator.Current, entity);
if (tracking)
{
var internalEntityEntry = _dependencies.StateManager.TryGetEntry(asyncEnumerator.Current);
Debug.Assert(internalEntityEntry != null);
internalEntityEntry.SetRelationshipSnapshotValue(inverseNavigation, entity);
}
}
if (!await asyncEnumerator.MoveNext(cancellationToken))
{
asyncEnumerator.Dispose();
_includedCollections[includeId] = null;
break;
}
}
else
{
break;
}
}
clrCollectionAccessor.AddRange(entity, relatedEntities);
if (tracking)
{
var internalEntityEntry = _dependencies.StateManager.TryGetEntry(entity);
Debug.Assert(internalEntityEntry != null);
internalEntityEntry.AddRangeToCollectionSnapshot(navigation, relatedEntities);
internalEntityEntry.SetIsLoaded(navigation);
}
}
public void Dispose()
{
enum1.Dispose();
}
public virtual void Dispose()
{
_relatedValuesEnumerator.Dispose();
}
public static ValueTask DisposeAsync <T>(this IAsyncEnumerator <T> enumerator)
{
enumerator.Dispose();
return(default);
public void Dispose()
{
_innerEnumerator?.Dispose();
_exceptionInterceptor._queryContext.Dispose();
}
public override void Dispose()
{
_asyncEnumerator.Dispose();
}
public void Dispose() => _enumerator.Dispose();
public void Dispose() => _asyncEnumerator.Dispose();
public void Dispose()
{
_inner.Dispose();
}
protected override void Dispose(bool disposing)
{
source.Dispose();
source = null;
}
public void Dispose()
{
_sourceEnumerator?.Dispose();
_innerGroupJoinIncludeContext?.Dispose();
_outerGroupJoinIncludeContext?.Dispose();
}
public void Dispose() => _underlyingStream.Dispose();