public void AsyncLock_Locked_PreventsLockUntilUnlocked()
{
AsyncContext.Run(async () =>
{
var mutex = new AsyncLock();
var task1HasLock = new TaskCompletionSource();
var task1Continue = new TaskCompletionSource();
Task<IDisposable> task1LockTask = null;
var task1 = Task.Run(async () =>
{
task1LockTask = mutex.LockAsync();
using (await task1LockTask)
{
task1HasLock.SetResult();
await task1Continue.Task;
}
});
await task1HasLock.Task;
Task<IDisposable> task2LockTask = null;
var task2Start = Task.Factory.StartNew(async () =>
{
task2LockTask = mutex.LockAsync();
await task2LockTask;
});
var task2 = await task2Start;
Assert.IsFalse(task2.IsCompleted);
task1Continue.SetResult();
await task2;
});
}
public void AsyncLock_Locked_PreventsLockUntilUnlocked()
{
Test.Async(async () =>
{
var mutex = new AsyncLock();
var task1HasLock = new TaskCompletionSource();
var task1Continue = new TaskCompletionSource();
var task1 = TaskShim.Run(async () =>
{
using (await mutex.LockAsync())
{
task1HasLock.SetResult();
await task1Continue.Task;
}
});
await task1HasLock.Task;
var task2Start = Task.Factory.StartNew(async () =>
{
await mutex.LockAsync();
});
var task2 = await task2Start;
Assert.IsFalse(task2.IsCompleted);
task1Continue.SetResult();
await task2;
});
}
public void Locked_PreventsLockUntilUnlocked()
{
AsyncContext.Run(async () =>
{
var monitor = new AsyncMonitor();
var task1HasLock = new TaskCompletionSource();
var task1Continue = new TaskCompletionSource();
Task<IDisposable> initialLockTask = null;
var task1 = Task.Run(async () =>
{
initialLockTask = monitor.EnterAsync();
using (await initialLockTask)
{
task1HasLock.SetResult();
await task1Continue.Task;
}
});
await task1HasLock.Task;
var lockTask = monitor.EnterAsync();
Assert.IsFalse(lockTask.IsCompleted);
task1Continue.SetResult();
await lockTask;
});
}
public void ProgressReport_NotifiesChangeOnCapturedSynchronizationContext()
{
Test.Async(async () =>
{
SynchronizationContext updateContext = null;
SynchronizationContext threadContext = null;
var tcs = new TaskCompletionSource();
using (var thread = new AsyncContextThread())
{
threadContext = await thread.Factory.Run(() => SynchronizationContext.Current);
PropertyProgress<int> propertyProgress = await thread.Factory.Run(() => new PropertyProgress<int>());
propertyProgress.PropertyChanged += (_, e) =>
{
updateContext = SynchronizationContext.Current;
tcs.SetResult();
};
IProgress<int> progress = propertyProgress;
progress.Report(13);
await tcs.Task;
}
Assert.IsNotNull(updateContext);
Assert.AreEqual(threadContext, updateContext);
});
}
/// <summary>
/// Creates an async-compatible manual-reset event.
/// </summary>
/// <param name="set">Whether the manual-reset event is initially set or unset.</param>
public AsyncManualResetEvent(bool set) {
_sync = new object();
_tcs = new TaskCompletionSource();
if (set) {
//Enlightenment.Trace.AsyncManualResetEvent_Set(this, _tcs.Task);
_tcs.SetResult();
}
}
private static Task<string> GetSomeTextAsync()
{
// https://msdn.microsoft.com/en-us/library/hh873177(v=vs.110).aspx
var tcs = new TaskCompletionSource<string>();
tcs.SetResult("some text");
return tcs.Task;
}
public void SignalAndWaitAsync_Underflow_ThrowsException()
{
var tcs = new TaskCompletionSource();
var barrier = new AsyncBarrier(1, async _ => { await tcs.Task; });
barrier.SignalAndWaitAsync();
AssertEx.ThrowsException<InvalidOperationException>(() => barrier.SignalAndWaitAsync());
tcs.SetResult();
}
private Task SynchronouslyEndingOperation()
{
Synchronous.Log("Entered synchronously ending operation");
Thread.Sleep(100);
var tcs = new TaskCompletionSource();
tcs.SetResult();
Synchronous.Log("Leaving synchronously ending operation");
return tcs.Task;
}
public void FromTaskSynchronously_TaskCompletes_TokenGetsCancellationRequested()
{
var tcs = new TaskCompletionSource();
var result = CancellationTokenHelpers.FromTask(tcs.Task, TaskContinuationOptions.ExecuteSynchronously);
tcs.SetResult();
Assert.IsTrue(result.Token.CanBeCanceled);
Assert.IsTrue(result.Token.IsCancellationRequested);
}
public void Pulse_ReleasesOneWaiter()
{
AsyncContext.Run(async () =>
{
var monitor = new AsyncMonitor();
int completed = 0;
var task1Ready = new TaskCompletionSource();
var task2Ready = new TaskCompletionSource();
Task<IDisposable> lockTask1 = null;
Task waitTask1 = null;
var task1 = Task.Run(async () =>
{
lockTask1 = monitor.EnterAsync();
using (await lockTask1)
{
waitTask1 = monitor.WaitAsync();
task1Ready.SetResult();
await waitTask1;
Interlocked.Increment(ref completed);
}
});
await task1Ready.Task;
Task<IDisposable> lockTask2 = null;
Task waitTask2 = null;
var task2 = Task.Run(async () =>
{
lockTask2 = monitor.EnterAsync();
using (await lockTask2)
{
waitTask2 = monitor.WaitAsync();
task2Ready.SetResult();
await waitTask2;
Interlocked.Increment(ref completed);
}
});
await task2Ready.Task;
Task<IDisposable> lockTask3 = monitor.EnterAsync();
using (await lockTask3)
{
monitor.Pulse();
}
await Task.WhenAny(task1, task2);
var result = Interlocked.CompareExchange(ref completed, 0, 0);
Assert.AreEqual(1, result);
});
}
public void AsyncLazy_Start_CallsFunc()
{
AsyncContext.Run(async () =>
{
var tcs = new TaskCompletionSource();
Func<int> func = () =>
{
tcs.SetResult();
return 13;
};
var lazy = new AsyncLazy<int>(func);
lazy.Start();
await tcs.Task;
});
}
public void AsyncLock_DoubleDispose_OnlyPermitsOneTask()
{
AsyncContext.Run(async () =>
{
var mutex = new AsyncLock();
var task1HasLock = new TaskCompletionSource();
var task1Continue = new TaskCompletionSource();
Task<IDisposable> lockTask = null;
await Task.Run(async () =>
{
lockTask = mutex.LockAsync();
var key = await lockTask;
key.Dispose();
key.Dispose();
});
Task<IDisposable> task1LockTask = null;
var task1 = Task.Run(async () =>
{
task1LockTask = mutex.LockAsync();
using (await task1LockTask)
{
task1HasLock.SetResult();
await task1Continue.Task;
}
});
await task1HasLock.Task;
Task<IDisposable> task2LockTask = null;
var task2Start = Task.Factory.StartNew(async () =>
{
task2LockTask = mutex.LockAsync();
await task2LockTask;
});
var task2 = await task2Start;
Assert.IsFalse(task2.IsCompleted);
task1Continue.SetResult();
await task2;
});
}
public void Pulse_ReleasesOneWaiter()
{
Test.Async(async () =>
{
var monitor = new AsyncMonitor();
int completed = 0;
var task1Ready = new TaskCompletionSource();
var task2Ready = new TaskCompletionSource();
var task1 = TaskShim.Run(async () =>
{
using (await monitor.EnterAsync())
{
var waitTask1 = monitor.WaitAsync();
task1Ready.SetResult();
await waitTask1;
Interlocked.Increment(ref completed);
}
});
await task1Ready.Task;
var task2 = TaskShim.Run(async () =>
{
using (await monitor.EnterAsync())
{
var waitTask2 = monitor.WaitAsync();
task2Ready.SetResult();
await waitTask2;
Interlocked.Increment(ref completed);
}
});
await task2Ready.Task;
using (await monitor.EnterAsync())
{
monitor.Pulse();
}
await TaskShim.WhenAny(task1, task2);
var result = Interlocked.CompareExchange(ref completed, 0, 0);
Assert.AreEqual(1, result);
});
}
public void WriteLocked_Unlocked_PermitsAnotherWriterLock()
{
AsyncContext.Run(async () =>
{
var rwl = new AsyncReaderWriterLock();
var firstWriteLockTaken = new TaskCompletionSource();
var releaseFirstWriteLock = new TaskCompletionSource();
var task = Task.Run(async () =>
{
using (await rwl.WriterLockAsync())
{
firstWriteLockTaken.SetResult();
await releaseFirstWriteLock.Task;
}
});
await firstWriteLockTaken.Task;
var lockTask = rwl.WriterLockAsync();
Assert.IsFalse(lockTask.IsCompleted);
releaseFirstWriteLock.SetResult();
await lockTask;
});
}
public void Locked_PreventsLockUntilUnlocked()
{
Test.Async(async () =>
{
var monitor = new AsyncMonitor();
var task1HasLock = new TaskCompletionSource();
var task1Continue = new TaskCompletionSource();
var task1 = TaskShim.Run(async () =>
{
using (await monitor.EnterAsync())
{
task1HasLock.SetResult();
await task1Continue.Task;
}
});
await task1HasLock.Task;
var lockTask = monitor.EnterAsync().AsTask();
Assert.IsFalse(lockTask.IsCompleted);
task1Continue.SetResult();
await lockTask;
});
}
/*
Old New Description
task.Wait await task Wait/await for a task to complete
task.Result await task Get the result of a completed task
Task.WaitAny await Task.WhenAny Wait/await for one of a collection of tasks to complete
Task.WaitAll await Task.WhenAll Wait/await for every one of a collection of tasks to complete
Thread.Sleep await Task.Delay Wait/await for a period of time
Task constructor Task.Run or TaskFactory.StartNew Create a code-based task
*/
#endregion
#region Mapping
/*
Type Lambda Parameters Return Value
Action () => { } None None
Func<Task> async () => { await Task.Yield(); } None None
Func<TResult> () => { return 6; } None TResult
Func<Task<TResult>> async () => { await Task.Yield(); return 6; } None TResult
Action<TArg1> x => { } TArg1 None
Func<TArg1, Task> async x => { await Task.Yield(); } TArg1 None
Func<TArg1, TResult> x => { return 6; } TArg1 TResult
Func<TArg1, Task<TResult>> async x => { await Task.Yield(); return 6; } TArg1 TResult
Action<TArg1, TArg2> (x, y) => { } TArg1, TArg2 None
Func<TArg1, TArg2, Task> async (x, y) => { await Task.Yield(); } TArg1, TArg2 None
Func<TArg1, TArg2, TResult> (x, y) => { return 6; } TArg1, TArg2 TResult
Func<TArg1, TArg2, Task<TResult>> async (x, y) => { await Task.Yield(); return 6; } TArg1, TArg2 TResult
*/
#endregion
#region DelayImplementation
private static Task Delay(int milliseconds)
{
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
Timer timer = new Timer(x => tcs.SetResult(null), null, milliseconds, Timeout.Infinite);
tcs.Task.ContinueWith(x => timer.Dispose());
return tcs.Task;
}
public void UpgradeableReadAndReadLocked_Upgrade_WaitsForReaderLockToUnlock()
{
Test.Async(async () =>
{
var rwl = new AsyncReaderWriterLock();
var readLockTaken = new TaskCompletionSource();
var releaseReadLock = new TaskCompletionSource();
var task = TaskShim.Run(async () =>
{
using (await rwl.ReaderLockAsync())
{
readLockTaken.SetResult();
await releaseReadLock.Task;
}
});
await readLockTaken.Task;
using (var key = await rwl.UpgradeableReaderLockAsync())
{
Assert.IsFalse(key.Upgraded);
var lockTask = key.UpgradeAsync().AsTask();
Assert.IsFalse(lockTask.IsCompleted);
releaseReadLock.SetResult();
await lockTask;
Assert.IsTrue(key.Upgraded);
}
});
}
public void UpgradeableReadAndReadLocked_UpgradeAborted_CompletesAsCanceled()
{
Test.Async(async () =>
{
var rwl = new AsyncReaderWriterLock();
var readLockTaken = new TaskCompletionSource();
var task = TaskShim.Run(async () =>
{
using (await rwl.ReaderLockAsync())
{
readLockTaken.SetResult();
await TaskConstants.Never;
}
});
await readLockTaken.Task;
Task upgradeTask;
using (var key = await rwl.UpgradeableReaderLockAsync())
{
upgradeTask = key.UpgradeAsync().AsTask();
Assert.IsFalse(key.Upgraded);
}
await AssertEx.ThrowsExceptionAsync<OperationCanceledException>(upgradeTask);
});
}
public void SetResult_CompletesTask()
{
Test.Async(async () =>
{
var tcs = new TaskCompletionSource();
tcs.SetResult();
await tcs.Task;
});
}
public void SetResult_CompletesTask()
{
AsyncContext.Run(async () =>
{
var tcs = new TaskCompletionSource();
tcs.SetResult();
await tcs.Task;
});
}
public void AsyncLock_Locked_OnlyPermitsOneLockerAtATime()
{
Test.Async(async () =>
{
var mutex = new AsyncLock();
var task1HasLock = new TaskCompletionSource();
var task1Continue = new TaskCompletionSource();
var task2HasLock = new TaskCompletionSource();
var task2Continue = new TaskCompletionSource();
var task1 = TaskShim.Run(async () =>
{
using (await mutex.LockAsync())
{
task1HasLock.SetResult();
await task1Continue.Task;
}
});
await task1HasLock.Task;
var task2Start = Task.Factory.StartNew(async () =>
{
using (await mutex.LockAsync())
{
task2HasLock.SetResult();
await task2Continue.Task;
}
});
var task2 = await task2Start;
var task3Start = Task.Factory.StartNew(async () =>
{
await mutex.LockAsync();
});
var task3 = await task3Start;
task1Continue.SetResult();
await task2HasLock.Task;
Assert.IsFalse(task3.IsCompleted);
task2Continue.SetResult();
await task2;
await task3;
});
}
public void TestAsync()
{
const int taskCount = 5000;
// Create an asynchronous context in which to run.
AsyncContext.Run(
async ()
=>
{
Task[] tasks = new Task[taskCount];
for (int a = 0; a < taskCount; a++)
tasks[a] = TaskEx.RunEx(
async () =>
{
ContextStack<string> stack = new ContextStack<string>();
TaskCompletionSource tcs1 = new TaskCompletionSource();
TaskCompletionSource tcs2 = new TaskCompletionSource();
TaskCompletionSource tcs3 = new TaskCompletionSource();
string randomString = Guid.NewGuid().ToString();
string randomString2 = Guid.NewGuid().ToString();
using (stack.Region(randomString))
{
// Check we have 'A' in the current stack.
Assert.AreEqual(randomString, stack.Current);
Assert.AreEqual(1, stack.CurrentStack.Count());
Assert.AreEqual(randomString, stack.CurrentStack.Last());
int threadId = Thread.CurrentThread.ManagedThreadId;
// Await the task
await TaskEx.Delay(500);
// Check we still have 'A' in the current stack.
Assert.AreEqual(randomString, stack.Current);
Assert.AreEqual(1, stack.CurrentStack.Count());
Assert.AreEqual(randomString, stack.CurrentStack.Last());
// Create new thread.
Task task = TaskEx.RunEx(
async () =>
{
int task2Thread = Thread.CurrentThread.ManagedThreadId;
// Assess if this is a new thread
if (threadId != task2Thread)
Interlocked.Increment(ref _task2NewThread);
// Check we have 'A' in the current stack.
Assert.AreEqual(randomString,
stack.Current);
Assert.AreEqual(1, stack.CurrentStack.Count());
Assert.AreEqual(randomString,
stack.CurrentStack.Last());
// Wait for the first signal
await tcs1.Task;
// Check we still have 'A' in the current stack (i.e. we're not affected by additions in first thread.
Assert.AreEqual(randomString, stack.Current);
Assert.AreEqual(1, stack.CurrentStack.Count());
Assert.AreEqual(randomString,
stack.CurrentStack.Last());
// Add C to stack.
using (stack.Region("C"))
{
// We should have A, C in stack now.
Assert.AreEqual("C", stack.Current);
Assert.AreEqual(2,
stack.CurrentStack.Count());
Assert.AreEqual(randomString,
stack.CurrentStack.First());
// Second signal
tcs2.SetResult();
// Wait for the 3rd signal
await tcs3.Task;
// We should still have A, C in stack now.
Assert.AreEqual("C", stack.Current);
Assert.AreEqual(2,
stack.CurrentStack.Count());
Assert.AreEqual(randomString,
stack.CurrentStack.First());
}
// Back to just having C.
Assert.AreEqual(randomString, stack.Current);
Assert.AreEqual(1, stack.CurrentStack.Count());
Assert.AreEqual(randomString,
stack.CurrentStack.Last());
// Wait a bit before finishing.
await TaskEx.Delay(100);
if (task2Thread !=
Thread.CurrentThread.ManagedThreadId)
Interlocked.Increment(
ref _task2ThreadSwitch);
});
// Add B to stack.
using (stack.Region(randomString2))
{
// We should have A, B in stack now.
Assert.AreEqual(randomString2, stack.Current);
Assert.AreEqual(2, stack.CurrentStack.Count());
Assert.AreEqual(randomString, stack.CurrentStack.First());
// Signal 2nd task with first signal.
tcs1.SetResult();
// Wait for 2nd task to signal back with 2nd second.
await tcs2.Task;
// We should still have A, B in stack now.
Assert.AreEqual(randomString2, stack.Current);
Assert.AreEqual(2, stack.CurrentStack.Count());
Assert.AreEqual(randomString, stack.CurrentStack.First());
// Signal 2nd task with third signal
tcs3.SetResult();
// Wait for task to finish.
await task;
// We should still have A, B in stack now.
Assert.AreEqual(randomString2, stack.Current);
Assert.AreEqual(2, stack.CurrentStack.Count());
Assert.AreEqual(randomString, stack.CurrentStack.First());
}
// We should just have A in stack.
Assert.AreEqual(randomString, stack.Current);
Assert.AreEqual(1, stack.CurrentStack.Count());
if (threadId != Thread.CurrentThread.ManagedThreadId)
Interlocked.Increment(ref _task1ThreadSwitch);
}
// The stack should be empty
Assert.IsNull(stack.Current);
Assert.AreEqual(0, stack.CurrentStack.Count());
});
await TaskEx.WhenAll(tasks);
});
Trace.WriteLine(
String.Format(
"Task1 Thread Switch: {1}{0}Task2 Thread Switch: {2}{0}Task2 new thread: {3}{0}Total tasks: {4}",
Environment.NewLine,
_task1ThreadSwitch,
_task2ThreadSwitch,
_task2NewThread,
taskCount));
}
public void AsyncLock_DoubleDispose_OnlyPermitsOneTask()
{
Test.Async(async () =>
{
var mutex = new AsyncLock();
var task1HasLock = new TaskCompletionSource();
var task1Continue = new TaskCompletionSource();
await TaskShim.Run(async () =>
{
var key = await mutex.LockAsync();
key.Dispose();
key.Dispose();
});
var task1 = TaskShim.Run(async () =>
{
using (await mutex.LockAsync())
{
task1HasLock.SetResult();
await task1Continue.Task;
}
});
await task1HasLock.Task;
var task2Start = Task.Factory.StartNew(async () =>
{
await mutex.LockAsync();
});
var task2 = await task2Start;
Assert.IsFalse(task2.IsCompleted);
task1Continue.SetResult();
await task2;
});
}
public void AsyncLock_Locked_OnlyPermitsOneLockerAtATime()
{
AsyncContext.Run(async () =>
{
var mutex = new AsyncLock();
var task1HasLock = new TaskCompletionSource();
var task1Continue = new TaskCompletionSource();
var task2HasLock = new TaskCompletionSource();
var task2Continue = new TaskCompletionSource();
Task<IDisposable> task1LockTask = null, task2LockTask = null, task3LockTask = null;
var task1 = Task.Run(async () =>
{
task1LockTask = mutex.LockAsync();
using (await task1LockTask)
{
task1HasLock.SetResult();
await task1Continue.Task;
}
});
await task1HasLock.Task;
var task2Start = Task.Factory.StartNew(async () =>
{
task2LockTask = mutex.LockAsync();
using (await task2LockTask)
{
task2HasLock.SetResult();
await task2Continue.Task;
}
});
var task2 = await task2Start;
var task3Start = Task.Factory.StartNew(async () =>
{
task3LockTask = mutex.LockAsync();
await task3LockTask;
});
var task3 = await task3Start;
task1Continue.SetResult();
await task2HasLock.Task;
Assert.IsFalse(task3.IsCompleted);
task2Continue.SetResult();
await task2;
await task3;
});
}
public void AsyncLock_CancelledLock_LeavesLockUnlocked()
{
AsyncContext.Run(async () =>
{
var mutex = new AsyncLock();
var cts = new CancellationTokenSource();
var taskReady = new TaskCompletionSource();
Task<IDisposable> initialLockTask = null, lockTask = null;
initialLockTask = mutex.LockAsync();
var unlock = await initialLockTask;
var task = Task.Run(async () =>
{
lockTask = mutex.LockAsync(cts.Token);
taskReady.SetResult();
await lockTask;
});
await taskReady.Task;
cts.Cancel();
await AssertEx.ThrowsExceptionAsync<OperationCanceledException>(task);
Assert.IsTrue(task.IsCanceled);
unlock.Dispose();
var finalLockTask = mutex.LockAsync();
await finalLockTask;
});
}
/// <summary>
/// Invoked when the browser is disconnected.
/// </summary>
/// <param name="tcs"></param>
/// <param name="args"></param>
void OnDisconnected(TaskCompletionSource<VoiceXmlResult> tcs, DisconnectedEventArgs args)
{
Dispatch(() =>
{
if (tcs.Task.IsCompleted)
return;
tcs.SetResult(null);
});
}
public void AsyncLazy_MultipleAwaiters_OnlyInvokeAsyncFuncOnce()
{
AsyncContext.Run(async () =>
{
int invokeCount = 0;
var tcs = new TaskCompletionSource();
Func<Task<int>> func = async () =>
{
Interlocked.Increment(ref invokeCount);
await tcs.Task;
return 13;
};
var lazy = new AsyncLazy<int>(func);
var task1 = Task.Factory.StartNew(async () => await lazy).Result;
var task2 = Task.Factory.StartNew(async () => await lazy).Result;
Assert.IsFalse(task1.IsCompleted);
Assert.IsFalse(task2.IsCompleted);
tcs.SetResult();
var results = await Task.WhenAll(task1, task2);
Assert.IsTrue(results.SequenceEqual(new[] { 13, 13 }));
Assert.AreEqual(1, invokeCount);
});
}
public async Task RecursiveAsyncLock_DoesNotPermitIndependentWaits()
{
var mutex0 = new RecursiveAsyncLock();
using (await mutex0.LockAsync())
{
var mutex = new RecursiveAsyncLock();
Func<TaskCompletionSource, TaskCompletionSource, Task> taker = async (ready, finish) =>
{
Assert.IsFalse(AsyncLockTracker.Contains(mutex));
using (await mutex.LockAsync())
{
Assert.IsTrue(AsyncLockTracker.Contains(mutex));
ready.TrySetResult();
await finish.Task;
Assert.IsTrue(AsyncLockTracker.Contains(mutex));
}
Assert.IsFalse(AsyncLockTracker.Contains(mutex));
};
var ready1 = new TaskCompletionSource();
var finish1 = new TaskCompletionSource();
Assert.IsFalse(AsyncLockTracker.Contains(mutex));
var task1 = taker(ready1, finish1);
Assert.IsFalse(AsyncLockTracker.Contains(mutex));
await Task.WhenAny(ready1.Task, task1);
Assert.IsFalse(AsyncLockTracker.Contains(mutex));
var ready2 = new TaskCompletionSource();
var finish2 = new TaskCompletionSource();
Assert.IsFalse(AsyncLockTracker.Contains(mutex));
var task2 = taker(ready2, finish2);
Assert.IsFalse(AsyncLockTracker.Contains(mutex));
Assert.IsFalse(ready2.Task.Wait(1000));
finish1.SetResult();
await Task.WhenAny(ready2.Task, task2);
Assert.IsFalse(AsyncLockTracker.Contains(mutex));
finish2.SetResult();
await Task.WhenAll(task1, task2);
Assert.IsFalse(AsyncLockTracker.Contains(mutex));
}
}
/// <summary>
/// Invoked when the session is complete. Sets the results of the session on the given task source.
/// </summary>
/// <param name="tcs"></param>
/// <param name="args"></param>
void OnSessionCompleted(TaskCompletionSource<VoiceXmlResult> tcs, SessionCompletedEventArgs args)
{
if (tcs.Task.IsCompleted)
return;
Dispatch(() =>
{
if (tcs.Task.IsCompleted)
return;
if (args.Cancelled)
tcs.SetCanceled();
else if (args.Error != null)
tcs.SetException(args.Error);
else if (args.Result.UnhandledThrowElement != null)
tcs.SetException(new UnhandledPageThrowException(args.Result.UnhandledThrowElement));
else
tcs.SetResult(args.Result);
});
}
