public async Task <bool> MoveNext()
{
if (_ended)
{
return(false);
}
var batch = new T[_batchSize];
int count = 0;
while (count < _batchSize && await _enumerator.MoveNext())
{
batch[count++] = _enumerator.Current;
}
if (count > 0)
{
if (count < _batchSize)
{
var temp = new T[count];
Array.Copy(batch, temp, count);
batch = temp;
}
Current = batch;
return(true);
}
_ended = true;
Current = default;
return(false);
}
public async Task RunQuery()
{
// Snippet: RunQuery(RunQueryRequest,CallSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize request argument
RunQueryRequest request = new RunQueryRequest
{
Parent = new AnyPathName("[PROJECT]", "[DATABASE]", "[DOCUMENT]", "[ANY_PATH]").ToString(),
};
// Make the request, returning a streaming response
FirestoreClient.RunQueryStream streamingResponse = firestoreClient.RunQuery(request);
// Read streaming responses from server until complete
IAsyncEnumerator <RunQueryResponse> responseStream = streamingResponse.ResponseStream;
while (await responseStream.MoveNext())
{
RunQueryResponse response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for SampleRowKeys</summary>
public async Task SampleRowKeys()
{
// Snippet: SampleRowKeys(SampleRowKeysRequest,CallSettings)
// Create client
BigtableServiceApiClient bigtableServiceApiClient = BigtableServiceApiClient.Create();
// Initialize request argument
SampleRowKeysRequest request = new SampleRowKeysRequest
{
TableNameAsTableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]"),
};
// Make the request, returning a streaming response
BigtableServiceApiClient.SampleRowKeysStream streamingResponse = bigtableServiceApiClient.SampleRowKeys(request);
// Read streaming responses from server until complete
IAsyncEnumerator <SampleRowKeysResponse> responseStream = streamingResponse.ResponseStream;
while (await responseStream.MoveNext())
{
SampleRowKeysResponse response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
public async Task <bool> MoveNext(CancellationToken cancellationToken)
{
if (!await _enumerator.MoveNext())
{
return(false);
}
if (!_checkedEmpty)
{
var empty = true;
for (var i = 0; i < _enumerator.Current.Count; i++)
{
empty &= _enumerator.Current[i] == null;
}
if (empty)
{
return(false);
}
_checkedEmpty = true;
}
return(true);
}
#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
public async Task <bool> MoveNext()
{
if (_ended)
{
return(false);
}
var batch = new T[_batchSize];
int count = 0;
while (count < _batchSize && await _enumerator.MoveNext())
{
batch[count++] = _enumerator.Current;
}
if (count > 0)
{
if (count < _batchSize)
{
var temp = new T[count];
Array.Copy(batch, temp, count);
batch = temp;
}
Current = batch;
return(true);
}
_ended = true;
#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
Current = default;
#pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
return(false);
}
public static Task<bool> MoveNext<T>(this IAsyncEnumerator<T> enumerator)
{
if (enumerator == null)
throw new ArgumentNullException (nameof (enumerator));
return enumerator.MoveNext (CancellationToken.None);
}
protected override async Task <bool> MoveNextCore(CancellationToken cancellationToken)
{
switch (state)
{
case AsyncIteratorState.Allocated:
enumerator = source.GetEnumerator();
accumulated = seed;
state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
if (await enumerator.MoveNext(cancellationToken)
.ConfigureAwait(false))
{
var item = enumerator.Current;
accumulated = accumulator(accumulated, item);
current = accumulated;
return(true);
}
break;
}
Dispose();
return(false);
}
#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
public async Task <bool> MoveNext()
{
try
{
while (_taskQueue.Count < _maxConcurrency && await _enumerator.MoveNext())
{
_taskQueue.Enqueue(_selector.Invoke(_enumerator.Current, _count++));
}
}
catch (Exception ex)
{
throw new AggregateException(Enumerable.Repeat(ex, 1).Concat(await DrainTaskQueue(_taskQueue)));
}
if (_taskQueue.Count == 0)
{
_maxConcurrency = 0;
#pragma warning disable CS8601 // Possible null reference assignment.
Current = default;
#pragma warning restore CS8601 // Possible null reference assignment.
return(false);
}
try
{
Current = await _taskQueue.Dequeue();
return(true);
}
catch (Exception ex)
{
throw new AggregateException(Enumerable.Repeat(ex, 1).Concat(await DrainTaskQueue(_taskQueue)));
}
}
protected override async Task <bool> MoveNextCore(CancellationToken cancellationToken)
{
switch (state)
{
case AsyncIteratorState.Allocated:
firstEnumerator = first.GetEnumerator();
secondEnumerator = second.GetEnumerator();
state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
// We kick these off and join so they can potentially run in parallel
var ft = firstEnumerator.MoveNext(cancellationToken);
var st = secondEnumerator.MoveNext(cancellationToken);
await Task.WhenAll(ft, st)
.ConfigureAwait(false);
if (ft.Result && st.Result)
{
current = selector(firstEnumerator.Current, secondEnumerator.Current);
return(true);
}
Dispose();
break;
}
return(false);
}
public async Task <bool> MoveNext(CancellationToken cancellationToken)
{
using (await _exceptionInterceptor._queryContext.ConcurrencyDetector
.EnterCriticalSectionAsync(cancellationToken))
{
try
{
// TODO remove this when/if bug is resolved in Ix-Async https://github.com/Reactive-Extensions/Rx.NET/issues/166
cancellationToken.ThrowIfCancellationRequested();
return(await _innerEnumerator.MoveNext(cancellationToken));
}
catch (Exception exception)
{
_exceptionInterceptor._logger
.LogError(
CoreLoggingEventId.DatabaseError,
() => new DatabaseErrorLogState(_exceptionInterceptor._contextType),
exception,
e => CoreStrings.LogExceptionDuringQueryIteration(Environment.NewLine, e));
throw;
}
}
}
protected override async Task <bool> MoveNextCore(CancellationToken cancellationToken)
{
switch (_state)
{
case AsyncIteratorState.Allocated:
_enumerator = _source.GetEnumerator();
_state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
if (await _enumerator.MoveNext(cancellationToken).ConfigureAwait(false))
{
_current = await _selector(_enumerator.Current, cancellationToken).ConfigureAwait(false);
return(true);
}
else
{
Dispose();
return(false);
}
default:
return(false);
}
}
public async Task <bool> MoveNext()
{
try
{
while (_taskQueue.Count < _maxConcurrency && await _enumerator.MoveNext())
{
_taskQueue.Enqueue(_selector.Invoke(_enumerator.Current, _count++));
}
}
catch (Exception ex)
{
throw new AggregateException(Enumerable.Repeat(ex, 1).Concat(await DrainTaskQueue(_taskQueue)));
}
if (_taskQueue.Count == 0)
{
_maxConcurrency = 0;
Current = default;
return(false);
}
try
{
Current = await _taskQueue.Dequeue();
return(true);
}
catch (Exception ex)
{
throw new AggregateException(Enumerable.Repeat(ex, 1).Concat(await DrainTaskQueue(_taskQueue)));
}
}
public async Task <bool> MoveNext(CancellationToken cancellationToken)
{
try
{
return(await _inner.MoveNext().ConfigureAwait(continueOnCapturedContext: false));
}
catch (Exception ex)
{
if (DataStoreException.ContainsDataStoreException(ex))
{
if (_logger.Value.IsEnabled(TraceType.Error))
{
_logger.Value.WriteError(Strings.FormatLogDataStoreExceptionRethrow(Strings.LogExceptionDuringQueryIteration), ex);
}
throw;
}
if (_logger.Value.IsEnabled(TraceType.Error))
{
_logger.Value.WriteError(Strings.FormatLogDataStoreExceptionWrap(Strings.LogExceptionDuringQueryIteration), ex);
}
throw new DataStoreException(Strings.DataStoreException, _context, ex);
}
}
public static async Task VisitAsync <T>(this IAsyncEnumerator <T> enumerator, Action <T> visitor)
{
while (await enumerator.MoveNext())
{
visitor(enumerator.Current);
}
}
public static IObservable <T> ToObservable <T>(this IAsyncEnumerator <T> source, CancellationToken cancel = default(CancellationToken))
{
return(Observable.Defer(() =>
{
var subject = new Subject <T>();
Task.Run(async() =>
{
try
{
while (await source.MoveNext(cancel))
{
subject.OnNext(source.Current);
}
subject.OnCompleted();
}
catch (Exception ex)
{
subject.OnError(ex);
}
finally
{
subject.Dispose();
}
});
return subject;
}));
}
public static async Task WriteCollectionAsync(IEdmModel edmModel, ODataUri odataUri,
IAsyncEnumerator <Object> asyncEnumerator, Stream responseStream, CancellationToken cancellationToken)
{
var importSegment = (OperationImportSegment)odataUri.Path.LastSegment;
IEdmOperationImport operationImport = importSegment.OperationImports.Single();
Type returnType = edmModel.GetClrType(operationImport.Operation.ReturnType.Definition);
IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(responseStream, null);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage,
new ODataMessageWriterSettings()
{
EnableMessageStreamDisposal = false, ODataUri = odataUri
}, edmModel))
{
IEdmTypeReference typeRef = OeEdmClrHelper.GetEdmTypeReference(edmModel, returnType);
ODataCollectionWriter writer = messageWriter.CreateODataCollectionWriter(typeRef);
writer.WriteStart(new ODataCollectionStart());
while (await asyncEnumerator.MoveNext(cancellationToken).ConfigureAwait(false))
{
Object value = asyncEnumerator.Current;
if (value != null && value.GetType().IsEnum)
{
value = value.ToString();
}
writer.WriteItem(value);
}
writer.WriteEnd();
}
}
public async Task MutateRows()
{
// Snippet: MutateRows(MutateRowsRequest,CallSettings)
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument
MutateRowsRequest request = new MutateRowsRequest
{
TableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]").ToString(),
Entries = { },
};
// Make the request, returning a streaming response
BigtableClient.MutateRowsStream streamingResponse = bigtableClient.MutateRows(request);
// Read streaming responses from server until complete
IAsyncEnumerator <MutateRowsResponse> responseStream = streamingResponse.ResponseStream;
while (await responseStream.MoveNext())
{
MutateRowsResponse response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
public static async Tasks.Task Apply <T>(this IAsyncEnumerator <T> me, Action <T> function)
{
while (await me.MoveNext())
{
function(me.Current);
}
}
protected override async Task <bool> MoveNextCore(CancellationToken cancellationToken)
{
switch (state)
{
case AsyncIteratorState.Allocated:
enumerator = source.GetEnumerator();
queue = new Queue <TSource>();
state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
while (await enumerator.MoveNext(cancellationToken)
.ConfigureAwait(false))
{
var item = enumerator.Current;
queue.Enqueue(item);
if (queue.Count > count)
{
current = queue.Dequeue();
return(true);
}
}
break;
}
Dispose();
return(false);
}
protected override async Task <bool> MoveNextCore(CancellationToken cancellationToken)
{
switch (state)
{
case AsyncIteratorState.Allocated:
enumerator = source.GetEnumerator();
state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
if (currentCount > 0 && await enumerator.MoveNext(cancellationToken)
.ConfigureAwait(false))
{
current = enumerator.Current;
currentCount--;
return(true);
}
break;
}
Dispose();
return(false);
}
public async Task <bool> MoveNext()
{
if (_state == 0)
{
if (await _enumerator.MoveNext())
{
Current = _enumerator.Current;
return(true);
}
else
{
_state = 1;
}
}
if (_state == 1)
{
_state = 2;
Current = await _element;
return(true);
}
return(false);
}
public async Task QueryAsyncEnumeratorSmallBatch()
{
ForceClient client = await forceClientFixture.GetForceClient();
var contactsEnumerable = client.QueryAsync <SfContact>("SELECT Id FROM Contact LIMIT 1000", batchSize: 200);
int count = 0;
SfContact contact = null;
using (IAsyncEnumerator <SfContact> contactsEnumerator = contactsEnumerable.GetEnumerator())
{
// Assert.NotNull(contactsEnumerator);
while (await contactsEnumerator.MoveNext())
{
contact = contactsEnumerator.Current;
count++;
#if DEBUG
if (count % 200 == 0)
{
Console.WriteLine("QueryAsyncEnumeratorSmallBatch: processed {0} records", count.ToString());
}
#endif
}
}
// recordcount needs be greater than 200 to ensure that more than one batch was retrieved
// and that the async retrieval occurred.
Assert.True(count > 200);
Assert.NotNull(contact.Id);
}
private async Task SerializeAsync(ODataWriter writer)
{
var resourceSet = new ODataResourceSet()
{
Count = Count
};
writer.WriteStart(resourceSet);
int count = 0;
T entity = default;
EntityPropertiesInfo entityPropertiesInfo = default;
while (await _entities.MoveNext())
{
entity = _entities.Current;
_stack.Add(entity);
WriteEntry(writer, entity, ref entityPropertiesInfo);
_stack.Remove(entity);
count++;
}
if (PageSize > 0 && count > 0 && (Count ?? Int32.MaxValue) > count)
{
resourceSet.NextPageLink = BuildNextPageLink(OeSkipTokenParser.GetSkipToken(_edmModel, GetKeys(entity)));
}
writer.WriteEnd();
}
public static async Task <IReadOnlyCollection <Blob> > ToBlobsAsync(PagedAsyncEnumerable <Objects, Object> pae, ListOptions options)
{
var result = new List <Blob>();
using (IAsyncEnumerator <Object> enumerator = pae.GetEnumerator())
{
while (await enumerator.MoveNext().ConfigureAwait(false))
{
Object go = enumerator.Current;
Blob blob = ToBlob(go);
if (options.FilePrefix != null && !blob.Name.StartsWith(options.FilePrefix))
{
continue;
}
if (options.BrowseFilter != null && !options.BrowseFilter(blob))
{
continue;
}
result.Add(blob);
if (options.MaxResults != null && result.Count >= options.MaxResults.Value)
{
break;
}
}
}
return(result);
}
public async Task BatchGetDocuments()
{
// Snippet: BatchGetDocuments(BatchGetDocumentsRequest,CallSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize request argument
BatchGetDocumentsRequest request = new BatchGetDocumentsRequest
{
Database = new DatabaseRootName("[PROJECT]", "[DATABASE]").ToString(),
Documents = { },
};
// Make the request, returning a streaming response
FirestoreClient.BatchGetDocumentsStream streamingResponse = firestoreClient.BatchGetDocuments(request);
// Read streaming responses from server until complete
IAsyncEnumerator <BatchGetDocumentsResponse> responseStream = streamingResponse.ResponseStream;
while (await responseStream.MoveNext())
{
BatchGetDocumentsResponse response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for StreamingRead</summary>
public async Task StreamingRead()
{
// Snippet: StreamingRead(ReadRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument
ReadRequest request = new ReadRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Table = "",
Columns = { },
KeySet = new KeySet(),
};
// Make the request, returning a streaming response
SpannerClient.StreamingReadStream streamingResponse = spannerClient.StreamingRead(request);
// Read streaming responses from server until complete
IAsyncEnumerator <PartialResultSet> responseStream = streamingResponse.ResponseStream;
while (await responseStream.MoveNext())
{
PartialResultSet response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
protected override async Task <bool> MoveNextCore(CancellationToken cancellationToken)
{
switch (state)
{
case AsyncIteratorState.Allocated:
enumerator = source.GetEnumerator();
state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
while (await enumerator.MoveNext(cancellationToken)
.ConfigureAwait(false))
{
var item = enumerator.Current;
var comparerEquals = false;
if (hasCurrentValue)
{
comparerEquals = comparer.Equals(currentValue, item);
}
if (!hasCurrentValue || !comparerEquals)
{
hasCurrentValue = true;
currentValue = item;
current = item;
return(true);
}
}
break;
}
Dispose();
return(false);
}
private async Task SerializeAsync(ODataWriter writer, OeMetadataLevel metadataLevel)
{
ClrPropertiesInfo clrPropertiesInfo = GetClrPropertiesInfo(_edmModel, _odataUri.SelectAndExpand, metadataLevel, typeof(T), null);
var resourceSet = new ODataResourceSet()
{
Count = Count
};
writer.WriteStart(resourceSet);
int count = 0;
T entity = default;
while (await _entities.MoveNext())
{
entity = _entities.Current;
_stack.Add(entity);
WriteEntry(writer, entity, clrPropertiesInfo);
_stack.Remove(entity);
count++;
}
if (PageSize > 0 && count > 0 && (Count ?? Int32.MaxValue) > count)
{
resourceSet.NextPageLink = BuildNextPageLink(OeSkipTokenParser.GetSkipToken(_edmModel, GetKeys(entity)));
}
writer.WriteEnd();
}
protected override async Task <bool> MoveNextCore(CancellationToken cancellationToken)
{
switch (state)
{
case AsyncIteratorState.Allocated:
enumerator = source.GetEnumerator();
index = -1;
state = AsyncIteratorState.Iterating;
goto case AsyncIteratorState.Iterating;
case AsyncIteratorState.Iterating:
while (await enumerator.MoveNext(cancellationToken)
.ConfigureAwait(false))
{
checked
{
index++;
}
var item = enumerator.Current;
if (predicate(item, index))
{
current = item;
return(true);
}
}
Dispose();
break;
}
return(false);
}
/// <summary>Snippet for MutateRows</summary>
public async Task MutateRows2_ResourceNames()
{
// Snippet: MutateRows(TableName, IEnumerable<MutateRowsRequest.Types.Entry>, string, CallSettings)
// Create client
BigtableServiceApiClient bigtableServiceApiClient = BigtableServiceApiClient.Create();
// Initialize request argument(s)
TableName tableName = new TableName("[PROJECT]", "[INSTANCE]", "[TABLE]");
IEnumerable <MutateRowsRequest.Types.Entry> entries = new MutateRowsRequest.Types.Entry[]
{
new MutateRowsRequest.Types.Entry(),
};
string appProfileId = "";
// Make the request, returning a streaming response
BigtableServiceApiClient.MutateRowsStream response = bigtableServiceApiClient.MutateRows(tableName, entries, appProfileId);
// Read streaming responses from server until complete
IAsyncEnumerator <MutateRowsResponse> responseStream = response.ResponseStream;
while (await responseStream.MoveNext())
{
MutateRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
