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