internal EnumeratorBlockingAsync(YieldCallbackAsync <TDelegate> yieldAsync)
{
var cancelYieldAsyncToken = cancelYieldAsyncTokenSource.Token;
yieldAsyncTask = Task.Run(async() =>
{
try
{
// TODO: Get cancellation token on this thread as well.
await yieldAsync.SandwichInvoke(
() =>
{
callbackBarrier.SignalAndWait();
return(this.totalCallback);
},
(updatedCallbackTask) =>
{
callbackTask = updatedCallbackTask;
callbackBarrier.SignalAndWait();
return(Task.FromResult(true));
});
} catch (Exception ex)
{
exception = ex;
throw ex;
} finally
{
complete = true;
callbackBarrier.RemoveParticipant();
}
}, cancelYieldAsyncToken);
}
public EnumeratorNonAsync(YieldCallbackAsync <TDelegateItems> yieldAsync,
TDelegateConvert resultCallback)
{
yieldAsyncTask = Task.Run(async() =>
{
try
{
await yieldAsync.ResultSwapInvoke <TResult, TDelegateItems, TDelegateConvert>(
() =>
{
callbackBarrier.SignalAndWait();
return(resultCallback);
},
(updatedCallbackTask) =>
{
this.Current = updatedCallbackTask;
callbackBarrier.SignalAndWait();
return(Task.FromResult(true));
});
}
catch (Exception ex)
{
exception = ex;
throw ex;
}
finally
{
complete = true;
callbackBarrier.RemoveParticipant();
}
});
}
public static async Task SandwichInvoke <TDelegate>(this YieldCallbackAsync <TDelegate> yieldAsync,
SandwichPreDelegate <TDelegate> preCallback, SandwichPostDelegate postCallback)
{
var sandwichDelegate = GetSandwichDelegate <TDelegate>();
await sandwichDelegate.Invoke(
preCallback,
yieldAsync,
postCallback);
}
public static async Task ResultSwapInvoke <TResult, TDelegateItems, TDelegateConvert>(
this YieldCallbackAsync <TDelegateItems> yieldAsync,
ResultSwapPreDelegate <TDelegateConvert> preCallback,
ResultSwapPostDelegate <TResult> postCallback)
{
var resultSwapDelegate = GetResultSwapDelegate <TResult, TDelegateItems, TDelegateConvert>();
await resultSwapDelegate.Invoke(
preCallback,
yieldAsync,
postCallback);
}
public static IEnumerableAsync <T> TakeAsync <T>(this IEnumerableAsync <T> items, int limit)
{
YieldCallbackAsync <T> yieldAsync = async yield =>
{
using (var enumerator = items.GetEnumerator())
{
while (limit > 0 && await enumerator.MoveNextAsync(yield))
{
limit--;
}
}
};
return(new EnumerableAsync <T>(yieldAsync));
}
public EnumeratorAsyncTest(YieldCallbackAsync <TestDelegateAsync> yieldAsync)
{
yieldAsyncTask = Task.Run(async() =>
{
var xm = Generators.GetSandwichDelegate();
await xm.Invoke(
() =>
{
callbackBarrier.SignalAndWait();
return(this.totalCallback);
},
yieldAsync,
(updatedCallbackTask) =>
{
callbackTask = updatedCallbackTask;
callbackBarrier.SignalAndWait();
return(Task.FromResult(true));
});
callbackBarrier.RemoveParticipant();
});
}
public IteratorAsyncTest(YieldCallbackAsync <TestDelegateAsync> yieldAsync,
TestDelegateResult <int> resultCallback)
{
yieldAsyncTask = Task.Run(async() =>
{
var xm = EmptyClass2.GetResultSwapDelegate();
await xm.Invoke(
() =>
{
callbackBarrier.SignalAndWait();
return(resultCallback);
},
yieldAsync,
(updatedCallbackTask) =>
{
this.Current = updatedCallbackTask;
callbackBarrier.SignalAndWait();
return(Task.FromResult(true));
});
complete = true;
callbackBarrier.RemoveParticipant();
});
}
internal IteratorSimpleAsync(YieldCallbackAsync <TDelegate> yieldAsync)
{
this.yieldAsync = yieldAsync;
}
public static IEnumerableAsync <TDelegate> YieldAsync <TDelegate>(YieldCallbackAsync <TDelegate> yieldAsync)
{
return(new EnumerableAsync <TDelegate>(yieldAsync));
}
internal IteratorAsyncTest(YieldCallbackAsync <TDelegate> yieldAsync)
{
this.yieldAsync = yieldAsync;
}
public EnumerableTest(YieldCallbackAsync <TestDelegateAsync> yieldAsync, TestDelegateResult <int> convertDelegate)
{
this.yieldAsync = yieldAsync;
this.convertDelegate = convertDelegate;
}
public EnumerableNonAsync(YieldCallbackAsync <TDelegateItems> yieldAsync, TDelegateConvert convertDelegate)
{
this.yieldAsync = yieldAsync;
this.convertDelegate = convertDelegate;
}
public EnumerableAsyncTest(YieldCallbackAsync <TestDelegateAsync> yieldAsync)
{
this.yieldAsync = yieldAsync;
}
public static IEnumerableAsync <TestDelegateAsync> YieldAsync(YieldCallbackAsync <TestDelegateAsync> yieldAsync)
{
return(new EnumerableAsyncTest(yieldAsync));
}
