public void Constructor_Should_Throw_Exception_On_Null_Context()
{
SynchronizationContextTaskScheduler res = null;
Action Do = () => res = new SynchronizationContextTaskScheduler(null);
Do.ShouldThrow <ArgumentNullException>();
}
public void Constructor_Should_Throw_Exception_On_Null_Context()
{
SynchronizationContextTaskScheduler res = null;
Action Do = () => res = new SynchronizationContextTaskScheduler(null);
Do.ShouldThrow<ArgumentNullException>();
}
private static SynchronizationContextTaskScheduler CreateTaskScheduler()
{
var synchronizationContext = new SynchronizationContext();
var localTaskScheduler = new SynchronizationContextTaskScheduler(synchronizationContext);
return(localTaskScheduler);
}
public void MaximumConcurrencyLevel_Should_Be_1()
{
//Arrange
var synContext = Substitute.For<SynchronizationContext>();
var target = new SynchronizationContextTaskScheduler(synContext);
//Assert
target.MaximumConcurrencyLevel.Should().Be(1);
}
public void MaximumConcurrencyLevel_Should_Be_1()
{
//Arrange
var synContext = Substitute.For <SynchronizationContext>();
var target = new SynchronizationContextTaskScheduler(synContext);
//Assert
target.MaximumConcurrencyLevel.Should().Be(1);
}
public void GetScheduledTasksEnumerable_Should_Be_Null()
{
//Arrange
var synContext = Substitute.For <SynchronizationContext>();
var target = new SynchronizationContextTaskScheduler(synContext);
//Assert
target.GetScheduledTasksEnumerable().Should().BeNull();
}
public void GetScheduledTasksEnumerable_Should_Be_Null()
{
//Arrange
var synContext = Substitute.For<SynchronizationContext>();
var target = new SynchronizationContextTaskScheduler(synContext);
//Assert
target.GetScheduledTasksEnumerable().Should().BeNull();
}
/// <summary>
/// Waiting for the application to 'idle' means that it is done pumping messages (including WM_PAINT).
/// </summary>
/// <param name="cancellationToken">The cancellation token that the operation will observe.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected static async Task WaitForApplicationIdleAsync(CancellationToken cancellationToken)
{
var synchronizationContext = new DispatcherSynchronizationContext(Application.Current.Dispatcher, DispatcherPriority.ApplicationIdle);
var taskScheduler = new SynchronizationContextTaskScheduler(synchronizationContext);
await Task.Factory.StartNew(
() => { },
cancellationToken,
TaskCreationOptions.None,
taskScheduler);
}
internal static ForegroundThreadData CreateDefault()
{
var kind = ForegroundThreadDataInfo.CreateDefault();
// None of the work posted to the foregroundTaskScheduler should block pending keyboard/mouse input from the user.
// So instead of using the default priority which is above user input, we use Background priority which is 1 level
// below user input.
var taskScheduler = new SynchronizationContextTaskScheduler(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher, DispatcherPriority.Background));
return new ForegroundThreadData(Thread.CurrentThread, taskScheduler, kind);
}
internal static ForegroundThreadData CreateDefault()
{
ForegroundThreadDataKind kind = SynchronizationContext.Current?.GetType().FullName == "System.Windows.Threading.DispatcherSynchronizationContext"
? ForegroundThreadDataKind.Wpf
: ForegroundThreadDataKind.Unknown;
// None of the work posted to the foregroundTaskScheduler should block pending keyboard/mouse input from the user.
// So instead of using the default priority which is above user input, we use Background priority which is 1 level
// below user input.
var taskScheduler = new SynchronizationContextTaskScheduler(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher, DispatcherPriority.Background));
return new ForegroundThreadData(Thread.CurrentThread, taskScheduler, kind);
}
public async Task Task_Created_By_Corresponding_Factory_Should_Call_SynchronizationContext_Post()
{
//Arrange
var synContext = BuildSynchronizationContext();
var target = new SynchronizationContextTaskScheduler(synContext);
bool done = false;
var factory = new TaskFactory(target);
await factory.StartNew(() => done = true);
//Assert
synContext.Received().Post(Arg.Any<SendOrPostCallback>(), Arg.Any<object>());
done.Should().BeTrue();
}
public async Task Task_Created_By_Corresponding_Factory_Should_Call_SynchronizationContext_Post()
{
//Arrange
var synContext = BuildSynchronizationContext();
var target = new SynchronizationContextTaskScheduler(synContext);
bool done = false;
var factory = new TaskFactory(target);
await factory.StartNew(() => done = true);
//Assert
synContext.Received().Post(Arg.Any <SendOrPostCallback>(), Arg.Any <object>());
done.Should().BeTrue();
}
protected override void Initialize()
{
base.Initialize();
// Assume that we are being initialized on the UI thread at this point, and setup our foreground state
var kind = ForegroundThreadDataInfo.CreateDefault(ForegroundThreadDataKind.ForcedByPackageInitialize);
// None of the work posted to the foregroundTaskScheduler should block pending keyboard/mouse input from the user.
// So instead of using the default priority which is above user input, we use Background priority which is 1 level
// below user input.
var taskScheduler = new SynchronizationContextTaskScheduler(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher, DispatcherPriority.Background));
ForegroundThreadAffinitizedObject.CurrentForegroundThreadData = new ForegroundThreadData(Thread.CurrentThread, taskScheduler, kind);
ForegroundObject = new ForegroundThreadAffinitizedObject();
}
protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);
await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
// Assume that we are being initialized on the UI thread at this point, and setup our foreground state
var kind = ForegroundThreadDataInfo.CreateDefault(ForegroundThreadDataKind.ForcedByPackageInitialize);
// None of the work posted to the foregroundTaskScheduler should block pending keyboard/mouse input from the user.
// So instead of using the default priority which is above user input, we use Background priority which is 1 level
// below user input.
var taskScheduler = new SynchronizationContextTaskScheduler(new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher, DispatcherPriority.Background));
ForegroundThreadAffinitizedObject.CurrentForegroundThreadData = new ForegroundThreadData(Thread.CurrentThread, taskScheduler, kind);
ForegroundObject = new ForegroundThreadAffinitizedObject();
}
public IEnumerator CustomScheduler_ChainRunsOnTheSameScheduler()
{
using (var test = StartTest())
{
using (var context = new ThreadSynchronizationContext(test.TaskManager.Token))
using (var scheduler = new SynchronizationContextTaskScheduler(context))
{
int expected = 0;
scheduler.Context.Send(_ => expected = Thread.CurrentThread.ManagedThreadId, null);
var task = test.TaskManager
.With(s => {
s.Add(Thread.CurrentThread.ManagedThreadId);
return(s);
}, new List <int>(), TaskAffinity.Custom)
.ThenInUI(s => {
s.Add(Thread.CurrentThread.ManagedThreadId);
return(s);
})
.Then(s => {
s.Add(Thread.CurrentThread.ManagedThreadId);
return(s);
}, TaskAffinity.Custom)
.Finally((s, e, ret) => {
if (!s)
{
e.Rethrow();
}
return(ret);
});
task.Start(scheduler);
foreach (var frame in WaitForCompletion(task))
{
yield return(frame);
}
if (!task.Successful)
{
task.Exception.Rethrow();
}
var actual = task.Result;
actual.Matches(new[] { expected, test.TaskManager.UIThread, expected });
}
}
}
public IEnumerator CustomScheduler_Works()
{
using (var test = StartTest())
{
using (var context = new ThreadSynchronizationContext(test.TaskManager.Token))
using (var scheduler = new SynchronizationContextTaskScheduler(context))
{
int expected = 0;
scheduler.Context.Send(_ => expected = Thread.CurrentThread.ManagedThreadId, null);
var task = test.TaskManager.With(() => Thread.CurrentThread.ManagedThreadId, TaskAffinity.Custom);
task.Start(scheduler);
foreach (var frame in StartAndWaitForCompletion(task))
{
yield return(frame);
}
Assert.Greater(task.Result, 1);
task.Result.Matches(expected);
}
}
}
public IEnumerator CustomScheduler_AsyncKeepsOrder()
{
using (var test = StartTest())
{
using (var context = new ThreadSynchronizationContext(test.TaskManager.Token))
using (var scheduler = new SynchronizationContextTaskScheduler(context))
{
int expected = 0;
scheduler.Context.Send(_ => expected = Thread.CurrentThread.ManagedThreadId, null);
var order = new List <int>();
var task1 = test.TaskManager
.WithAsync(async s => {
await Task.Delay(10);
s.Add(1);
return(s);
}, order, TaskAffinity.Custom)
.Finally((s, e, ret) => {
if (!s)
{
e.Rethrow();
}
return(ret);
});
var task2 = test.TaskManager.WithAsync(async s => {
await Task.Yield();
s.Add(2);
return(s);
}, order, TaskAffinity.Custom)
.Finally((s, e, ret) => {
if (!s)
{
e.Rethrow();
}
return(ret);
});
var task3 = test.TaskManager.WithAsync(async s => {
s.Add(3);
await Task.Yield();
return(s);
}, order, TaskAffinity.Custom)
.Finally((s, e, ret) => {
if (!s)
{
e.Rethrow();
}
return(ret);
});
task1.Start(scheduler);
task2.Start(scheduler);
task3.Start(scheduler);
foreach (var frame in WaitForCompletion(task1, task2, task3))
{
yield return(frame);
}
order.Matches(new int[] { 1, 2, 3 });
}
}
}
internal static void Schedule(this SynchronizationContextTaskScheduler scheduler, ITaskManager taskManager, Func <Task> action)
{
taskManager.WithAsync(action, TaskAffinity.Custom).Start(scheduler);
}
internal static void Schedule(this SynchronizationContextTaskScheduler scheduler, Action <object> action, object state, CancellationToken token)
{
Task.Factory.StartNew(action, state, token, TaskCreationOptions.None, scheduler);
}
