提交功能

Core/Task/Runner/FlushingOperation.cs

@@ -0,0 +1,18 @@
+namespace NBC
+{
+    /// <summary>
+    ///     操作信息类
+    /// </summary>
+    public class FlushingOperation
+    {
+        /// <summary>
+        ///     是否被终结
+        /// </summary>
+        public bool Kill;
+
+        /// <summary>
+        ///     是否暂停
+        /// </summary>
+        public bool Paused;
+    }
+}

Core/Task/Runner/Runner.cs

@@ -0,0 +1,89 @@
+using System.Collections.Generic;
+
+namespace NBC
+{
+    public class Runner : IRunner
+    {
+        /// <summary>
+        ///     当前运行的任务
+        /// </summary>
+        protected readonly List<ITask> Coroutines = new();
+
+        /// <summary>
+        ///     当前操作的信息
+        /// </summary>
+        protected readonly FlushingOperation FlushingOperation = new();
+
+        /// <summary>
+        ///     准备要运行的任务
+        /// </summary>
+        protected readonly Queue<ITask> ReadyTask = new();
+
+        public bool IsPaused
+        {
+            get => FlushingOperation.Paused;
+            set => FlushingOperation.Paused = value;
+        }
+
+        public bool IsKilled => FlushingOperation.Kill;
+        public int RunningTaskNum => Coroutines.Count;
+        public int NeedRunTaskNum => ReadyTask.Count;
+
+        public virtual void Run(ITask task)
+        {
+            ReadyTask.Enqueue(task);
+        }
+
+        public virtual void Process()
+        {
+            var count = ReadyTask.Count;
+            for (var i = 0; i < count; i++)
+            {
+                var task = ReadyTask.Dequeue();
+                Coroutines.Add(task);
+            }
+
+            if (Coroutines.Count < 1) return;
+
+            var index = 0;
+            bool mustExit;
+            do
+            {
+                var childTask = Coroutines[index];
+                var st = childTask.Process();
+                if (st >= NTaskStatus.Success)
+                    Coroutines.Remove(childTask);
+                else
+                    index++;
+
+                mustExit = Coroutines.Count == 0 || index >= Coroutines.Count;
+            } while (!mustExit);
+        }
+
+        public virtual void StopTask(ITask task)
+        {
+            var index = Coroutines.IndexOf(task);
+            if (index != -1)
+            {
+                var t = Coroutines[index];
+                t.Stop();
+                Coroutines.RemoveAt(index);
+            }
+        }
+
+        public virtual void StopAllTask()
+        {
+            ReadyTask.Clear();
+            for (var i = 0; i < Coroutines.Count; i++) Coroutines[i].Stop();
+
+            Coroutines.Clear();
+        }
+
+        public virtual void ShutDown()
+        {
+            IsPaused = false;
+            FlushingOperation.Kill = true;
+            StopAllTask();
+        }
+    }
+}

Core/Task/Runner/RunnerProcess.cs

@@ -0,0 +1,77 @@
+using System.Collections.Generic;
+
+namespace NBC
+{
+    public class RunnerProcess : IProcess
+    {
+        /// <summary>
+        ///     当前运行的任务
+        /// </summary>
+        protected readonly List<ITask> Coroutines;
+
+        /// <summary>
+        ///     当前操作的信息
+        /// </summary>
+        protected readonly FlushingOperation FlushingOperation;
+
+        /// <summary>
+        ///     准备要运行的任务
+        /// </summary>
+        protected readonly Queue<ITask> ReadyTask;
+
+        /// <summary>
+        ///     进程名称
+        /// </summary>
+        protected string Name;
+
+        public RunnerProcess(string name, List<ITask> coroutines, Queue<ITask> readyTask, FlushingOperation op)
+        {
+            Name = name;
+            Coroutines = coroutines;
+            ReadyTask = readyTask;
+            FlushingOperation = op;
+        }
+
+        public NTaskStatus Process()
+        {
+            var flag = false;
+            if (FlushingOperation.Kill)
+            {
+                flag = true;
+            }
+            else
+            {
+                for (var index = 0; index < ReadyTask.Count; index++)
+                {
+                    // var task = ReadyTask[0];
+                    var task = ReadyTask.Dequeue();
+                    Coroutines.Add(task);
+                    // ReadyTask.RemoveAt(0);
+                }
+
+                if (Coroutines.Count == 0 || FlushingOperation.Paused)
+                {
+                    flag = false;
+                }
+                else
+                {
+                    var index = 0;
+                    var mustExit = false;
+                    do
+                    {
+                        var childTask = Coroutines[index];
+                        var st = childTask.Process();
+                        if (st >= NTaskStatus.Success)
+                            Coroutines.RemoveAt(index); //.splice(index, 1);
+                        else
+                            index++;
+
+                        mustExit = Coroutines.Count == 0 || index >= Coroutines.Count;
+                    } while (!mustExit);
+                }
+            }
+
+            return flag ? NTaskStatus.Success : NTaskStatus.Running;
+        }
+    }
+}