public void AllComplete_ExecutesCallbackWhenSomeDiscardedSomeCompleted()
{
var run = false;
var s = MockMaker.Empty <IScheduler>();
var t1 = new DelegateBasedAsyncTask(s);
var t2 = new DelegateBasedAsyncTask(s);
var l = new List <AsyncTask>()
{
t1,
t2
};
l.AllComplete((_) =>
{
run = true;
});
t1.HandleTaskDiscarded();
t2.HandleTaskCompletion();
Assert.True(run);
}
/// <summary>
/// Add a new task to the scheduler to be executed and after that run a
/// follow-up task.
/// </summary>
/// <param name="a">The task to be run in the scheduler</param>
/// <param name="h">The follow up handler to be executed</param>
private void RunOnSchedulerSync(Action a, AsyncTaskCompletedHandler h)
{
var task = new DelegateBasedAsyncTask(scheduler, a);
task.ThenPost(h, SynchronizationContext.Current);
scheduler.ScheduleForExecution(task);
}
public void AllComplete_ReturnsDisposableThatDisposesAllRegistrations()
{
var run = false;
var s = MockMaker.Empty <IScheduler>();
var t1 = new DelegateBasedAsyncTask(s);
var t2 = new DelegateBasedAsyncTask(s);
var l = new List <AsyncTask>()
{
t1,
t2
};
l.AllComplete((_) =>
{
run = true;
}).Dispose();
t1.HandleTaskCompletion();
t2.HandleTaskDiscarded();
Assert.False(run);
}
public static void ExecuteOnIdleAsync(Action p)
{
var scheduler = DynamoRevit.RevitDynamoModel.Scheduler;
var task = new DelegateBasedAsyncTask(scheduler);
task.Initialize(p);
scheduler.ScheduleForExecution(task);
}
private void UpdateHtmlString()
{
var s = _dynamoViewModel.Model.Scheduler;
var t = new DelegateBasedAsyncTask(s, () =>
{
_mandrillNode.MyHtml = _mandrillNode.GetInputString(_dynamoModel.EngineController);
});
s.ScheduleForExecution(t);
}
private void UpdateNode()
{
var s = _dynamoViewModel.Model.Scheduler;
var t = new DelegateBasedAsyncTask(s, () =>
{
_customNode.Input = _customNode.GetInputString(_dynamoModel.EngineController);
});
s.ScheduleForExecution(t);
}
private void ResetWatch()
{
// When the node has no input connected, the preview should be empty
// Without doing this, the preview would say "null"
if (watch.IsPartiallyApplied)
{
rootWatchViewModel.Children.Clear();
rootWatchViewModel.IsCollection = false;
return;
}
// If the node hasn't been evaluated, no need to update the UI
if (!watch.HasRunOnce)
{
return;
}
var s = dynamoViewModel.Model.Scheduler;
WatchViewModel wvm = null;
// prevent data race by running on scheduler
var t = new DelegateBasedAsyncTask(s, () =>
{
wvm = GetWatchViewModel();
});
// then update on the ui thread
t.ThenPost((_) =>
{
//If wvm is not computed successfully then don't post.
if (wvm == null)
{
return;
}
// store in temp variable to silence binding
var temp = rootWatchViewModel.Children;
rootWatchViewModel.Children = null;
temp.Clear();
temp.Add(wvm);
// rebind
rootWatchViewModel.Children = temp;
rootWatchViewModel.CountNumberOfItems();
rootWatchViewModel.CountLevels();
rootWatchViewModel.Children[0].IsTopLevel = true;
}, syncContext);
s.ScheduleForExecution(t);
}
private void UpdateCollection()
{
// (Konrad) We pass a list of items already selected so that we can update them rather than create a new list.
var selected = View._listBox.SelectedItems;
var scheduler = DynamoViewmodel.Model.Scheduler;
var delegateBasedAsyncTask = new DelegateBasedAsyncTask(scheduler, delegate
{
ViewModel.PopulateItems(selected);
});
delegateBasedAsyncTask.ThenSend(delegate { }, SyncContext);
scheduler.ScheduleForExecution(delegateBasedAsyncTask);
}
/// <summary>
/// Call this method to schedule a DelegateBasedAsyncTask for execution.
/// </summary>
/// <param name="p">The delegate to execute on the idle thread.</param>
/// <param name="completionHandler">Event handler that will be invoked
/// when the scheduled DelegateBasedAsyncTask is completed. This parameter
/// is optional.</param>
///
internal static void ExecuteOnIdleAsync(Action p,
AsyncTaskCompletedHandler completionHandler = null)
{
var scheduler = DynamoRevit.RevitDynamoModel.Scheduler;
var task = new DelegateBasedAsyncTask(scheduler, p);
if (completionHandler != null)
{
task.Completed += completionHandler;
}
scheduler.ScheduleForExecution(task);
}
private void OnRequestScheduledTask(Action action)
{
var s = dynamoViewModel.Model.Scheduler;
var t = new DelegateBasedAsyncTask(s, () =>
{
});
t.ThenSend((_) =>
{
action();
}, syncContext);
s.ScheduleForExecution(t);
}
private void UpdateParameterSelector()
{
var scheduler = _dynamoViewmodel.Model.Scheduler;
var delegateBasedAsyncTask = new DelegateBasedAsyncTask(scheduler, delegate
{
_viewModel.PopulateItems();
});
delegateBasedAsyncTask.ThenSend(delegate
{
_viewModel.SelectedItem = _viewModel.SelectedItem ?? _viewModel.ItemsCollection.FirstOrDefault();
}, _syncContext);
scheduler.ScheduleForExecution(delegateBasedAsyncTask);
}
private void UpdateColorRange()
{
var s = dynamoViewModel.Model.Scheduler;
// prevent data race by running on scheduler
var t = new DelegateBasedAsyncTask(s, () =>
{
colorRange = colorRangeNode.ComputeColorRange(dynamoModel.EngineController);
});
// then update on the ui thread
t.ThenSend((_) =>
{
var bmp = CreateColorRangeBitmap(colorRange);
gradientImage.Source = bmp;
}, syncContext);
s.ScheduleForExecution(t);
}
private void UpdateParameterSelector()
{
DynamoScheduler scheduler = DynamoViewmodel.Model.Scheduler;
DelegateBasedAsyncTask delegateBasedAsyncTask = new DelegateBasedAsyncTask(scheduler, delegate
{
ViewModel.PopulateItems();
});
AsyncTaskExtensions.ThenSend(delegateBasedAsyncTask, delegate(AsyncTask _)
{
if (ViewModel.SelectedItem != null)
{
ViewModel.SelectedItem = ViewModel.SelectedItem;
}
else
{
ViewModel.SelectedItem = ViewModel.ItemsCollection.FirstOrDefault <ParameterWrapper>();
}
}, SyncContext);
scheduler.ScheduleForExecution(delegateBasedAsyncTask);
}
protected void AsyncSchedule(DelegateBasedAsyncTask task)
{
viewModel.Model.Scheduler.ScheduleForExecution(task);
}
protected DelegateBasedAsyncTask AsyncThenUI(DelegateBasedAsyncTask task, Action action)
{
task.ThenSend((_) => action?.BeginInvoke(action.EndInvoke, null), syncContext);
return(task);
}