public void TaskYield_ConfigureAwait_OnDefaultSyncContext(bool useDefaultYield)
{
Task.Run(async delegate
{
SynchronizationContext defaultSyncContext = new SynchronizationContext();
SynchronizationContext.SetSynchronizationContext(defaultSyncContext);
var asyncLocal = new System.Threading.AsyncLocal <object> {
Value = 3
};
if (useDefaultYield)
{
await Task.Yield();
}
else
{
await Task.Yield().ConfigureAwait(true);
}
Assert.Equal(3, asyncLocal.Value);
Assert.Null(SynchronizationContext.Current);
await Task.Yield().ConfigureAwait(false);
Assert.Equal(3, asyncLocal.Value);
Assert.Null(SynchronizationContext.Current);
});
}
public void TaskYield_ConfigureAwait_OnNonDefaultTaskScheduler(bool useDefaultYield)
{
var scheduler = new MockTaskScheduler();
Task.Factory.StartNew(
async delegate
{
var asyncLocal = new System.Threading.AsyncLocal <object> {
Value = 3
};
if (useDefaultYield)
{
await Task.Yield();
}
else
{
await Task.Yield().ConfigureAwait(true);
}
Assert.Equal(3, asyncLocal.Value);
Assert.Same(scheduler, TaskScheduler.Current);
await Task.Yield().ConfigureAwait(false);
Assert.Equal(3, asyncLocal.Value);
Assert.NotSame(scheduler, TaskScheduler.Current);
},
CancellationToken.None,
TaskCreationOptions.None,
scheduler).Unwrap().GetAwaiter().GetResult();
}
public void TaskYield_ConfigureAwait_OnDispatcher(bool useDefaultYield)
{
this.ExecuteOnDispatcher(async delegate
{
var asyncLocal = new System.Threading.AsyncLocal <object> {
Value = 3
};
int originalThreadId = Environment.CurrentManagedThreadId;
if (useDefaultYield)
{
await Task.Yield();
}
else
{
await Task.Yield().ConfigureAwait(true);
}
Assert.Equal(3, asyncLocal.Value);
Assert.Equal(originalThreadId, Environment.CurrentManagedThreadId);
await Task.Yield().ConfigureAwait(false);
Assert.Equal(3, asyncLocal.Value);
Assert.NotEqual(originalThreadId, Environment.CurrentManagedThreadId);
});
}
public void TaskYield_ConfigureAwait_OnDefaultTaskScheduler(bool useDefaultYield)
{
Task.Run(
async delegate
{
var asyncLocal = new System.Threading.AsyncLocal <object> {
Value = 3
};
if (useDefaultYield)
{
await Task.Yield();
}
else
{
await Task.Yield().ConfigureAwait(true);
}
Assert.Equal(3, asyncLocal.Value);
Assert.Same(TaskScheduler.Default, TaskScheduler.Current);
await Task.Yield().ConfigureAwait(false);
Assert.Equal(3, asyncLocal.Value);
Assert.Same(TaskScheduler.Default, TaskScheduler.Current);
}).GetAwaiter().GetResult();
}
public async Task NoThrowAwaitable_UnsafeOnCompleted_DoesNotCaptureExecutionContext(bool captureContext)
{
var testResultTcs = new TaskCompletionSource <object?>();
var awaitableTcs = new TaskCompletionSource <object?>();
var asyncLocal = new System.Threading.AsyncLocal <object?>();
asyncLocal.Value = "expected";
TplExtensions.NoThrowTaskAwaiter awaiter = awaitableTcs.Task.NoThrowAwaitable(captureContext).GetAwaiter();
awaiter.UnsafeOnCompleted(delegate
{
try
{
Assert.Null(asyncLocal.Value);
testResultTcs.SetResult(null);
}
catch (Exception ex)
{
testResultTcs.SetException(ex);
}
});
asyncLocal.Value = null;
await Task.Yield();
awaitableTcs.SetResult(null);
await testResultTcs.Task.WithTimeout(UnexpectedTimeout);
}
public async Task NoThrowAwaitable_Await_CapturesExecutionContext(bool captureContext)
{
var awaitableTcs = new TaskCompletionSource <object?>();
var asyncLocal = new System.Threading.AsyncLocal <object?>();
asyncLocal.Value = "expected";
var testResult = Task.Run(async delegate
{
await awaitableTcs.Task.NoThrowAwaitable(captureContext); // uses UnsafeOnCompleted
Assert.Equal("expected", asyncLocal.Value);
});
asyncLocal.Value = null;
await Task.Delay(AsyncDelay); // Make sure the delegate above has time to yield
awaitableTcs.SetResult(null);
await testResult.WithTimeout(UnexpectedTimeout);
}
public async Task AwaitTaskScheduler_UnsafeOnCompleted_DoesNotCaptureExecutionContext()
{
var taskResultSource = new TaskCompletionSource <object?>();
System.Threading.AsyncLocal <object?> asyncLocal = new System.Threading.AsyncLocal <object?>();
asyncLocal.Value = "expected";
TaskScheduler.Default.GetAwaiter().UnsafeOnCompleted(delegate
{
try
{
Assert.Null(asyncLocal.Value);
taskResultSource.SetResult(null);
}
catch (Exception ex)
{
taskResultSource.SetException(ex);
}
});
asyncLocal.Value = null;
await taskResultSource.Task;
}
public async Task TaskYield_ConfigureAwait_OnCompleted_CapturesExecutionContext(bool captureContext)
{
var taskResultSource = new TaskCompletionSource <object?>();
System.Threading.AsyncLocal <object?> asyncLocal = new System.Threading.AsyncLocal <object?>();
asyncLocal.Value = "expected";
Task.Yield().ConfigureAwait(captureContext).GetAwaiter().OnCompleted(delegate
{
try
{
Assert.Equal("expected", asyncLocal.Value);
taskResultSource.SetResult(null);
}
catch (Exception ex)
{
taskResultSource.SetException(ex);
}
});
asyncLocal.Value = null;
await taskResultSource.Task;
}
public async Task AwaitTaskScheduler_OnCompleted_CapturesExecutionContext(bool defaultTaskScheduler)
{
var taskResultSource = new TaskCompletionSource <object?>();
System.Threading.AsyncLocal <object?> asyncLocal = new System.Threading.AsyncLocal <object?>();
asyncLocal.Value = "expected";
TaskScheduler scheduler = defaultTaskScheduler ? TaskScheduler.Default : new MockTaskScheduler();
scheduler.GetAwaiter().OnCompleted(delegate
{
try
{
Assert.Equal("expected", asyncLocal.Value);
taskResultSource.SetResult(null);
}
catch (Exception ex)
{
taskResultSource.SetException(ex);
}
});
asyncLocal.Value = null;
await taskResultSource.Task;
}
