Unity3D 协程管理

Unity里面的协程好用，但总是在如何关闭指定协程，尤其是关闭带参数的协程的问题上困惑不已。
在本文，笔者带你用最简单的方式（2个方案）管理这些运行中的协程，做到点对点关闭，即便是带参数协程，也能点对点关闭。

思路：

1. 要每一个协程都在开启后能再次拿到，并且具备辨识度，就需要缓存引用并为其配特定名称（key），构成 一个 KeyValuePair ，一个个 KeyValuePair 的集合不就是字典？
2. 所以想要管理协程，做好他们的增删改查，这儿引入 Dictionary 保存协程 Coroutine 的引用 或者 干脆保存这个迭代器 IEnumerator ，如果想要关闭指定的协程，只需从字典里面拿到这些个引用，然后使用 StopCoroutine API 即可。
3. 如果字典里面存的是 迭代器 IEnumerator , 那样似乎更加棒棒，嗯还可以 抽取指定协程 使用 StartCoroutine API 开启。

方案一：

执行 StartCoroutine，将返回这个协同程序 Coroutine 的引用，将这个引用存到字典，需要的时候直接StopCoroutine(这个引用);

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

public class TestIEnumlator01 : MonoBehaviour {
    //方案一，执行 StartCoroutine，将返回 Coroutine 引用，需要的时候直接 StopCoroutine(这个引用);
    Dictionary CoroutineDic = new Dictionary();
      //消息输出字典，用于Debug
    Dictionary MessageDic = new Dictionary() {
        { "a", "Test04" },
        { "s", "Test05" },
        { "d", "Test06" }
    };
    void Start () {
        //模拟运行协程
        CoroutineDic.Add("a", StartCoroutine(Test04()));
        CoroutineDic.Add("s", StartCoroutine(Test05(1f)));
        CoroutineDic.Add("d", StartCoroutine(Test06("测试", 1f)));
    }

    private void Update()
    {
        if (Input.anyKeyDown)
        {
            string name = Input.inputString;
            if (CoroutineDic.ContainsKey(name))
            {
                StopCoroutine(CoroutineDic[name]);
                CoroutineDic.Remove(name);
                Debug.Log(string.Format("我按下了{0}键，字典还有{1}个对象，注意看协程{2}还有输出不？", name, CoroutineDic.Count, MessageDic[name]));
            }
        }
    }
    //以下协程均为测试用，为了便于观察，均为死循环且定时均为1秒
    IEnumerator Test04()//不带参数协程
    {
        while (true)
        {
            yield return new WaitForSeconds(1f);
            Debug.Log("我是Test04:"+Time.realtimeSinceStartup);
        }
    }
    IEnumerator Test05(float _DelayTime)//带一个参数的协程
    {
        while (true)
        {
            yield return new WaitForSeconds(_DelayTime);
            Debug.Log("我是Test05:" + Time.realtimeSinceStartup);
        }
    }
    IEnumerator Test06(string msg,float delayTime)//带两个参数的协程
    {
        while (true)
        {
            yield return new WaitForSeconds(delayTime);
            Debug.Log("我是Test06:"+ Time.realtimeSinceStartup + "传入字符串为:" + msg);
        }
    }
}

方案二：

将迭代器 IEnumerator（表象是存的这个协程方法名）先添加到字典，给它指定一个特定的名字, 想拿到指定的迭代器 IEnumerator，不就是 Dictionary.TryGetValue 么，有了迭代器的在手， 就可以随意开启 / 关闭 指定的协程啦;

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

public class TestIEnumlator02 : MonoBehaviour {
    //方案二，声明字典，缓存迭代器，制作映射表。
    Dictionary IEnumeratorDic = new Dictionary();
    //消息输出字典，用于Debug
    Dictionary MessageDic = new Dictionary() {
        { "q", "Test01" },
        { "w", "Test02" },
        { "e", "Test03" }
    };
    void Start () {
        //添加协程引用，并为其配置一个键 Key，方便后续增删改查的操作
        IEnumeratorDic.Add("q",Test01());
        IEnumeratorDic.Add("w",Test02(1f));
        IEnumeratorDic.Add("e",Test03("测试",1f));
        //依次执行这些协程
        foreach (var item in IEnumeratorDic)
        {
            StartCoroutine(item.Value);
        }
    }

    private void Update()
    {
        if (Input.anyKeyDown)
        {
            string name=Input.inputString;
            if (IEnumeratorDic.ContainsKey(name))
            {
                StopCoroutine(IEnumeratorDic[name]);
                IEnumeratorDic.Remove(name);
                Debug.Log(string.Format("我按下了{0}键，字典还有{1}个对象，注意看协程{2}还有输出不？", name, IEnumeratorDic.Count,MessageDic[name]));
            }
        }
    }

    //以下协程均为测试用，为了便于观察，均为死循环且定时均为1秒
    IEnumerator Test01()//不带参数协程
    {
        while (true)
        {
            yield return new WaitForSeconds(1f);
            Debug.Log("我是Test01:" + Time.realtimeSinceStartup);
        }
    }
    IEnumerator Test02(float _DelayTime)//带一个参数的协程
    {
        while (true)
        {
            yield return new WaitForSeconds(_DelayTime);
            Debug.Log("我是Test02:" + Time.realtimeSinceStartup);
        }
    }
    IEnumerator Test03(string msg, float delayTime)//带两个参数的协程
    {
        while (true)
        {
            yield return new WaitForSeconds(delayTime);
            Debug.Log("我是Test03:" + Time.realtimeSinceStartup + "传入字符串为:" + msg);
        }
    }
}

动画：

效果演示

总结：

原来，协程也可以这么好用的，想执行谁，想停止谁，不管你带没带参数，都可以单独停止，单独启动。
想想，以前为了关闭一个带参数的协程，不得不执行 StopAllCoroutines()也是醉了；
引入 Dictionary 等数据结构，为这些协程指定一个有意义的key， 增删改查手到擒来，取用起来也就更方便啦！
嗯，多研读API，有更多惊喜~

小知识：

1. 如果一个类里面协程有多个重载，且均只有一个参数，可以用如下的API启动。

StartCoroutine("FuncName",1);
StartCoroutine("FuncName","参数");
StartCoroutine("FuncName",gameObject);

2. 像tips1那样使用字符串来开启协程，有一个好处：就是使用StopCoroutine("FuncName")能够停止所有的运行在这个实例上的有着这个方法名的协程。

3. 相应的，用StartCoroutine(FuncName(1))这样开启的协程，不管有无参数，StopCoroutine("FuncName")都是不凑效的。

4. 将Coroutine所在的脚本设为enable = false并不能够将Coroutine停止，因为它跟Monobehavior是同层级的。

5. 启动一个协程时缓存他Coroutine类型的返回值是一个很好的习惯，这样在启动这个协程前判null就能保证这个协程不被多次加载，形如：

private Coroutine cor=null;
private void Start()
 {
    if(cor==null)
    {
        cor=StartCoroutine(TestFunc);
    }else
     {
      Debug.Log("协程运行中");
    }
 }

6. 苦恼协程没有返回值 ，ref / out 也不行？ 给个 Action 或者 Func 做参数就很巴适~ 我的这篇文字：Unity3D IEnumerator 做一个通用的定时器 就是这个理念了。

扩展阅读

基于协程的TaskManager
协程管理CoroutineManager - 笔者整理的

标签：unity 3d，IEnumerator 协程，StartCoroutine，StopCoroutine关闭协程，关闭指定协程，关闭指定的带参数协程