public void EventCallTest(Result result)
{
MultiTask.CountDown(10, (obj) => {
result.Invoke(Fail("Time Over"));
return(MultiTask.End.TRUE);
});
}
public void TestWithNoFinishedTasks()
{
var tasks = new List <ManualTask>()
{
new ManualTask((t) => {}),
new ManualTask((t) => {}),
new ManualTask((t) => {})
};
var task = new MultiTask(tasks);
var listener = new TaskListener();
task.StartTask(listener);
Assert.AreEqual(listener, task.Listener);
Assert.AreEqual(3, task.Tasks.Count);
Assert.IsFalse(task.IsFinished);
Assert.IsTrue(task.DidRun);
Assert.AreEqual(0f, listener.TotalProgress, Delta);
Assert.IsFalse(listener.IsFinished);
tasks.ForEach(t => t.SetFinished());
Assert.IsTrue(task.IsFinished);
Assert.AreEqual(1f, listener.TotalProgress, Delta);
Assert.IsTrue(listener.IsFinished);
}
/// <summary>
/// 複数回の保存ができるか 1
/// </summary>
public void RecTest2_multi(Result result)
{
// 強制終了条件
MultiTask.CountDown(10, (obj) => {
result.Invoke(Fail("Time Over"));
return(MultiTask.End.TRUE);
});
}
/// <summary>
/// Disposes hitsound loader if exists.
/// </summary>
private void DisposeHitsoundLoader()
{
if (hitsoundLoader != null)
{
hitsoundLoader.RevokeTask(true);
}
hitsoundLoader = null;
}
public FrmMultiTaskCheck(MultiTask multiTask)
{
InitializeComponent();
//InitUI();
this.CurrentMultiTask = multiTask;
}
public void RecTest1(Result result)
{
//保存ができるか
MultiTask.CountDown(10, (obj) => {
result.Invoke(Fail("Time Over"));
return(MultiTask.End.TRUE);
});
}
public void Parse_AbnormalWordTest(Result result)
{
// { a:*, c:d }
MultiTask.CountDown(10, (obj) =>
{
result.Invoke(Fail("Time Over"));
return(MultiTask.End.TRUE);
});
}
public Task(MultiTask _owner)
{
owner = _owner;
if (owner != null)
{
owner.OnAbort += OnAbort;
}
}
//public void Parse_OnlyStringTest ( Result result ) {
// // "s"
// MultiTask.CountDown(10, ( obj ) =>
// {
// result.Invoke(Fail("Time Over"));
// return MultiTask.End.TRUE;
// });
// JsonParseData.Parse<string>("\"s\"", ( obj, ret ) =>
// {
// if (obj.GetType() != typeof(string)) {
// result.Invoke(Fail("Illefgurar type " + obj.GetType().Name));
// }
// if (obj.Length != 1) {
// result.Invoke(Fail("Illefgurar element " + obj));
// }
// if (obj != "s") {
// result.Invoke(Fail("Illefgurar element " + obj));
// }
// result.Invoke(Pass());
// });
//}
//public void Parse_OnlyArrayTest ( Result result ) {
// // [1,2,3]
// MultiTask.CountDown(10, ( obj ) =>
// {
// result.Invoke(Fail("Time Over"));
// return MultiTask.End.TRUE;
// });
// JsonParseData.Parse<Array>("[1,2,3]", ( obj, ret ) =>
// {
// if (obj.GetType().IsArray == false) {
// result.Invoke(Fail("Illefgurar type " + obj.GetType().Name));
// }
// if (obj.GetType() != typeof(String [])) {
// result.Invoke(Fail("Illefgurar type " + obj.GetType().Name));
// }
// var strs = (string []) obj;
// if (strs.Length != 3) {
// result.Invoke(Fail("Illefgurar element " + obj));
// }
// if (strs [0] != "1") {
// result.Invoke(Fail("Illefgurar element " + obj));
// }
// result.Invoke(Pass());
// });
//}
//public void Parse_OnlyObjectTest ( Result result ) {
// // {}
// MultiTask.CountDown(10, ( obj ) =>
// {
// result.Invoke(Fail("Time Over"));
// return MultiTask.End.TRUE;
// });
// JsonParseData.Parse<ObjDict>("{}", ( obj, ret ) =>
// {
// if (obj.GetType() != typeof(ObjDict)) {
// result.Invoke(Fail("Illefgurar type " + obj.GetType().Name));
// }
// if (obj.Count != 0) {
// result.Invoke(Fail("Illefgurar element " + obj.Count));
// }
// result.Invoke(Pass());
// });
//}
//public void Parse_SimpleObjectTest ( Result result ) {
// // { a:b }
// MultiTask.CountDown(10, ( obj ) =>
// {
// result.Invoke(Fail("Time Over"));
// return MultiTask.End.TRUE;
// });
// JsonParseData.Parse<ObjDict>(
// "{\"a\":\"b\"}", ( obj, ret ) =>
// {
// if (ret == false) { return; }
// if (obj.GetType() != typeof(ObjDict)) {
// result.Invoke(Fail("Illefgurar type " + obj.GetType().Name));
// }
// if (obj.Count != 1) {
// result.Invoke(Fail("Illefgurar element @count= " + obj.Count));
// }
// if (obj.ContainsKey("a") == false) {
// result.Invoke(Fail("This is not include element"));
// }
// JsonParseData.Parse<string>((string) obj ["a"], ( o, r ) =>
// {
// if (o != "b") {
// result.Invoke(Fail("Illefgurar element " + obj ["a"]));
// }
// result.Invoke(Pass());
// });
// });
//}
//public void Parse_ObjectTest_2 ( Result result ) {
// // { a:b, c:d }
// MultiTask.CountDown(10, ( obj ) =>
// {
// result.Invoke(Fail("Time Over"));
// return MultiTask.End.TRUE;
// });
// JsonParseData.Parse<ObjDict>(
// "{\"a\":\"b\",\"c\":\"d\"}"
// , ( obj, ret ) =>
// {
// JsonParseData.Parse<string>((string) obj ["a"], ( o, r ) =>
// {
// if (o == "b") { return; }
// result.Invoke(Fail("Illefgurar element " + obj ["a"]));
// });
// JsonParseData.Parse<string>((string) obj ["c"], ( o, r ) =>
// {
// if (o == "d") { return; }
// result.Invoke(Fail("Illefgurar element " + obj ["c"]));
// });
// result.Invoke(Pass());
// });
//}
//public void Parse_ArrayIncludeObjectTest ( Result result ) {
// // { a:[1,2,3], c:d }
// MultiTask.CountDown(10, ( obj ) =>
// {
// result.Invoke(Fail("Time Over"));
// return MultiTask.End.TRUE;
// });
// JsonParseData.Parse<ObjDict>(
// "{\"a\":\"b\",\"c\":\"d\"}"
// , ( obj, ret ) =>
// {
// JsonParseData.Parse<string>((string) obj ["a"], ( o, r ) =>
// {
// if (o != "[1,2,3]") { result.Invoke(Fail("Illefgurar element " + obj ["a"])); }
// JsonParseData.Parse<Array>(o, ( arr, re ) => {
// });
// });
// JsonParseData.Parse<string>((string) obj ["c"], ( o, r ) =>
// {
// if (o == "d") { return; }
// result.Invoke(Fail("Illefgurar element " + obj ["c"]));
// });
// result.Invoke(Pass());
// });
//}
public void Parse_ObjectIncludeObjectTest(Result result)
{
// { a: {c:k, t:y}, c:d }
MultiTask.CountDown(10, (obj) =>
{
result.Invoke(Fail("Time Over"));
return(MultiTask.End.TRUE);
});
}
public void TestInitialState()
{
var task = new MultiTask();
Assert.IsNull(task.Listener);
Assert.AreEqual(0, task.Tasks.Count);
Assert.IsFalse(task.IsFinished);
Assert.IsFalse(task.DidRun);
Assert.IsFalse(task.IsRevoked.Value);
}
public FindPath(MultiTask _owner) : base(_owner)
{
nodeGrid = new PathNode[GameGrid.SIZE.x, GameGrid.SIZE.y];
for (int y = 0; y < GameGrid.SIZE.y; y++)
{
for (int x = 0; x < GameGrid.SIZE.x; x++)
{
nodeGrid[x, y] = new PathNode(x, y);
}
}
}
private void LoadHomeScene(bool server)
{
MultiTask tasks = new MultiTask();
if (server == false)
{
tasks.AddTask(new JoinGameTask(m_JoinIPText.text));
}
tasks.AddTask(new AsyncLoadScene("HomeScene"));
tasks.AddTask(new DestroyObjectsOnComplete(m_DestroyOnLoad));
NetworkManager.Instance().AddTask(tasks);
}
/// <summary>
/// Disposes all loading processes.
/// </summary>
private void DisposeLoader()
{
// Cancel all game loaders.
gameLoaders.ForEach(p => p.RevokeTask(true));
gameLoaders.Clear();
// Dispose game loader
if (gameLoader != null)
{
gameLoader.RevokeTask(true);
gameLoader = null;
}
}
private async void Compare()
{
SuspendLayout();
LeftPath = cbLeftDirectory.Text;
RightPath = cbRightDirectory.Text;
treeView1.Nodes.Clear();
// Directory compare
compare = new DirectoryCompare(LeftPath, RightPath, filterExtensions);
await compare.Parse();
// create root noew
treeView1.Nodes.Add(new TreeNode($"Comparison: {LeftPath} x {RightPath}", 0, 0));
treeView1.Nodes[0].ContextMenuStrip = rootNodeMenu;
unlisted.Clear();
unlisted.UnionWith(compare.LeftFiles.Values);
unlisted.UnionWith(compare.RightFiles.Values);
// run tasks
var tasks = MultiTask.Run(new Func <TreeNode>[]
{
() => { return(AddInconsistencies(new TreeNode("Left Analysis", 1, 1), compare.DuplicateLeft, compare.RefactoredLeft, compare.EmptyFilesLeft)); },
() => { return(AddInconsistencies(new TreeNode("Right Analysis", 1, 1), compare.DuplicateRight, compare.RefactoredRight, compare.EmptyFilesRight)); },
() => { return(AddMoved()); },
() => { return(AddRenamed()); },
() => { return(AddChanged()); },
() => { return(AddRefactored()); },
() => { return(AddUnchangedFiles()); }
});
Task.WaitAll(tasks);
treeView1.BeginUpdate();
foreach (var t in tasks)
{
if (t.Result.Nodes.Count > 0)
{
treeView1.Nodes[0].Nodes.Add(t.Result);
}
}
treeView1.Nodes[0].Nodes.Add(AddUnlisted());
treeView1.EndUpdate();
processTime.Stop();
taskProgress1.Information = $"Processed in {processTime.ElapsedMilliseconds} ms";
treeView1.Nodes[0].Expand();
btStartRefresh.Enabled = true;
ResumeLayout();
var forget = Task.Run(() => { System.GC.Collect(); });
}
public void TestEmptyTasks()
{
var task = new MultiTask();
var listener = new TaskListener();
task.StartTask(listener);
Assert.AreEqual(listener, task.Listener);
Assert.AreEqual(0, task.Tasks.Count);
Assert.IsTrue(task.IsFinished);
Assert.IsTrue(task.DidRun);
Assert.AreEqual(1f, listener.TotalProgress, Delta);
Assert.IsTrue(listener.IsFinished);
}
/// <summary>
/// Initializes the game loader processes.
/// </summary>
private void InitLoader()
{
if (gameLoader != null)
{
throw new InvalidOperationException("Attempted to initialize a redundant game loader process.");
}
gameLoader = new MultiTask(gameLoaders);
gameLoader.OnFinished += () =>
{
GC.Collect();
loadState.Value = GameLoadState.Success;
};
gameLoader.StartTask();
}
static void Main(string[] args)
{
Thread.CurrentThread.Name = "main";
CustomThreads custom = new CustomThreads();
ThreadPooler pooler = new ThreadPooler();
MultiTask parrallel = new MultiTask();
Tasker tasker = new Tasker();
custom.DoWork();
Console.WriteLine("custom threader finished");
pooler.DoWork();
Console.WriteLine("pooler finished");
parrallel.DoWork();
Console.WriteLine("parrallel finished");
tasker.DoWork();
Console.WriteLine("tasker finished");
}
public ITask LoadHitsounds()
{
DisposeHitsoundLoader();
if (IsHitsoundLoaded)
{
return(new ManualTask());
}
FindHitsounds();
hitsoundLoader = new MultiTask(CreateHitsoundLoaders());
hitsoundLoader.OnFinished += () =>
{
IsHitsoundLoaded = true;
hitsoundLoader = null;
};
return(hitsoundLoader);
}
public async Task <IActionResult> GetSlidePartial(string presenter, string slug, int number)
{
var(show, slide) =
await MultiTask.WhenAll(_shows.Get(presenter, slug), _shows.GetSlide(presenter, slug, number));
if (show == null || (slide == null || !slide.HasBeenShown))
{
return(NotFound());
}
var slidePartial = new SlidePartial
{
Layout = slide.Layout,
Html = ProcessSlideHtml(slide.Html),
Title = slide.Title
};
return(Ok(slidePartial));
}
public State Perform(MultiTask _multiTask)
{
switch (currentState)
{
case Task.State.Done:
case Task.State.Abort:
case Task.State.Start:
Start(out currentState);
break;
case Task.State.Tick:
Tick(out currentState);
break;
default:
Debug.LogError(currentState + " hasn't been properly implemented yet!");
break;
}
return(currentState);
}
private TreeNode AddInconsistencies(TreeNode root, CrossCompareSet duplicates, CrossCompareSet refactored, SortedSet <FileCompareData> empty)
{
var tasks = MultiTask.Run(new Func <TreeNode>[]
{
() => { return(AddDuplicates(new TreeNode("Left Duplicates", 1, 1), duplicates)); },
() => { return(AddRefactored(new TreeNode("Left Refactored", 1, 1), refactored)); },
() => { return(AddEmpty(new TreeNode("Left Empty", 1, 1), empty)); },
});
Task.WhenAll(tasks);
foreach (var t in tasks)
{
var node = t.Result;
if (node.Nodes.Count > 0)
{
root.Nodes.Add(t.Result);
}
}
return(root);
}
public void TestWithComplexTasks()
{
var manualTask = new ManualTask((t) => { });
var multiTask = new MultiTask(new List <ITask>()
{
new ManualTask((t) => {}),
new ManualTask((t) => {})
});
var tasks = new List <ITask>()
{
manualTask,
multiTask
};
var task = new MultiTask(tasks);
var listener = new TaskListener();
task.StartTask(listener);
Assert.AreEqual(listener, task.Listener);
Assert.AreEqual(2, task.Tasks.Count);
Assert.IsFalse(task.IsFinished);
Assert.IsTrue(task.DidRun);
Assert.AreEqual(0f, listener.TotalProgress, Delta);
Assert.IsFalse(listener.IsFinished);
(multiTask.Tasks[0] as ManualTask).SetFinished();
Assert.IsFalse(task.IsFinished);
Assert.AreEqual(0.25f, listener.TotalProgress, Delta);
Assert.IsFalse(listener.IsFinished);
manualTask.SetFinished();
Assert.IsFalse(task.IsFinished);
Assert.AreEqual(0.75f, listener.TotalProgress, Delta);
Assert.IsFalse(listener.IsFinished);
(multiTask.Tasks[1] as ManualTask).SetFinished();
Assert.IsTrue(task.IsFinished);
Assert.AreEqual(1f, listener.TotalProgress, Delta);
Assert.IsTrue(listener.IsFinished);
}
private void wizardControl1_FinishClick(object sender, CancelEventArgs e)
{
DataTable tTasks = GridCheckSetting.DataSource as DataTable;
if (tTasks.Rows.Count > 0)
{
this.Hide();
MultiTask multiTask = new MultiTask();
for (int i = 0; i < tTasks.Rows.Count; i++)
{
multiTask.AddTask(this.GetTaskFromDataRow(tTasks.Rows[i]));
}
//FrmMultiTaskCheck frmCheck = new FrmMultiTaskCheck(multiTask);
//frmCheck.ExcuteMultiTask(ref m_AvailableTasks);
multiTask.CreatingTaskChanged += new TaskCreateEventsHandler(multiTask_CreatingTaskChanged);
multiTask.TaskCreated += new TaskCreateEventsHandler(multiTask_TaskCreated);
multiTask.CheckingTaskChanged += new TaskCheckEventsHandler(multiTask_CheckingTaskChanged);
multiTask.TaskChecked += new TaskCheckEventsHandler(multiTask_TaskChecked);
//m_FrmCheck.AdaptCheckerEvents(multiTask.TaskChecker);
//System.Threading.ThreadStart threadStart = delegate
//{
bool isSucceed = multiTask.Excute(ref m_AvailableTasks);
if (isSucceed)
{
XtraMessageBox.Show(multiTask.PromptMessage);
}
else
{
XtraMessageBox.Show("批量任务过程中出现错误，创建失败");
}
//};
//System.Threading.Thread thread = new System.Threading.Thread(threadStart);
//thread.Start();
}
}
public void AssignMultiTask(MultiTask _multiTask)
{
if (_multiTask == null)
{
return;
}
if (CurrentMultiTask != null)
{
if (_multiTask.Priority <= CurrentMultiTask.Priority)
{
return;
}
else
{
FinishedMultiTask(CurrentMultiTask, _wasSuccess: false);
}
}
CurrentMultiTask = _multiTask;
CurrentMultiTask.StartNextTask();
}
public async Task <IActionResult> PresenterView(string handle, string slug, CancellationToken ct)
{
var user = User.FindFirst(ShtikClaimTypes.Handle)?.Value;
if (!handle.Equals(user, StringComparison.OrdinalIgnoreCase))
{
return(NotFound());
}
var(show, questions) = await MultiTask.WhenAll(_shows.Get(user, slug, ct), _questions.GetQuestionsForShow(user, slug, ct));
if (show == null)
{
return(NotFound());
}
var viewModel = new PresenterViewModel
{
Show = show,
Questions = questions.OrderByDescending(q => q.Time).ToList()
};
return(View(viewModel));
}
public void FinishedMultiTask(MultiTask _multiTask, bool _wasSuccess)
{
if (_multiTask != CurrentMultiTask)
{
Debug.LogError(Owner.name + " somehow has multiple multitasks!");
}
if (_wasSuccess)
{
// Debug.Log((Owner.name + " successfully completed multitask!").Color(Color.green));
}
else
{
// Debug.LogWarning((Owner.name + " failed to complete multitask!").Color(Color.red));
if (_multiTask.OnAbort != null)
{
_multiTask.OnAbort();
}
}
CurrentMultiTask = null;
}
public async Task <IActionResult> ShowSlide(string presenter, string slug, int number)
{
var(show, slide) =
await MultiTask.WhenAll(_shows.Get(presenter, slug), _shows.GetSlide(presenter, slug, number));
if (show == null || (slide == null || !slide.HasBeenShown))
{
return(NotFound());
}
slide.Html = ProcessSlideHtml(slide.Html);
var viewModel = new ShowSlideViewModel
{
Presenter = presenter,
Slug = slug,
Title = show.Title,
Time = show.Time,
Place = show.Place,
Slide = slide
};
return(View(viewModel));
}
public void TestRevoke()
{
var tasks = new List <ITask>()
{
new ManualTask(),
new MultiTask(new List <ITask>()
{
new ManualTask(),
new ManualTask()
})
};
var task = new MultiTask(tasks);
task.StartTask();
Assert.IsTrue(task.IsFinished);
task.RevokeTask(true);
Assert.IsTrue(task.IsRevoked.Value);
Assert.IsTrue((tasks[0] as ManualTask).IsRevoked.Value);
Assert.IsTrue((tasks[1] as MultiTask).IsRevoked.Value);
Assert.IsTrue(((tasks[1] as MultiTask).Tasks[0] as ManualTask).IsRevoked.Value);
Assert.IsTrue(((tasks[1] as MultiTask).Tasks[1] as ManualTask).IsRevoked.Value);
}
public MoveAlongPath(MultiTask _owner) : base(_owner)
{
}
public override void UpdateDefault()
{
taskHandler.AssignMultiTask(MultiTask.TryGetIdleWalk(taskHandler));
}
