Unity延时调用管理器不使用协程

效果如下

怎么调用

Debug.Log("<color=#ffff00>Hello world</color>");

DelayCallMgr.Call(() => 
    {
		Debug.Log("<color=#00ff00>延时2秒调用</color>");
	}, 2);

DelayCallMgr.cs代码

// DelayCallMgr.cs
using UnityEngine;
using System.Collections;
using System.Collections.Generic;


public class DelayCallMgr : MonoBehavIoUr
{
    MonoBhvSimTimer normalTimer = new MonoBhvSimTimer();
    MonoBhvSimTimer unscaledTimer = new MonoBhvSimTimer();

    private static DelayCallMgr s_instance = null;
    private static DelayCallMgr GetInstance()
    {
        if (s_instance == null)
        {
            GameObject obj = new GameObject("DelayCallMgr");
            s_instance = obj.AddComponent<DelayCallMgr>();
        }
        return s_instance;
    }

    /// <summary>
    /// 延时调用函数
    /// </summary>
    /// <param name="tag">标签，可用于取消延时调用</param>
    /// <param name="func">要调用的函数</param>
    /// <param name="delayTime">延时的时间，注 小于或等于0时会直接调用，如果想在下一帧调用，就写一个很小的并大于0的时间</param>
    /// <param name="isScaledTime"></param>
    public static void Call(string tag, System.Action func, float delayTime, bool isScaledTime)
    {
        if (func == null)
        {
            return;
        }

        if (delayTime <= 0)
        {
            func();
            return;
        }

        DelayCallMgr instance = GetInstance();
        instance.enabled = true;
        if (isScaledTime)
        {
            instance.normalTimer.Invoke(tag, func, delayTime);
        }
        else
        {
            instance.unscaledTimer.Invoke(tag, delayTime);
        }
    }

    public static void Call(System.Action func, bool isScaledTime)
    {
        Call(null, delayTime, isScaledTime);
    }

    public static void Call(System.Action func, float delayTime)
    {
        Call(func, true);
    }


    public static void Cancel(string tag)
    {
        DelayCallMgr instance = GetInstance();
        instance.normalTimer.RemoveAll(tag);
        instance.unscaledTimer.RemoveAll(tag);
    }

    public static void Clear()
    {
        DelayCallMgr instance = GetInstance();
        instance.normalTimer.Clear();
        instance.unscaledTimer.Clear();
        instance.enabled = false;
    }

    void Update()
    {
        normalTimer.Update(Time.deltaTime);
        unscaledTimer.Update(Time.unscaledDeltaTime);
        if (normalTimer.count <= 0 && unscaledTimer.count <= 0)
        {
            enabled = false;
        }
    }
}



public class MonoBhvSimTimer
{
    class TimerData
    {
        public string tag;
        public float time;
        public System.Action cb;
    }
    private List<TimerData> m_list = new List<TimerData>();
    private float m_dt = 0;


    public int count { get { return m_list.Count; } }

    public void Invoke(System.Action cb, float time)
    {
        Invoke(null, cb, time);
    }

    public void Invoke(string tag, System.Action cb, float time)
    {
        if (cb == null)
            return;
        m_list.Add(new TimerData() { tag = tag, cb = cb, time = time });
    }

    public void RemoveAll(string tag)
    {
        m_list.RemoveAll(data => data.tag == tag);
    }

    public void Clear()
    {
        m_list.Clear();
    }

    public void Update(float dt)
    {
        int dataCount = m_list.Count;
        m_dt = dt;
        if (dataCount > 0)
        {
            TimerData data = null;
            for (int i = dataCount - 1; i >= 0; i--)
            {
                data = m_list[i];
                UpdateData(data);
                if (data.time < 0)
                {
                    m_list.RemoveAt(i);
                }
            }
        }
    }

    void UpdateData(TimerData td)
    {
        td.time -= m_dt;
        if (td.time <= 0)
        {
            if (td.cb != null)
            {
                td.cb();
            }
        }
    }

    static bool RemoveDataCdt(TimerData td)
    {
        return td.time < 0;
    }
}