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 }