任务队列(Unity,C#)

目录

1.作用

2.自动往下执行的任务队列

3.手动执行下一步骤的任务列表

---

1.作用

让任务按顺序执行，适用于任务步骤有先后执行顺序的地方

2.自动往下执行的任务队列

Task类：

using System;
using System.Collections;
using System.Collections.Generic;

public class Task 
{
    //任务名
    private string m_TaskName;
    public string TaskName
    {
        set
        {
            m_TaskName = value;
        }
        get
        {
            return m_TaskName;
        }
    }

    //任务具体内容，外部传入
    public Action Work;

    public Task(Action work, string taskName = "defaultTaskName")
    {
        this.Work = work;
        this.m_TaskName = taskName;
    }
}

TaskQueue类：

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class TaskQueue 
{
    //构造函数
    public TaskQueue()
    {
        m_TaskQueue = new Queue<Task>();
        m_TasksNum = 0;
    }

    //1、添加任务
    public void AddTask(Task task)
    {
        m_TaskQueue.Enqueue(task);
    }

    public void AddTask(Action work)
    {
        Task task = new Task(work);
        m_TaskQueue.Enqueue(task);
    }
    
    //2、开始任务
    public void Start()
    {
        //获取任务队列的总任务数
        m_TasksNum = m_TaskQueue.Count;

        if (OnStart != null)
        {
            OnStart();
        }
        NextTask();
    }

    //3、清空任务
    public void Clear()
    {
        m_TaskQueue.Clear();
        m_TasksNum = 0;
    }

    //4、开始任务回调
    public Action OnStart = null;

    //5、完成所有任务回调
    public Action OnFinish = null;

    //6、下一个任务
    private void NextTask()
    {
        if (m_TaskQueue.Count > 0)
        {
            Task task = m_TaskQueue.Dequeue();
            task.Work();
            NextTask();
        }
        else
        {
            if (OnFinish != null)
            {
                OnFinish();
            }
        }
    }

    //7、当前任务进度
    public float TaskProcess
    {
        get
        {
            return 1 - m_TaskQueue.Count * 1.0f / m_TasksNum;
        }
    }
    
    //8、任务队列总任务量
    private int m_TasksNum = 0;

    //9、任务队列
    private Queue<Task> m_TaskQueue;
}

测试：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Test : MonoBehaviour 
{
	void Start () 
	{
        TaskQueue taskQueue = new TaskQueue();
        taskQueue.OnStart = () => { Debug.Log("OnStart"); };
        taskQueue.OnFinish = () => { Debug.Log("OnFinish"); };
        taskQueue.AddTask(Task1);
        taskQueue.AddTask(Task2);
        taskQueue.Start();
	}

    private void Task1()
    {
        Debug.Log("Task1");
    }

    private void Task2()
    {
        Debug.Log("Task2");
    }
}

3.手动执行下一步骤的任务列表

public class TaskSequence
    {
        //任务序列完成回调
        public Action onFinish;
        //任务步骤列表
        private List<TaskProcedure> taskList;
        //是否已经取消任务
        private bool isCancel = false;

        public TaskSequence()
        {
            taskList = new List<TaskProcedure>();
        }

        public TaskSequence(Action onFinish)
        {
            taskList = new List<TaskProcedure>();
            this.onFinish = onFinish;
        }

        #region 添加任务
        public TaskSequence Add(Action<TaskProcedure> taskFunc)
        {
            TaskProcedure task = new TaskProcedure();
            task.taskSequence = this;
            task.onTaskFunc = taskFunc;
            taskList.Add(task);
            return this;
        }

        public TaskSequence Add(bool result, Action<TaskProcedure> trueTaskFunc)
        {
            if (!result) return this;
            return Add(trueTaskFunc);
        }

        public TaskSequence Add(bool result, Action<TaskProcedure> trueTaskFunc, Action<TaskProcedure> falseTaskFunc)
        {
            if (result)
            {
                return Add(trueTaskFunc);
            }
            else
            {
                return Add(falseTaskFunc);
            }
        }

        public TaskSequence Add(float delayTime, Action<TaskProcedure> taskFunc)
        {
            TaskProcedure task = new TaskProcedure();
            task.taskSequence = this;
            task.onTaskFunc = (taskParam) =>
            {
                TimerUtil.Simple.AddTimer(delayTime, () =>
                {
                    taskFunc(task);
                });
            };
            taskList.Add(task);
            return this;
        }
        #endregion

        #region 添加延迟时间
        public TaskSequence AddDelay(float delayTime)
        {
            TaskProcedure task = new TaskProcedure();
            task.taskSequence = this;
            task.onTaskFunc = (taskParam) =>
            {
                TimerUtil.Simple.AddTimer(delayTime, () =>
                {
                    if (task.onComplete != null)
                    {
                        task.onComplete();
                    }
                });
            };
            taskList.Add(task);
            return this;
        }
        #endregion

        #region 运行
        public TaskSequence Run(float delayTime)
        {
            TimerUtil.Simple.AddTimer(delayTime, () => Run());
            return this;
        }

        public TaskSequence Run()
        {
            if (isCancel)
                return null;
            for (int i = 0; i < taskList.Count - 1; i++)
            {
                int index = i;
                int nextIndex = index + 1;
                taskList[index].onComplete = () => taskList[nextIndex].onTaskFunc(taskList[nextIndex]);
            }

            if (taskList.Count > 0)
            {
                taskList[taskList.Count - 1].onComplete = onFinish;
                taskList[0].onTaskFunc(taskList[0]);
            }
            return this;
        }
        #endregion

        public TaskSequence Clear()
        {
            onFinish = null;
            foreach (TaskProcedure task in taskList)
            {
                task.Dispose();
            }
            taskList.Clear();
            return this;
        }

        public TaskSequence Cancel()
        {
            isCancel = true;
            Clear();
            return this;
        }
    }

    /// <summary>
    /// 任务步骤
    /// </summary>
    public class TaskProcedure
    {
        //任务步骤对应的任务
        public TaskSequence taskSequence;
        //任务步骤具体内容
        public Action<TaskProcedure> onTaskFunc;
        //该步骤完成回调
        public Action onComplete;

        public void InvokeComplete()
        {
            if (onComplete != null)
            {
                onComplete();
            }
        }

        public void DelayInvokeComplete(float delayTime)
        {
            TimerUtil.Simple.AddTimer(delayTime, InvokeComplete);
        }

        public void Dispose()
        {
            taskSequence = null;
            onTaskFunc = null;
            onComplete = null;
        }
    }

测试：

 void Start()
    {
        TaskSequence seq = new TaskSequence(OnStart,OnFinish);

        seq.Add(task =>
        {
            Debug.Log("步骤一");
            task.onComplete();
        });

        seq.Add(task =>
        {
            Debug.Log("步骤二");
            task.onComplete();
        });

        seq.Add(task =>
        {
            Debug.Log("步骤三");
            task.onComplete();
        });

        seq.Run();
    }