/// <summary>
/// Starts a task that waits for the next rendering from Chrome.
/// Chrome also renders the page loading, so if you want to see a complete rendering,
/// only start this task once your page is loaded (which you can detect via FrameLoadEnd
/// or your own heuristics based on evaluating JavaScript).
/// It is your responsibility to dispose the returned Bitmap.
/// The bitmap size is determined by the Size property set earlier.
/// </summary>
/// <param name="ignoreExistingScreenshot">Ignore existing bitmap (if any) and return the next avaliable bitmap</param>
/// /// <param name="blend">Choose which bitmap to retrieve, choose <see cref="PopupBlending.Blend"/> for a merged bitmap.</param>
/// <returns>Task<Bitmap>.</returns>
public Task <Bitmap> ScreenshotAsync(bool ignoreExistingScreenshot = false, PopupBlending blend = PopupBlending.Main)
{
// Try our luck and see if there is already a screenshot, to save us creating a new thread for nothing.
var screenshot = ScreenshotOrNull(blend);
var completionSource = new AsyncTaskCompletionSource <Bitmap>();
if (screenshot == null || ignoreExistingScreenshot)
{
EventHandler <OnPaintEventArgs> paint = null; // otherwise we cannot reference ourselves in the anonymous method below
paint = (sender, e) =>
{
// Chromium has rendered. Tell the task about it.
Paint -= paint;
completionSource.TrySetResultAsync(ScreenshotOrNull());
};
Paint += paint;
}
else
{
completionSource.TrySetResultAsync(screenshot);
}
return(completionSource.Task);
}
protected override void Dispose(bool explicitDispose)
{
_nextSignalAwaitable = null;
_signalState = null;
//
base.Dispose(explicitDispose);
}
public Task WaitAsync(TimeSpan timeOut, CancellationToken token)
{
var tcs = new AsyncTaskCompletionSource();
_tcs.Task.ContinueWith(t => tcs.TrySetResult());
return(tcs.WaitWithTimeoutAndCancelAsync(timeOut, token));
}
public void WhenLauncherHasQueuedDelegate_ItShouldCompleted()
{
var sut = new SingleRunningDelegateLauncher();
var tcs = new AsyncTaskCompletionSource();
sut.Launch(ct => { tcs.SetResult(); }, t => { });
ConcurrentAssert.EnsureThatTaskIsCompleted(tcs.Task);
}
public AsyncBarrier(int clientsCount)
{
if (clientsCount <= 0)
{
throw new ArgumentOutOfRangeException("clientsCount can not be less or equal to zero.");
}
_initialClientsCount = _clientsCount = clientsCount;
_tcs = new AsyncTaskCompletionSource();
}
protected RunControlOperationState(RunControl <TComponent> runControl, TimeSpan beginTimestamp, CancellationToken ct)
{
runControl.EnsureNotNull(nameof(runControl));
beginTimestamp.Arg(nameof(beginTimestamp)).EnsureNotLessThan(operand: TimeSpan.Zero);
//
RunControl = runControl;
BeginTimestamp = beginTimestamp;
Ct = ct;
_completionProxy = new AsyncTaskCompletionSource <IRunControlAttemptSuccess>(options: TaskCreationOptions.None);
_completionProxy.Task.ContinueWith(continuationAction: P_LogAttemptContinuation, continuationOptions: TaskContinuationOptions.ExecuteSynchronously);
}
public void WhenLauncherHasQueuedDelegate_TheOnFinishedActionShouldBeCalledIf()
{
var sut = new SingleRunningDelegateLauncher();
var tcs = new AsyncTaskCompletionSource();
Task task = null;
sut.Launch(ct => { }, t => { tcs.SetResult(); task = t; });
ConcurrentAssert.EnsureThatTaskIsCompleted(tcs.Task);
Assert.IsNotNull(task);
Assert.IsTrue(task.IsCompleted);
Assert.IsFalse(task.IsFaulted);
}
private AsyncTaskCompletionSource GetWaitingClientFromQueue()
{
AsyncTaskCompletionSource tcs = null;
while (_waitingClientsQueue.TryDequeue(out tcs))
{
if (!tcs.Task.IsCompleted)
{
return(tcs);
}
}
return(null);
}
public Task WaitAsync()
{
lock (_lockObj)
{
if (_availableCount > 0)
{
--_availableCount;
return(_completedTask);
}
var waiter = new AsyncTaskCompletionSource <Boolean>();
_waiters.Enqueue(waiter);
return(waiter.Task);
}
}
public void WhenLauncherHasQueuedDelegate_TheOnFinishedActionShouldBeCalledAfterDelegateHasFinished()
{
var sut = new SingleRunningDelegateLauncher();
var tcs = new AsyncTaskCompletionSource();
var tcs2 = new AsyncTaskCompletionSource();
Task task = null;
sut.Launch(ct => { tcs.Task.Wait(); }, t => { tcs2.SetResult(); task = t; });
ConcurrentAssert.EnsureThatTaskIsNeverCompleted(tcs2.Task);
tcs.SetResult();
ConcurrentAssert.EnsureThatTaskIsCompleted(tcs2.Task);
}
public Task WaitAsync(TimeSpan timeout, CancellationToken token)
{
lock (_lock)
{
_clientsCount++;
if (_clientsCount > _maxClientsCount)
{
var tcs = new AsyncTaskCompletionSource();
_waitingClientsQueue.Enqueue(tcs);
return(tcs.WaitWithTimeoutAndCancelAsync(timeout, token));
}
else
{
return(Task.CompletedTask);
}
}
}
public Task WaitAsync(CancellationToken cancellationToken)
{
lock (_lockObj)
{
if (_availableCount > 0)
{
--_availableCount;
return(_completedTask);
}
var waiter = new AsyncTaskCompletionSource <Boolean>();
_waiters.Enqueue(waiter);
cancellationToken.Register(
OnCancelled, waiter);
return(waiter.Task);
}
}
public Task WaitAsync(TimeSpan timeOut, CancellationToken token)
{
AsyncTaskCompletionSource tcs = null;
lock (_lock)
{
if (_isSignalState)
{
_isSignalState = false;
return(Task.CompletedTask);
}
else
{
tcs = new AsyncTaskCompletionSource();
_waitingClientsQueue.Enqueue(tcs);
return(tcs.WaitWithTimeoutAndCancelAsync(timeOut, token));
}
}
}
/// <summary>
/// Returns a task that will return the messages received on
/// <paramref
/// name="managedClient" />
/// when
/// <paramref
/// name="expectedNumberOfMessages" />
/// have been received
/// </summary>
Task <List <MqttApplicationMessage> > SetupReceivingOfMessages(ManagedMqttClient managedClient, int expectedNumberOfMessages)
{
var receivedMessages = new List <MqttApplicationMessage>();
var result = new AsyncTaskCompletionSource <List <MqttApplicationMessage> >();
managedClient.ApplicationMessageReceivedAsync += e =>
{
receivedMessages.Add(e.ApplicationMessage);
if (receivedMessages.Count == expectedNumberOfMessages)
{
result.TrySetResult(receivedMessages);
}
return(PlatformAbstractionLayer.CompletedTask);
};
return(result.Task);
}
public Task <TriggerSignalEventArgs> NextSignalAwaitable()
{
try {
var existingAwaitable = TryReadDA(ref _nextSignalAwaitable, considerDisposeRequest: true);
if (existingAwaitable is null)
{
if (HasDeactivationRequested)
{
return(TaskUtilities.FromCanceled <TriggerSignalEventArgs>());
}
else
{
AsyncTaskCompletionSource <TriggerSignalEventArgs> newAwaitable = default;
try {
try {
UpdDAIfNullBool(location: ref _nextSignalAwaitable, factory: () => newAwaitable = new AsyncTaskCompletionSource <TriggerSignalEventArgs>(), current: out existingAwaitable);
}
catch (ObjectDisposedException) {
if (IsDisposeRequested)
{
return(TaskUtilities.FromCanceled <TriggerSignalEventArgs>());
}
else
{
throw;
}
}
}
finally {
if (!ReferenceEquals(existingAwaitable, newAwaitable))
{
newAwaitable?.TrySetCanceled(ct: CancellationToken.None);
}
}
}
}
return(existingAwaitable.Task);
}
catch (Exception exception) {
return(TaskUtilities.FromError <TriggerSignalEventArgs>(error: exception));
}
}
public void Set()
{
AsyncTaskCompletionSource tcs = null;
lock (_lock)
{
if (!_isSignalState)
{
tcs = GetWaitingClientFromQueue();
if (tcs == null)
{
_isSignalState = true;
}
else
{
tcs.TrySetResult();
}
}
}
}
public Task <IDisposable> LockAsync(TimeSpan timeout, CancellationToken token)
{
var tcs = new AsyncTaskCompletionSource <IDisposable>();
_am.EnterAsync(timeout, token).ContinueWith(t =>
{
if (t.IsCanceled)
{
tcs.TrySetCanceled(token);
}
else if (t.IsFaulted)
{
tcs.TrySetException(t.Exception);
}
else
{
tcs.SetResult(new Disposable(_am));
}
});
return(tcs.Task);
}
public Task SignalAndWaitAsync(TimeSpan timeout, CancellationToken token)
{
var tcs = _tcs;
var count = Interlocked.Decrement(ref _clientsCount);
if (count < 0)
{
throw new InvalidOperationException("Can not signaled if counter is already less then zero.");
}
else if (count == 0)
{
_tcs = new AsyncTaskCompletionSource();
_clientsCount = _initialClientsCount;
tcs.SetResult();
return(tcs.Task);
}
else
{
var cancellableTcs = new AsyncTaskCompletionSource();
tcs.Task.ContinueWith(t => cancellableTcs.TrySetResult());
return(cancellableTcs.WaitWithTimeoutAndCancelAsync(timeout, token));
}
}
/// <summary>
/// Starts a task that waits for the next rendering from Chrome.
/// Chrome also renders the page loading, so if you want to see a complete rendering,
/// only start this task once your page is loaded (which you can detect via FrameLoadEnd
/// or your own heuristics based on evaluating JavaScript).
/// It is your responsibility to dispose the returned Bitmap.
/// The bitmap size is determined by the Size property set earlier.
/// </summary>
/// <param name="ignoreExistingScreenshot">Ignore existing bitmap (if any) and return the next available bitmap</param>
/// <param name="blend">Choose which bitmap to retrieve, choose <see cref="PopupBlending.Blend"/> for a merged bitmap.</param>
/// <returns>Task<Bitmap>.</returns>
public Task <Bitmap> ScreenshotAsync(bool ignoreExistingScreenshot = false, PopupBlending blend = PopupBlending.Main)
{
// Try our luck and see if there is already a screenshot, to save us creating a new thread for nothing.
var screenshot = ScreenshotOrNull(blend);
var completionSource = new AsyncTaskCompletionSource <Bitmap>();
if (screenshot == null || ignoreExistingScreenshot)
{
EventHandler <OnPaintEventArgs> afterPaint = null; // otherwise we cannot reference ourselves in the anonymous method below
afterPaint = (sender, e) =>
{
// Chromium has rendered. Tell the task about it.
AfterPaint -= afterPaint;
//If the user handled the Paint event then we'll throw an exception here
//as it's not possible to use ScreenShotAsync as the buffer wasn't updated.
if (e.Handled)
{
completionSource.TrySetException(new InvalidOperationException("OnPaintEventArgs.Handled = true, unable to process request. The buffer has not been updated"));
}
else
{
completionSource.TrySetResultAsync(ScreenshotOrNull(blend));
}
};
AfterPaint += afterPaint;
}
else
{
completionSource.TrySetResultAsync(screenshot);
}
return(completionSource.Task);
}
public Task <int> ReadAsync(byte[] buffer, int offset, int count, StreamMode mode)
{
System.Diagnostics.Debug.Assert(mConnectionOutputToEncoderInput == null);
System.Diagnostics.Debug.Assert(buffer != null);
System.Diagnostics.Debug.Assert(0 <= offset && offset < buffer.Length);
System.Diagnostics.Debug.Assert(0 < count && count <= buffer.Length - offset);
if (mEncoderOutputToConnectionInput != null)
{
return(mEncoderOutputToConnectionInput.ReadAsync(buffer, offset, count, mode));
}
lock (this)
{
// Multiple outstanding ReadAsync calls are not allowed.
if (mBuffer != null)
{
throw new InternalFailureException();
}
if (mComplete)
{
return(Task.FromResult(0));
}
mBuffer = buffer;
mOffset = offset;
mEnding = offset + count;
// CompletionSource must be async so we can complete it from within the lock.
// If we move the completion outside the lock we may be able to do inline completion?
mResult = AsyncTaskCompletionSource <int> .Create();
Monitor.PulseAll(this);
return(mResult.Task);
}
}
public Task<int> ReadAsync(byte[] buffer, int offset, int count, StreamMode mode)
{
System.Diagnostics.Debug.Assert(mConnectionOutputToEncoderInput == null);
System.Diagnostics.Debug.Assert(buffer != null);
System.Diagnostics.Debug.Assert(0 <= offset && offset < buffer.Length);
System.Diagnostics.Debug.Assert(0 < count && count <= buffer.Length - offset);
if (mEncoderOutputToConnectionInput != null)
return mEncoderOutputToConnectionInput.ReadAsync(buffer, offset, count, mode);
lock (this)
{
// Multiple outstanding ReadAsync calls are not allowed.
if (mBuffer != null)
throw new InternalFailureException();
if (mComplete)
return Task.FromResult(0);
mBuffer = buffer;
mOffset = offset;
mEnding = offset + count;
// CompletionSource must be async so we can complete it from within the lock.
// If we move the completion outside the lock we may be able to do inline completion?
mResult = AsyncTaskCompletionSource<int>.Create();
Monitor.PulseAll(this);
return mResult.Task;
}
}
public AsyncManualResetEvent()
{
_tcs = new AsyncTaskCompletionSource();
}
