public ValueTask DisposeAsync()
{
_enumerator?.DisposeAsync();
_enumerator = null;
return default;
}
public IAsyncEnumerator <TResult> GetAsyncEnumerator(CancellationToken ct, AsyncIterationHint mode)
{
ct.ThrowIfCancellationRequested();
IAsyncEnumerator <TSource>?inner = null;
try
{
inner = this.Source is IConfigurableAsyncEnumerable <TSource> configurable?configurable.GetAsyncEnumerator(ct, mode) : this.Source.GetAsyncEnumerator(ct);
Contract.Debug.Requires(inner != null, "The underlying async sequence returned an empty enumerator");
var outer = this.Factory(inner);
if (outer == null)
{
throw new InvalidOperationException("The async factory returned en empty enumerator");
}
return(outer);
}
catch (Exception)
{
//make sure that the inner iterator gets disposed if something went wrong
//BUGBUG: we have to block on the async disposable :(
inner?.DisposeAsync().GetAwaiter().GetResult();
throw;
}
}
/// <summary>
/// Ensure that both <paramref name="enumerator"/> and <paramref name="otherEnumerator"/> are disposed
/// correctly and if an exception is thrown and <paramref name="outerException"/> is not null, throw an <see cref="AggregateException"/>
/// that aggregate both the exception thrown by the enumerator/s and the exception containted in <paramref name="outerException"/>
/// </summary>
/// <param name="enumerator"></param>
/// <param name="outerException"></param>
/// <param name="otherEnumerator"></param>
/// <returns></returns>
/// <throw ><see cref="AggregateException"/></throw>
public static async Task DisposeAsync(this IAsyncEnumerator enumerator, Exception outerException, IAsyncEnumerator otherEnumerator)
{
try
{
await Task.WhenAll(enumerator.DisposeAsync(), otherEnumerator.DisposeAsync());
}
catch (Exception ex)
{
if (outerException != null)
throw new AggregateException(outerException, ex);
throw;
}
}
/// <summary>
/// Enumerates over all elements in the collection asynchronously
/// </summary>
/// <param name="enumerator">The collection of elements which can be enumerated asynchronously</param>
/// <param name="action">A synchronous action to perform for every single item in the collection</param>
/// <returns>Returns a Task which does enumeration over elements in the collection</returns>
public static async Task ForEachAsync(this IAsyncEnumerator enumerator, Action <object> action)
{
try
{
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
action(enumerator.Current);
}
}
catch (ForEachAsyncBreakException)
{
}
finally
{
await enumerator.DisposeAsync().ConfigureAwait(false);
}
}
public override async ValueTask DisposeAsync()
{
if (_enumerator != null)
{
await _enumerator.DisposeAsync().ConfigureAwait(false);
_enumerator = null;
}
if (_resource != null)
{
_resource.Dispose();
_resource = default;
}
await base.DisposeAsync().ConfigureAwait(false);
}
private static async Task ForEachCore <T>(
this IAsyncEnumerator <T> enumerator,
Func <AsyncLoopContext <T>, Task> enumerationAction
)
{
if (enumerationAction == null)
{
throw new ArgumentNullException("enumerationAction");
}
var index = 0L;
var loopState = new AsyncLoopContext <T>();
ExceptionDispatchInfo edi = null;
try
{
while (await enumerator.MoveNext().ConfigureAwait(false))
{
loopState.Item = enumerator.Current;
loopState.Index = index;
try
{
await enumerationAction(loopState).ConfigureAwait(false);
}
catch (Exception e)
{
edi = ExceptionDispatchInfo.Capture(e);
break;
}
if (loopState.WasBreakCalled)
{
break;
}
index++;
}
}
finally
{
await enumerator.DisposeAsync(edi?.SourceException);
}
edi?.Throw();
}
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Global
public static async ValueTask AssertResult <T>(this IAsyncEnumerator <T> source, params T[] values)
{
var main = default(Exception);
var dispose = default(Exception);
var idx = 0;
try
{
while (await source.MoveNextAsync())
{
Assert.True(idx < values.Length, "Source has more than the expected " + values.Length + " items");
Assert.Equal(values[idx], source.Current);
idx++;
}
Assert.True(values.Length == idx, "Source has less items than expected: " + values.Length + ", actual: " + idx);
}
catch (Exception ex)
{
main = ex;
}
finally
{
try
{
await source.DisposeAsync();
}
catch (Exception ex)
{
dispose = ex;
}
}
if (main != null && dispose != null)
{
throw new AggregateException(main, dispose);
}
if (main != null)
{
throw main;
}
if (dispose != null)
{
throw dispose;
}
}
public override async ValueTask DisposeAsync()
{
if (_resultEnumerator != null)
{
await _resultEnumerator.DisposeAsync().ConfigureAwait(false);
_resultEnumerator = null;
}
if (_sourceEnumerator != null)
{
await _sourceEnumerator.DisposeAsync().ConfigureAwait(false);
_sourceEnumerator = null;
}
await base.DisposeAsync().ConfigureAwait(false);
}
public async Task Dispose_CompletedEventIsRaised()
{
// arrange
using var cts = new CancellationTokenSource(30000);
var sent = new EventMessage("foo", "bar");
var eventStream = new InMemoryEventStream();
IAsyncEnumerator <IEventMessage> enumerator = eventStream.GetAsyncEnumerator(cts.Token);
bool eventRaised = false;
eventStream.Completed += (s, e) => eventRaised = true;
// act
await enumerator.DisposeAsync();
// assert
Assert.True(eventRaised);
Assert.False(await enumerator.MoveNextAsync());
}
public override async ValueTask DisposeAsync()
{
if (_loserTask != null)
{
await _loserTask.ConfigureAwait(false);
_loserTask = null;
_enumerator = null;
}
else if (_enumerator != null)
{
await _enumerator.DisposeAsync().ConfigureAwait(false);
_enumerator = null;
}
await base.DisposeAsync().ConfigureAwait(false);
}
protected override async ValueTask Cleanup()
{
try
{
if (m_chunkIterator != null)
{
await m_chunkIterator.DisposeAsync();
}
}
finally
{
m_chunkIterator = null;
m_chunk = null;
m_outOfChunks = true;
m_currentOffsetInChunk = 0;
m_itemsRemainingInChunk = 0;
}
}
public ODataResult <T> OData <T>(IAsyncEnumerable <T> asyncEnumerable)
{
IAsyncEnumerator <T> asyncEnumerator = asyncEnumerable.GetAsyncEnumerator();
_httpContext.Response.OnCompleted(() => asyncEnumerator.DisposeAsync().AsTask());
if (_odataUri != null && (OeExpressionHelper.IsPrimitiveType(typeof(T)) || _odataUri.Path.LastSegment is CountSegment))
{
return(new ODataPrimitiveResult <T>(_edmModel, _odataUri, asyncEnumerator));
}
if (_queryContext == null)
{
throw new InvalidOperationException("Must invoke OeAspQueryParser.ExecuteReader");
}
return(new ODataResult <T>(_queryContext, asyncEnumerator));
}
public async Task DeleteArchivedBlobsAsync(BlobServiceClient blobServiceClient, string blobContainerName, string blobNameFormat, int retainedBlobCountLimit)
{
if (retainedBlobCountLimit < 1)
{
throw new ArgumentException("Invalid value provided; retained blob count limit must be at least 1 or null.");
}
BlobContainerClient blobContainer = blobServiceClient.GetBlobContainerClient(blobContainerName);
List <BlobItem> logBlobs = new List <BlobItem>();
AsyncPageable <BlobItem> blobItems = blobContainer.GetBlobsAsync();
IAsyncEnumerator <BlobItem> enumerator = blobItems.GetAsyncEnumerator();
try
{
while (await enumerator.MoveNextAsync())
{
logBlobs.Add(enumerator.Current);
}
}
finally
{
await enumerator.DisposeAsync();
}
IEnumerable <BlobItem> validLogBlobs = logBlobs.Where(blobItem => DateTime.TryParseExact(
RemoveRolledBlobNameSerialNum(blobItem.Name),
blobNameFormat,
CultureInfo.InvariantCulture,
DateTimeStyles.AssumeLocal,
out var _date));
IEnumerable <BlobItem> blobsToDelete = validLogBlobs
.OrderByDescending(blobItem => blobItem.Name)
.Skip(retainedBlobCountLimit);
foreach (var blobItem in blobsToDelete)
{
AppendBlobClient blobToDelete = blobContainer.GetAppendBlobClient(blobItem.Name);
await blobToDelete.DeleteIfExistsAsync();
}
}
public async Task <List <string> > ListQueuesAsync()
{
var result = new List <string>();
var allQueues = queueServiceClient.GetQueuesAsync();
IAsyncEnumerator <QueueItem> enumerator = allQueues.GetAsyncEnumerator();
try
{
while (await enumerator.MoveNextAsync())
{
result.Add(enumerator.Current.Name);
}
}
finally
{
await enumerator.DisposeAsync();
}
return(result);
}
internal static IAsyncEnumerator <T> GetEnumerator(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(sequence.Transaction.Cancellation));
}
//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
{
#warning Fix async begin transaction!
trans = sequence.Database !.BeginTransactionAsync(ct).GetAwaiter().GetResult(); //HACKHACK: BUGBUG: async!
var source = generator(trans);
Contract.Assert(source != null);
iterator = source is IConfigurableAsyncEnumerable <T> configurable?configurable.GetAsyncEnumerator(ct, mode) : source.GetAsyncEnumerator(ct);
return(new TransactionIterator(trans, iterator));
}
catch (Exception)
{
success = false;
throw;
}
finally
{
if (!success)
{
//BUGBUG: we have to block on the async disposable :(
iterator?.DisposeAsync().GetAwaiter().GetResult();
trans?.Dispose();
}
}
}
public void WillDisposeInternalEnumeratorAndEnumerableWhenDisposed()
{
MockRepository mocks = new MockRepository();
IAsyncEnumerable <Row> enumerable = mocks.DynamicMultiMock <IAsyncEnumerable <Row> >(typeof(IAsyncDisposable));
IAsyncEnumerator <Row> enumerator = mocks.DynamicMock <IAsyncEnumerator <Row> >();
using (mocks.Record())
{
SetupResult.For(enumerable.GetAsyncEnumerator(Arg <CancellationToken> .Is.Anything)).Return(enumerator);
SetupResult.For(enumerator.DisposeAsync()).Return(new ValueTask());
SetupResult.For(((IAsyncDisposable)enumerable).DisposeAsync()).Return(new ValueTask());
}
using (mocks.Playback())
{
DictionaryEnumeratorDataReader reader =
new DictionaryEnumeratorDataReader(new Dictionary <string, Type>(), enumerable);
reader.Dispose();
}
}
public static IEnumerable <T> ToBlockingEnumerable <T>(this IAsyncEnumerable <T> source, CancellationToken cancellationToken = default)
{
IAsyncEnumerator <T> enumerator = source.GetAsyncEnumerator(cancellationToken);
// A ManualResetEventSlim variant that lets us reuse the same
// awaiter callback allocation across the entire enumeration.
ManualResetEventWithAwaiterSupport?mres = null;
try
{
while (true)
{
#pragma warning disable CA2012 // Use ValueTasks correctly
ValueTask <bool> moveNextTask = enumerator.MoveNextAsync();
#pragma warning restore CA2012 // Use ValueTasks correctly
if (!moveNextTask.IsCompleted)
{
(mres ??= new()).Wait(moveNextTask.ConfigureAwait(false).GetAwaiter());
Debug.Assert(moveNextTask.IsCompleted);
}
if (!moveNextTask.Result)
{
yield break;
}
yield return(enumerator.Current);
}
}
finally
{
ValueTask disposeTask = enumerator.DisposeAsync();
if (!disposeTask.IsCompleted)
{
(mres ?? new()).Wait(disposeTask.ConfigureAwait(false).GetAwaiter());
Debug.Assert(disposeTask.IsCompleted);
}
disposeTask.GetAwaiter().GetResult();
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "getproducts-async/{cost}")]
HttpRequest req,
[Sql("select * from Products where cost = @Cost",
CommandType = System.Data.CommandType.Text,
Parameters = "@Cost={cost}",
ConnectionStringSetting = "SqlConnectionString")]
IAsyncEnumerable <Product> products)
{
IAsyncEnumerator <Product> enumerator = products.GetAsyncEnumerator();
var productList = new List <Product>();
while (await enumerator.MoveNextAsync())
{
productList.Add(enumerator.Current);
}
await enumerator.DisposeAsync();
return((ActionResult) new OkObjectResult(productList));
}
private static async Task Demo2Async()
{
var aDevice = new ADevice();
IAsyncEnumerable <SensorData> en = aDevice.GetSensorData1();
IAsyncEnumerator <SensorData> enumerator = en.GetAsyncEnumerator();
try
{
while (await enumerator.MoveNextAsync())
{
var sensorData = enumerator.Current;
Console.WriteLine($"{sensorData.Value1} {sensorData.Value2}");
}
}
finally
{
await enumerator.DisposeAsync();
}
}
static async IAsyncEnumerable <string> Demo2Async()
{
var aDevice = new Advice();
IAsyncEnumerable <Event> en = aDevice.GetSensorData1();
IAsyncEnumerator <Event> enumerator = en.GetAsyncEnumerator();
try
{
while (await enumerator.MoveNextAsync())
{
var sendorData = enumerator.Current;
yield return($"Demo2 {sendorData.Score1} {sendorData.Score2}");
}
}
finally
{
await enumerator.DisposeAsync();
}
}
public async static Task <IEnumerable <T> > AsyncToList <T>(IAsyncEnumerator <T> e)
{
IList <T> result = new List <T>();
try
{
while (await e.MoveNextAsync())
{
result.Add(e.Current);
}
}
finally
{
if (e != null)
{
await e.DisposeAsync();
}
}
return(result);
}
/// <summary>
/// Enumerates over all elements in the collection asynchronously
/// </summary>
/// <typeparam name="T">The type of elements in the collection</typeparam>
/// <param name="enumerator">The collection of elements which can be enumerated asynchronously</param>
/// <param name="action">A synchronous action to perform for every single item in the collection, where the second argument is the index of an item</param>
/// <returns>Returns a Task which does enumeration over elements in the collection</returns>
public static async Task ForEachAsync <T>(this IAsyncEnumerator <T> enumerator, Action <T, long> action)
{
try
{
long index = 0;
while (await enumerator.MoveNextAsync().ConfigureAwait(false))
{
action(enumerator.Current, index);
index++;
}
}
catch (ForEachAsyncBreakException)
{
}
finally
{
await enumerator.DisposeAsync().ConfigureAwait(false);
}
}
public void ReceiveAllAsync_MultipleSingleElementEnumerations_AllItemsEnumerated(bool sameEnumerable, bool dispose)
{
var source = new BufferBlock <int>();
IAsyncEnumerable <int> enumerable = source.ReceiveAllAsync();
for (int i = 0; i < 10; i++)
{
Assert.True(source.Post(i));
IAsyncEnumerator <int> e = (sameEnumerable ? enumerable : source.ReceiveAllAsync()).GetAsyncEnumerator();
ValueTask <bool> vt = e.MoveNextAsync();
Assert.True(vt.IsCompletedSuccessfully);
Assert.True(vt.Result);
Assert.Equal(i, e.Current);
if (dispose)
{
ValueTask dvt = e.DisposeAsync();
Assert.True(dvt.IsCompletedSuccessfully);
dvt.GetAwaiter().GetResult();
}
}
}
public void ReadAllAsync_MultipleSingleElementEnumerations_AllItemsEnumerated(bool sameEnumerable, bool dispose)
{
Channel <int> c = CreateChannel();
IAsyncEnumerable <int> enumerable = c.Reader.ReadAllAsync();
for (int i = 0; i < 10; i++)
{
Assert.True(c.Writer.TryWrite(i));
IAsyncEnumerator <int> e = (sameEnumerable ? enumerable : c.Reader.ReadAllAsync()).GetAsyncEnumerator();
ValueTask <bool> vt = e.MoveNextAsync();
Assert.True(vt.IsCompletedSuccessfully);
Assert.True(vt.Result);
Assert.Equal(i, e.Current);
if (dispose)
{
ValueTask dvt = e.DisposeAsync();
Assert.True(dvt.IsCompletedSuccessfully);
dvt.GetAwaiter().GetResult();
}
}
}
async Task TryPollOn(IAsyncEnumerator <int> en)
{
try
{
var f = en as IAsyncFusedEnumerator <int>;
for (; ;)
{
var v = f.TryPoll(out var state);
if (state != AsyncFusedState.Ready)
{
break;
}
Volatile.Write(ref field, v);
}
}
finally
{
await en.DisposeAsync();
}
}
internal async Task <int> ConsumeStream()
{
IAsyncEnumerator <int> asyncEnumerator = GenerateSequence().GetAsyncEnumerator();
try
{
while (await asyncEnumerator.MoveNextAsync())
{
int number = asyncEnumerator.Current;
Console.WriteLine($"The time is {DateTime.Now:hh:mm:sssss}. Retrieved {number}");
}
}
finally
{
if (asyncEnumerator != null)
{
await asyncEnumerator.DisposeAsync();
}
}
return(0);
}
/// <summary>List files</summary>
/// <param name="directoryName">The directory of interest or null if you want the root directory</param>
/// <param name="returnDirectoriesAndFiles">If true, you will get both directories and file. If false, you will get only files.</param>
/// <param name="cancellationToken"></param>
/// <param name="options"></param>
/// <returns></returns>
public async Task <List <ShareFileItem> > ListFilesAsync(string directoryName,
bool returnDirectoriesAndFiles, CancellationToken cancellationToken = default,
ShareDirectoryGetFilesAndDirectoriesOptions options = null)
{
var result = new List <ShareFileItem>();
ShareDirectoryClient directory = string.IsNullOrWhiteSpace(directoryName) ?
_share.GetRootDirectoryClient() :
_share.GetDirectoryClient(directoryName);
// For >= C# 8.0 use:
//await foreach (ShareFileItem fileItem in directory.GetFilesAndDirectoriesAsync(options, cancellationToken))
//{
// result.Add(fileItem);
//}
// For < C# 8.0 use:
AsyncPageable <ShareFileItem> filePages = directory.GetFilesAndDirectoriesAsync(options, cancellationToken);
IAsyncEnumerator <ShareFileItem> enumerator = filePages.GetAsyncEnumerator();
try
{
while (await enumerator.MoveNextAsync())
{
if (returnDirectoriesAndFiles == false && enumerator.Current.IsDirectory)
{
continue;
}
result.Add(enumerator.Current);
}
}
finally
{
await enumerator.DisposeAsync();
}
return(result);
}
public static async Task ForEachAsync <T>(this IAsyncEnumerable <T> source, Func <T, CancellationToken, Task> body, CancellationToken cancellationToken = default(CancellationToken))
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
cancellationToken.ThrowIfCancellationRequested();
IAsyncEnumerator <T> e = source.GetAsyncEnumerator();
try
{
while (await e.WaitForNextAsync().ConfigureAwait(false))
{
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
T item = e.TryGetNext(out bool success);
if (!success)
{
break;
}
await body(item, cancellationToken).ConfigureAwait(false);
}
}
}
finally
{
await e.DisposeAsync().ConfigureAwait(false);
}
}
public async Task <IActionResult> ProductSearch(string name)
{
if (name != string.Empty && name != null)
{
var productServiceClient = new ProductServiceClient();
IAsyncEnumerator <ProductModel> products = productServiceClient.SearchProduct(name);
var productList = new List <ProductModel>();
while (await products.MoveNextAsync())
{
productList.Add(products.Current);
}
await products.DisposeAsync();
ViewData["ProductSearchName"] = name;
return(View(productList));
}
return(RedirectToAction("Index"));
}
private async ValueTask DisposeAsync(bool dispose)
{
if (disposed)
{
return;
}
try
{
if (dispose)
{
if (null != enumerator)
{
await enumerator.DisposeAsync();
}
}
}
finally
{
disposed = true;
}
}
public async ValueTask <(bool success, TItem item, TState state, bool last)> TryDequeue()
{
if (disposedValue)
{
throw new ObjectDisposedException(nameof(StreamQueue <TItem, TState>));
}
if (currentEnumerator != null)
{
return(await DequeueCached());
}
else if (queue.TryDequeue(out QueueItem queueItem))
{
if (queueItem.Items == null)
{
return(true, queueItem.Item, queueItem.State, true);
}
else
{
IAsyncEnumerator <TItem> enumerator = queueItem.Items.GetAsyncEnumerator();
bool next = await enumerator.MoveNextAsync().ConfigureAwait(false);
if (!next)
{
await enumerator.DisposeAsync().ConfigureAwait(false);
return(await TryDequeue().ConfigureAwait(false));
}
else
{
currentEnumerator = enumerator;
currentState = queueItem.State;
return(await DequeueCached().ConfigureAwait(false));
}
}
}
else
{
return(default);
