协程管理工具

这个工具是本人基于TaskManager改动来的
通过两个脚本来对协程进行管理
1.TaskManager
这个脚本主要用来控制Task，包括添加，开启，获取Task的状态等等，只需要输入Task对应的名称，即可进行相关的操作

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices.WindowsRuntime;
using UnityEngine;

public class TaskManager : SingletonMono<TaskManager> {
	/// <summary>
	/// 存放当前所有的Task
	/// </summary>
	private Dictionary<string, Task> task_Dic=new Dictionary<string, Task>();
	/// <summary>
	/// 创建Task
	/// </summary>
	/// <param name="name"></param>
	/// <param name="enumerator"></param>
	public bool CreateTask(string name,IEnumerator enumerator,bool AutoStart=false)
	{
		if (task_Dic.ContainsKey(name))
		{
			Debug.LogWarning("存在重复的Task");
			return false;
		}
		Task newTask = new Task(enumerator);
		task_Dic.Add(name, newTask);
		if (AutoStart)
		{
			StartTask(name);
		}
		return true;
	}
	/// <summary>
	/// 创建延迟调用的Task
	/// </summary>
	public bool CreateDelayTask(string name, IEnumerator enumerator,float delayTime, bool AutoStart = false)
	{
		if (task_Dic.ContainsKey(name))
		{
			Debug.LogWarning("存在重复的Task");
			return false;
		}
		Task newTask = new Task(enumerator,delayTime);
		task_Dic.Add(name, newTask);
		if (AutoStart)
		{
			StartTask(name);
		}
		return true;
	}
	/// <summary>
	/// 开启某个Task
	/// </summary>
	/// <param name="taskName"></param>
	public void StartTask(string taskName)
	{
		task_Dic[taskName].TaskStart();
		task_Dic[taskName].TaskCor=StartCoroutine(task_Dic[taskName].CallWrapper());
	}
	/// <summary>
	/// 关闭某个Task
	/// </summary>
	/// <param name="taskName"></param>
	public void StopTask(string taskName)
	{
		if (task_Dic[taskName].TaskCor!=null)
		{
			StopCoroutine(task_Dic[taskName].TaskCor);
			task_Dic[taskName].TaskCor = null;
		}
		
	}
	/// <summary>
	/// 暂停某个Task
	/// </summary>
	/// <param name="taskName"></param>
	public void PausedTask(string taskName)
	{
		task_Dic[taskName].TaskPaused();
	}
	/// <summary>
	/// 继续某个Task
	/// </summary>
	/// <param name="taskName"></param>
	public void UnpausedTask(string taskName)
	{
		task_Dic[taskName].TaskUnpaused();
	}
	/// <summary>
	/// 清理已经执行完毕的task
	/// </summary>
	public void ClearStopTask()
	{
		foreach (var item in task_Dic)
		{
			if (item.Value.Running==false)
			{
				StopTask(item.Key);
			}
		}
	}
	/// <summary>
	/// 通过名称获取某个Task
	/// </summary>
	/// <param name="name"></param>
	/// <returns></returns>
	public Task TaskSearch(string name)
	{
		Task task = null;
		if (task_Dic.ContainsKey(name))
		{
			task = task_Dic[name];
		}
		return task;
	}
}

2.Task
用来管理协程的具体执行流程

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

public class Task {

	private bool _paused;
	private bool _running;
	/// <summary>
	/// 是否暂停
	/// </summary>
	public bool Paused
	{
		get
		{
			return _paused;
		}
	}
	/// <summary>
	/// 是否正在运行
	/// </summary>
	public bool Running
	{
		get
		{
			return _running;
		}
	}
	/// <summary>
	/// 延迟执行的时间
	/// </summary>
	private float _delayTime;
	private IEnumerator _enumerator;
	public Coroutine TaskCor;
	public Task(IEnumerator enumerator)
	{
		_enumerator = enumerator;
	}
	public Task(IEnumerator enumerator, float delayTime)
	{
		_enumerator = enumerator;
		_delayTime = delayTime;
	}
	public IEnumerator CallWrapper()
	{
		yield return new WaitForSeconds(_delayTime);
		IEnumerator e = _enumerator;
		while (_running)
		{
			if (_paused)
				yield return null;
			else
			{
				if (e != null && e.MoveNext())
				{
					yield return e.Current;
				}
				else
				{
					_running = false;
					
				}
			}
		}
	}
	
	public void TaskPaused()
	{
		_paused = true;
	}
	public void TaskUnpaused()
	{
		_paused = false;
	}
	public void TaskStart()
	{
		_running = true;
	}
	
}

注： 第一个TaskManager里面继承的SingletonMono就是一个单例
附上单例的代码

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
/// <summary>
/// 继承mono的单例类
/// </summary>
/// <typeparam name="T">T用来指明类</typeparam>
public class SingletonMono<T> : MonoBehaviour where T : SingletonMono<T> 
{

	private static T instance;

	public static T Instance
	{
		get
		{
			if (instance==null)
			{
				//看是否已经创建了该物体
				T _instance = FindObjectOfType<T>();
				if (_instance==null)
				{
					GameObject go = new GameObject(typeof(T).Name);
					instance = go.AddComponent<T>();
					DontDestroyOnLoad(go);
				}
				else
				{
					instance = _instance;
				}
			}
			return instance;
		}
	}
}

这个方法有个问题 就是协程不能二次开启 暂时没有找到解决的方法