用C# 模拟实现unity里的协程

注：需要了解C#的迭代器，不然很难理解。

之前面试有被问到unity协程的原理，以及撇开unity用纯C#去实现协程的方法。后来了解一下，确实可以的。趁这会有空，稍微总结一下。

还是结合代码说事吧：

/// <summary>
/// 等待接口
/// </summary>
public interface IWait
{
    /// <summary>
    /// 每帧检测是否等待结束
    /// </summary>
    /// <returns></returns>
    bool Tick();
}

先定义一个等待接口，WaitForSeconds 和 WaitForFrames 实现接口的Tick()方法，每一帧调用Tick()方法检测是否等待结束

 

/// <summary>
/// 按秒等待
/// </summary>
public class WaitForSeconds:IWait
{
    float _seconds = 0f;

    public WaitForSeconds(float seconds)
    {
        _seconds = seconds;
    }

    public bool Tick()
    {
        _seconds -= Time.deltaTime;
        return _seconds <= 0;
    }
}

/// <summary>
/// 按帧等待
/// </summary>
public class WaitForFrames:IWait
{
    private int _frames = 0;
    public WaitForFrames(int frames)
    {
        _frames = frames;
    }

    public bool Tick()
    {
        _frames -= 1;
        return _frames <= 0;
    }
}

定义 WaitForSeconds 和 WaitForFrames ，在构造函数初始化需要等待的时间/帧数

 

 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

public class CoroutineManager
{
    private static CoroutineManager _instance = null;
    public static CoroutineManager Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new CoroutineManager();
            }
            return _instance;
        }
    }

    private LinkedList<IEnumerator> coroutineList = new LinkedList<IEnumerator>();

    public void StartCoroutine(IEnumerator ie)
    {
        coroutineList.AddLast(ie);
    }

    public void StopCoroutine(IEnumerator ie)
    {
        try
        {
            coroutineList.Remove(ie);
        }
        catch (Exception e) { Console.WriteLine(e.ToString()); }
    }

    public void UpdateCoroutine()
    {
        var node = coroutineList.First;
        while (node != null)
        {
            IEnumerator ie = node.Value;
            bool ret = true;
            if (ie.Current is IWait)
            {
                IWait wait = (IWait)ie.Current;
                //检测等待条件，条件满足，跳到迭代器的下一元素 （IEnumerator方法里的下一个yield）
                if (wait.Tick())
                {
                    ret = ie.MoveNext();
                }
            }
            else
            {
                ret = ie.MoveNext();
            }
            //迭代器没有下一个元素了，删除迭代器（IEnumerator方法执行结束）
            if (!ret)
            {
                coroutineList.Remove(node);
            }
            //下一个迭代器
            node = node.Next;
        }
    }
}

这一段代码是这里最重要的部分。这里用一个链表记录了添加的所有“协程”，并在UpdateCoroutine()方法的每一次执行都去遍历这些“协程”以及检测等待是否结束。

 

public class Time
{
    //每帧时间(秒)
    public static float deltaTime
    { get { return (float)deltaMilliseconds / 1000; } }
    //每帧时间（毫秒）
    public static int deltaMilliseconds
    { get { return 20; }}
}

模拟一帧的时间。

 

运用测试：

public class Program
{
    static void Main(string[] args)
    {
        var t1 = Test01();
        var t2 = Test02();
        CoroutineManager.Instance.StartCoroutine(t1);
        CoroutineManager.Instance.StartCoroutine(t2);

        while (true)// 模拟update
        {
            Thread.Sleep(Time.deltaMilliseconds);
            CoroutineManager.Instance.UpdateCoroutine();
        }
    }


    static IEnumerator Test01()
    {
        Console.WriteLine("start test 01");
        yield return new WaitForSeconds(5);
        Console.WriteLine("after 5 seconds");
        yield return new WaitForSeconds(5);
        Console.WriteLine("after 10 seconds");
    }

    static IEnumerator Test02()
    {
        Console.WriteLine("start test 02");
        yield return new WaitForFrames(500);
        Console.WriteLine("after 500 frames");
    }
}

测试结果：

用秒表掐了 一下，好像没什么毛病。