Unity implements delayed callback tool

A practical timer that can time delay calls and delay repetition calls.

You can encapsulate it into a singleton mode and hang it on the GameObject for use, or execute the OnUpdate() method of this class in the Update of another behavior and then use it.

For safer use, it is recommended to clean up all corresponding timers when destroying MonoBehaviour.

Or when calling, you can choose to pass the MonoBehaviour where the incoming callback is located, so that it can be cleaned up automatically.

using ;
using System;
using ;
using UnityEngine;

public static class DelayCall
{

    private static List&lt;CallTimeObj&gt; calltimes = new List&lt;CallTimeObj&gt;();
    private static Dictionary&lt;int, CallObj&gt; callsort = new Dictionary&lt;int, CallObj&gt;();
    private static int countid = 0;
    /// &lt;summary&gt;
    /// Generate id    /// &lt;/summary&gt;
    /// &lt;returns&gt;The new identifier.&lt;/returns&gt;
    /// &lt;param name="call"&gt;Call.&lt;/param&gt;
    private static int getNewId(CallObj call)
    {
        countid++;
        if (countid &gt;= )
        {
            countid = 1;
        }
        while ((countid)) countid++;
         = countid;
        (countid, call);
        return countid;

    }
    public static void ClearAll()
    {

        ();
        ();
    }
    /// &lt;summary&gt;
    /// Delete delayed execution.    /// &lt;/summary&gt;
    /// &lt;param name='call'&gt;
    /// Call.
    /// &lt;/param&gt;
    public static void remove(int callid)
    {
        if (callid &gt; 0 &amp;&amp; (callid))
        {
            CallObj call = callsort[callid];
            (callid);
            if (call != null)
            {
                ((CallTimeObj)call);
            }
        }

    }

    public static int AddTime(float delayTime, object arg, int repeat = 1，Action&lt;object&gt; call)
    {
        var callobj = new CallTimeObj();
         = call;
         = arg;
         = repeat;
         =  + delayTime;
         = delayTime;
        if (repeat == 0)
        {
             = true;
        }
        (callobj);
        getNewId(callobj);
        return ;

    }

    /// &lt;summary&gt;
    /// Add delayed execution    /// &lt;/summary&gt;
    /// <param name="call">Callback method</param>    /// <param name="delayTime">Delay time</param>    /// <param name="repeat">Repeat callbacks</param>    /// <param name="mn">Judgement on whether the instance that bears the function back exists</param>    /// <param name="isUnique">Is it the only way</param>    /// <param name="isReplace">If duplicate does it overwrite</param>    /// &lt;returns&gt;&lt;/returns&gt;
    public static int AddTime(float delayTime, int repeat = 1, MonoBehaviour mn = null, bool isUnique = false, bool isReplace = false，Action call)
    {
        if (isUnique)
        {
            for (int i = 0; i &lt; ; i++)
            {
                CallTimeObj call2 = calltimes[i];
                if ( == mn &amp;&amp;  == call)
                {
                    if (isReplace)
                    {
                         =  + delayTime;

                    }
                    return ;
                }
            }
        }

        var callobj = new CallTimeObj();
         = call;
         = (mn != null);
         = mn;
         = repeat;
         =  + delayTime;
         = delayTime;
        if (repeat == 0)
        {
             = true;
        }
        (callobj);
        getNewId(callobj);
        return ;
    }


    public static void OnUpdate()
    {

        //time call
        if ( != 0) for (int i = 0; i &lt; ; ++i)
            {
                CallTimeObj call = calltimes[i];
                if ( &lt;= )
                {
                    if ( == false)
                    {
                        --;
                        if ( &lt;= 0)
                        {
                            (i);
                            ();
                            --i;
                        }
                        else
                        {
                            //Re-accumulate time                             += ;

                        }
                    }
                    else
                    {
                         += ;
                    }

                    if (! ||  != null)
                    {
                        try
                        {
                            if ( != null)
                            {
                                ();
                                if ( == false)
                                {
                                    if ( &lt;= 0)
                                    {
                                         = null;
                                         = null;
                                         = null;
                                    }
                                }
                            }
                            else
                            {
                                ();
                            }
                        }
                        catch (Exception e)
                        {
                            (e);
                        }
                    }
                }
            }

    }
    private class CallObj
    {
        public Action call = null;
        public int frame;
        public bool isMN;
        public MonoBehaviour mn;
        public int callid = 0;
    }
    private class CallTimeObj : CallObj
    {
        public Action&lt;object&gt; argsCall = null;
        public float time;
        public int repeat = 1;
        public float delayTime = 0;
        public object arg;
        public bool isloop = false;
    }
}

The above is all the content of this article. I hope it will be helpful to everyone's study and I hope everyone will support me more.