public async Task OnCompleted_NotCompletedTest()
{
TaskObserver observer = TaskObserver.Create(Task.Run(() => { }), GetLogger());
observer.OnCompleted();
bool completedTransition = await observer.TaskStatusCompletedTransition;
Assert.IsFalse(completedTransition);
}
public void TestTaskObserverCreate()
{
Assert.Throws <ArgumentNullException>(() => new TaskObserver(null));
TaskObserver observer = new TaskObserver(TaskType.Prepare, "description", false);
Assert.AreSame(TaskType.Prepare, observer.Type);
Assert.AreEqual("description", observer.Description);
Assert.IsFalse(observer.Exposed);
}
public async Task OnCompleted_CompletedTest()
{
Task taskToObserve = Task.Run(() => { Task.Delay(2000).Wait(); });
TaskObserver observer = TaskObserver.Create(taskToObserve, GetLogger());
observer.OnNext(taskToObserve);
observer.OnCompleted();
bool completedTransition = await observer.TaskStatusCompletedTransition;
Assert.IsTrue(completedTransition);
}
public IObserver <Task> GetRequiredObserverByTask(Task task)
{
IObserver <Task> observerTask;
try
{
observerTask = observers.First <IObserver <Task> >(
observer => Object.ReferenceEquals(((TaskObserver)observer).ObservableTask, task));
}catch (System.InvalidOperationException)
{
logger.Debug(string.Format("Task {0} was not registered", task.Id));
observerTask = TaskObserver.Create(task, logger);
((TaskObserver)observerTask).Subscribe(this);
}
return(observerTask);
}
public void SubscribeTest()
{
List <Task> tasks = new List <Task>();
Task task = Task.Run(() => { });
tasks.Add(task);
TasksProvider provider = TasksProvider.Create(new List <Task>(), GetLogger());
provider.AddTask(task);
TaskObserver observer = TaskObserver.Create(task, GetLogger());
observer.OnNext(task);
IDisposable unsubscriber = provider.Subscribe(observer);
Assert.IsTrue(provider.Subscribe(observer) is IDisposable);
}
public async Task <bool> ObserversCompletation()
{
List <Task> potentiallyFinishedTasks = new List <Task>();
foreach (IObserver <Task> observer in observers)
{
TaskObserver taskObserver = (TaskObserver)observer;
await taskObserver.TaskStatusCompletedTransition;
potentiallyFinishedTasks.Add(taskObserver.ObservableTask);
taskObserver.OnCompleted();
}
foreach (Task task in potentiallyFinishedTasks)
{
OnTaskFinished(task);
}
return(true);
}
private void AddTask(Task task)
{
TaskObserver observableTask = TaskObserver.Create(task, logger);
observableTask.Subscribe(tasksProvider);
}
public TaskObserver getTaskObserver(Model.task_info _task_info, List <string> _gun_position_info_id, Subject sub)
{
taskObserver = new TaskObserver(_task_info, _gun_position_info_id, sub);
return(taskObserver);
}
public TaskObserver getTaskObserver(Model.task_info _task_info, List<string> _gun_position_info_id, Subject sub)
{
taskObserver = new TaskObserver(_task_info,_gun_position_info_id, sub);
return taskObserver;
}
/// <summary>
/// 移除观察者
/// </summary>
/// <param name="observer"></param>
public void Detach(TaskObserver observer)
{
observers.Remove(observer);
}
/// <summary>
/// 增加观察者
/// </summary>
/// <param name="observer"></param>
public void Attach(TaskObserver observer)
{
observers.Add(observer);
}
public void TasksObserverCreateTest()
{
Assert.IsTrue(TaskObserver.Create(Task.Run(() => { }), GetLogger()) is IObserver <Task>);
}
/// <summary>
/// 订阅
/// </summary>
/// <param name="onResult">收到结果委托</param>
/// <param name="onError">遇到错误委托</param>
/// <exception cref="ArgumentNullException"></exception>
/// <returns></returns>
public IDisposable Subscribe(Action <TResult> onResult, Action <Exception> onError)
{
var observer = new TaskObserver <TResult>(onResult, onError, null);
return(this.Subscribe(observer));
}
