public async void CheckCancel() { var t = new ObservableTask(token => Task.Delay(100000, token)); //await Task.Delay(50); Assert.PropertyChanged(t, nameof(t.IsCanceled), () => t.CancelCommand.Cancel()); }
private void Window_Loaded(object sender, RoutedEventArgs e) { // Constructor is too early for setting these properties. // The live sorting/grouping/filtering feature is a very expensive one so be careful to activate it only if needed // and only the one you actually need. It may be a good idea too to de-activate it when it’s no more needed. computersDataGrid.Items.IsLiveFiltering = true; foreach (string propertie in ObservableHost.GetLiveFilteringProperties()) { computersDataGrid.Items.LiveFilteringProperties.Add(propertie); } projectsDataGrid.Items.IsLiveFiltering = true; foreach (string propertie in ObservableProject.GetLiveFilteringProperties()) { projectsDataGrid.Items.LiveFilteringProperties.Add(propertie); } tasksDataGrid.Items.IsLiveFiltering = true; foreach (string propertie in ObservableTask.GetLiveFilteringProperties()) { tasksDataGrid.Items.LiveFilteringProperties.Add(propertie); } transfersDataGrid.Items.IsLiveFiltering = true; foreach (string propertie in ObservableTransfer.GetLiveFilteringProperties()) { transfersDataGrid.Items.LiveFilteringProperties.Add(propertie); } }
public async Task WhenTheTaskwasCompletedThenTheOnTaskCompletedCallbackWasInvokedWithExpectedParameter() { var expectedTaskResult = new List <string>() { "Iniesta", "Costa", "Pique" }; List <string> actualCallbackInputParameter = null; Task <List <string> > someTask = Task.Factory.StartNew(() => { Thread.Sleep(TimeSpan.FromMilliseconds(500)); return(new List <string>() { "Iniesta", "Costa", "Pique" }); }); ObservableTask <List <string> > observableTask = new ObservableTask <List <string> >( someTask, this.tracerMock.Object, (param) => { actualCallbackInputParameter = param; }); await Task.Delay(TimeSpan.FromSeconds(1)); Assert.IsFalse(observableTask.IsRunning); CollectionAssert.AreEqual(expectedTaskResult, observableTask.Result); CollectionAssert.AreEqual(expectedTaskResult, actualCallbackInputParameter); }
public async void CreateObservableTask() { var t = new ObservableTask <string>(Task.Run(() => "something")); await t.Task; Assert.NotNull(t); Assert.NotNull(t.Task); Assert.NotNull(t.Task); }
public AsyncCommand(Func <object, Task> execute, Func <object, bool> canExecute) { if (execute != null) { _obvservableTask = new ObservableTask(execute); _obvservableTask.Register(this); } _canExecute = canExecute; }
public AsyncCommand(Func <object, Task> execute, Func <object, bool> canExecute) { if (execute == null) { throw new ArgumentNullException(nameof(execute)); } _observableTask = new ObservableTask(execute); _observableTask.Register(this); _canExecute = canExecute; }
public void WhenCreatingAnObservableTaskForTaskThatWasAlreadyCompletedThenItIsInitializedCorrectly() { var expectedResult = new List <string>() { "Iniesta", "Costa", "Pique" }; ObservableTask <List <string> > observableTask = new ObservableTask <List <string> >(Task.FromResult(expectedResult), this.tracerMock.Object); Assert.IsFalse(observableTask.IsRunning); CollectionAssert.AreEqual(expectedResult, observableTask.Result); }
protected override async Task ExecuteAsync(object parameter = null) { IsExecuting = true; Execution = new ObservableTask(execute?.Invoke(CancellationToken)); RaiseCanExecuteChanged(); await Execution.TaskObserver; IsExecuting = false; RaiseCanExecuteChanged(); await base.ExecuteAsync(parameter); }
internal static ObservableTask <ImageSource> ConvertCore(ImageMoniker moniker, double logicalWidth, double logicalHeight, Color background, bool grayscale, Color biasColor, bool highContrast, double dpi, double scaleFactor) { var num = dpi / DpiHelper.Default.LogicalDpiX * scaleFactor; var size = new Size { Width = logicalWidth * num, Height = logicalHeight * num }; var attributes = new ImageAttributes { DeviceSize = new Int16Size(size), Background = background == Colors.Transparent ? new Color?() : background, Grayscale = grayscale, GrayscaleBiasColor = biasColor, HighContrast = highContrast }; return(ObservableTask <ImageSource> .FromResult(ImageLibrary.Instance.GetImage(moniker, attributes))); }
private async Task <ASSET_DIC> LoadAssets(ILoader <object> loading, List <string> resources) { async Task <Tuple <string, AssetRef> > LoadFunc(string path) { var go = await MVP.Framework.Resource.instance.LoadAsync(path, BuildOption(loading)); return(Tuple.Create(path, go)); }; var tasks = new List <IObservable <Tuple <string, AssetRef> > >(); tasks = resources.Aggregate(tasks, (data, it) => { data.Add(ObservableTask.Create(LoadFunc(it))); return(data); }); var results = await tasks.WhenAll(); return(results.ToDictionary(tuple => tuple.Item1, tuple => tuple.Item2)); }
private async Task <Tuple <ASSET_DIC, AsyncOperation> > Load(ILoader <object> loading, List <string> resources) { async Task <Tuple <string, object> > LoadAssetsFunc() { var result = await LoadAssets(loading, resources); return(Tuple.Create("assets", result as object)); }; async Task <Tuple <string, object> > LoadSceneFunc() { var result = await Scene.instance.Load(this.name, BuildOption(loading)); return(Tuple.Create("scene", result as object)); }; var tasks = new List <IObservable <Tuple <string, object> > >(); tasks.Add(ObservableTask.Create(LoadAssetsFunc())); tasks.Add(ObservableTask.Create(LoadSceneFunc())); var loaders = await tasks.WhenAll(); ASSET_DIC assetDic = null; AsyncOperation asyncOperation = null; foreach (var loader in loaders) { if (loader.Item1.Equals("assets")) { assetDic = loader.Item2 as ASSET_DIC; } if (loader.Item1.Equals("scene")) { asyncOperation = loader.Item2 as AsyncOperation; } } return(Tuple.Create(assetDic, asyncOperation)); }
private async Task UpdateTasks(HostState hostState) { await hostState.BoincState.UpdateResults(); if (!_useObservableCollections) { return; } foreach (var rpcResult in hostState.BoincState.Results) { ObservableTask task = Tasks.FirstOrDefault(m => m.HostId == hostState.Id && m.Workunit == rpcResult.WorkunitName); if (task == null) { task = new ObservableTask(hostState, rpcResult); if (string.IsNullOrEmpty(SearchString)) { Tasks.Add(task); } else { foreach (var content in task.GetContentsForFiltering()) { if (content != null && content.IndexOf(SearchString, StringComparison.InvariantCultureIgnoreCase) != -1) { // The search string is found in any of the Models's property Tasks.Add(task); break; } } } } else { task.Update(hostState, rpcResult); } } }
public async Task WhenCreatingAnObservableTaskForTaskThatWasNotCompletedYetThenItIsInitializedCorrectly() { var expectedResult = new List <string>() { "Iniesta", "Costa", "Pique" }; Task <List <string> > someTask = Task.Factory.StartNew(() => { Thread.Sleep(TimeSpan.FromMilliseconds(500)); return(new List <string>() { "Iniesta", "Costa", "Pique" }); }); ObservableTask <List <string> > observableTask = new ObservableTask <List <string> >(someTask, this.tracerMock.Object); await Task.Delay(TimeSpan.FromSeconds(1)); Assert.IsFalse(observableTask.IsRunning); CollectionAssert.AreEqual(expectedResult, observableTask.Result); }
public TaskDetailViewModel(ObservableTask task) { Title = task.Application; Task = task; }
public MailFolder(IMailFolder folder, MailAccount account) { _sourceFolder = SafetyChecker.RequireArgumentNonNull(folder, "folder"); _account = SafetyChecker.RequireArgumentNonNull(account, "account"); SubFoldersTask = new ObservableTask <ObservableCollection <MailFolder> >(GetSubFolders()); }
public MailAccount(string email, ImapService service) { Email = email; _service = SafetyChecker.RequireArgumentNonNull(service, "service"); FoldersTask = new ObservableTask <ObservableCollection <MailFolder> >(GetFolders()); }
public async void CheckIsSuccessfullyCompletedPropertyChanged() { var t = new ObservableTask(token => Task.Delay(50, token)); await Assert.PropertyChangedAsync(t, nameof(t.IsSuccessfullyCompleted), () => t.TaskCompletion); }
public async void CheckStatusPropertyChanged() { var t = new ObservableTask(token => Task.Delay(50, token)); await Assert.PropertyChangedAsync(t, nameof(t.Status), () => t.TaskCompletion); }
public async void CheckResult() { var t = new ObservableTask <string>(Task.Run(() => "something")); Assert.Equal("something", await t.Task); }
public AsyncCommandEventArgs(ObservableTask task, object parameter) : base(parameter) => Task = task;
public AsyncCommandEventArgs(ObservableTask <TResult> task, object parameter) : base(parameter) { Result = task.Result; Task = task; }