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); }