Unity基于C#的时间管理类(TimerManager)

已于 2022-09-19 11:06:52 修改
阅读量1.7k 收藏 9
点赞数 5
文章标签： c# time unity unity3d networkmanager
于 2021-01-29 14:07:54 首次发布
原文链接：https://www.cnblogs.com/Qi-Henry/p/5242852.html
版权

做Unity也有一年多了，但项目中总没有一个方便使用的时间管理类，前段时间抽空把以前AS项目中的一个时间管理类改了一下，用了段时间，感觉还不错，分享给大家

文章目录


这是一个单例类，适合整个项目的时间管理，从此让我们摆脱MonoBehaviour.Update函数

另外，由统一管理调用的，大家可能会觉得耗性能，这只是调用委托函数，即使一次循环调用上千个空方法，都不会卡顿的，主要是看方法内部的实现，大家都知道不要在Update里写大量逻辑，这里也是一样的道理，特别是循环调用的回调，要注意代码逻辑。

先贴用法，再贴代码

方法一、定时执行一次(基于毫秒)

doOnce(int delay, Handler method)

doOnce<T1>(int delay, Handler<T1> method, params object[] args)

doOnce<T1, T2>(int delay, Handler<T1, T2> method, params object[] args)

doOnce<T1, T2, T3>(int delay, Handler<T1, T2, T3> method, params object[] args)

这是一种重载写法，如果不懂重载，就要去补一下基础了，这里不再科普

T1，T2，T3在这里出现是因为项目中有些时候可能在我执行这个Handler回调时，想接收一些参数，这样就用到了。

无参用法：

TimerManager.instance.doOnce(3000,method);　　3000毫秒后执行method

有参用法，比如有两个参数

TimerManager.instance.doOnce<GameObject,Transform>(3000,method,go,tf);　　

3000毫秒后执行method,并把go,tf传递给method

这种用法相信很多人都懂了，如果不懂可以留言给我。

下面的方法，都是一样，都有四种重载方法，我在这里就不一一贴出来了，大家可以看后面的代码。

方法二、定时重复执行(基于毫秒)

doLoop(int delay, Handler method)

方法三、定时执行一次(基于帧率)

doFrameOnce(int delay, Handler method)

方法四、定时重复执行(基于帧率)

doFrameLoop(int delay, Handler method)

方法五、清理定时器

clearTimer(Handler method)

定时执行一次：只会执行一次，执行完成后会自动调用clearTimer

定时重复执行：会重复调用method回调，直到程序主动调用clearTimer

基于毫秒：以毫秒为间隔调用method

基于帧率：以帧速来调用，假设传1，1帧执行一次，传2，2帧执行一次

这是一个管理类，需要有调用方法，那么我们需要调用他

我们每个项目中肯定有一个永远存在的继承自MonoBehaviour的类，在Update中写上：

foreach(IAnimatable animatable in TimerManager.timerList) {
　　animatable.AdvanceTime();
}

接下来贴代码

用于方便写单例的基类

先贴继承类，这是一个用于方便写单例的基类

public abstract class PureSingleton<T> where T : new() {
    private static T _instance;
    public static T instance{
        get{
            if(_instance == null){
                _instance = new T();
            }
            return _instance;
        }
    }
}

正类 TimerManager

这是正类 TimerManager

using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
 
public delegate void Handler();
public delegate void Handler<T1>(T1 param1);
public delegate void Handler<T1, T2>(T1 param1, T2 param2);
public delegate void Handler<T1, T2, T3>(T1 param1, T2 param2, T3 param3);
 
public interface IAnimatable {
     void AdvanceTime();
}

/**时钟管理器[同一函数多次计时，默认会被后者覆盖,delay小于1会立即执行]*/
public class TimerManager:PureSingleton<TimerManager>, IAnimatable {
{
    public static List<IAnimatable> timerList = new List<IAnimatable>();

    public TimerManager()
    {
        timerList.Add(this);
    }

    private List<TimerHandler> _pool = new List<TimerHandler>();
    /** 用数组保证按放入顺序执行*/
    private List<TimerHandler> _handlers = new List<TimerHandler>();
    private int _currFrame = 0;
    private uint _index = 0;
    public void AdvanceTime()
    {
        _currFrame++;
        for (int i = 0; i < _handlers.Count; i++)
        {
            TimerHandler handler = _handlers[i];
            long t = handler.userFrame ? _currFrame : currentTime;
            if (t >= handler.exeTime)
            {
                Delegate method = handler.method;
                object[] args = handler.args;
                if (handler.repeat)
                {
                    while (t >= handler.exeTime)
                    {
                        handler.exeTime += handler.delay;
                        method.DynamicInvoke(args);
                    }
                }
                else
                {
                    clear(handler.method);
                    method.DynamicInvoke(args);
                }
            }
        }
    }
    private object create(bool useFrame, bool repeat, int delay, Delegate method, params object[] args)
    {
        if (method == null)
        {
            return null;
        }

        //如果执行时间小于1，直接执行
        if (delay < 1)
        {
            method.DynamicInvoke(args);
            return -1;
        }
        TimerHandler handler;
        if (_pool.Count > 0)
        {
            handler = _pool[_pool.Count - 1];
            _pool.Remove(handler);
        }
        else
        {
            handler = new TimerHandler();
        }
        handler.userFrame = useFrame;
        handler.repeat = repeat;
        handler.delay = delay;
        handler.method = method;
        handler.args = args;
        handler.exeTime = delay + (useFrame ? _currFrame : currentTime);
        _handlers.Add(handler);
        return method;
    }

    /// /// <summary>
    /// 定时执行一次(基于毫秒)
    /// </summary>
    /// <param name="delay">延迟时间(单位毫秒)</param>
    /// <param name="method">结束时的回调方法</param>
    /// <param name="args">回调参数</param>
    public void doOnce(int delay, Handler method)
    {
        create(false, false, delay, method);
    }
    public void doOnce<T1>(int delay, Handler<T1> method, params object[] args)
    {
        create(false, false, delay, method, args);
    }
    public void doOnce<T1, T2>(int delay, Handler<T1, T2> method, params object[] args)
    {
        create(false, false, delay, method, args);
    }
    public void doOnce<T1, T2, T3>(int delay, Handler<T1, T2, T3> method, params object[] args)
    {
        create(false, false, delay, method, args);
    }

    /// /// <summary>
    /// 定时重复执行(基于毫秒)
    /// </summary>
    /// <param name="delay">延迟时间(单位毫秒)</param>
    /// <param name="method">结束时的回调方法</param>
    /// <param name="args">回调参数</param>
    public void doLoop(int delay, Handler method)
    {
        create(false, true, delay, method);
    }
    public void doLoop<T1>(int delay, Handler<T1> method, params object[] args)
    {
        create(false, true, delay, method, args);
    }
    public void doLoop<T1, T2>(int delay, Handler<T1, T2> method, params object[] args)
    {
        create(false, true, delay, method, args);
    }
    public void doLoop<T1, T2, T3>(int delay, Handler<T1, T2, T3> method, params object[] args)
    {
        create(false, true, delay, method, args);
    }


    /// <summary>
    /// 定时执行一次(基于帧率)
    /// </summary>
    /// <param name="delay">延迟时间(单位为帧)</param>
    /// <param name="method">结束时的回调方法</param>
    /// <param name="args">回调参数</param>
    public void doFrameOnce(int delay, Handler method)
    {
        create(true, false, delay, method);
    }
    public void doFrameOnce<T1>(int delay, Handler<T1> method, params object[] args)
    {
        create(true, false, delay, method, args);
    }
    public void doFrameOnce<T1, T2>(int delay, Handler<T1, T2> method, params object[] args)
    {
        create(true, false, delay, method, args);
    }
    public void doFrameOnce<T1, T2, T3>(int delay, Handler<T1, T2, T3> method, params object[] args)
    {
        create(true, false, delay, method, args);
    }

    /// <summary>
    /// 定时重复执行(基于帧率)
    /// </summary>
    /// <param name="delay">延迟时间(单位为帧)</param>
    /// <param name="method">结束时的回调方法</param>
    /// <param name="args">回调参数</param>
    public void doFrameLoop(int delay, Handler method)
    {
        create(true, true, delay, method);
    }
    public void doFrameLoop<T1>(int delay, Handler<T1> method, params object[] args)
    {
        create(true, true, delay, method, args);
    }
    public void doFrameLoop<T1, T2>(int delay, Handler<T1, T2> method, params object[] args)
    {
        create(true, true, delay, method, args);
    }
    public void doFrameLoop<T1, T2, T3>(int delay, Handler<T1, T2, T3> method, params object[] args)
    {
        create(true, true, delay, method, args);
    }

    /// <summary>
    /// 清理定时器
    /// </summary>
    /// <param name="method">method为回调函数本身</param>
    public void clearTimer(Handler method)
    {
        clear(method);
    }
    public void clearTimer<T1>(Handler<T1> method)
    {
        clear(method);
    }
    public void clearTimer<T1, T2>(Handler<T1, T2> method)
    {
        clear(method);
    }
    public void clearTimer<T1, T2, T3>(Handler<T1, T2, T3> method)
    {
        clear(method);
    }

    private void clear(Delegate method)
    {
        TimerHandler handler = _handlers.FirstOrDefault(t => t.method == method);
        if (handler != null)
        {
            _handlers.Remove(handler);
            handler.clear();
            _pool.Add(handler);
        }
    }

    /// <summary>
    /// 清理所有定时器
    /// </summary>
    public void clearAllTimer()
    {
        foreach (TimerHandler handler in _handlers)
        {
            clear(handler.method);
            clearAllTimer();
            return;
        }
    }

    public static void RemoveTimerMgr(TimerManager timerMgr)
    {
        timerList.Remove(timerMgr);
    }

    /// <summary>
    /// 游戏自启动运行时间，毫秒
    /// </summary>
    public long currentTime
    {
        get { return (long)(Time.time * 1000); }
    }

    /**定时处理器*/

    private class TimerHandler
    {
        /**执行间隔*/
        public int delay;
        /**是否重复执行*/
        public bool repeat;
        /**是否用帧率*/
        public bool userFrame;

        /**执行时间*/
        public long exeTime;

        /**处理方法*/
        public Delegate method;

        /**参数*/
        public object[] args;

        /**清理*/

        public void clear()
        {
            method = null;
            args = null;
        }
    }
}

大家如果觉得好，多给我回复一下，刷刷人气

转载于:https://www.cnblogs.com/Qi-Henry/p/5242852.html

天宇u3d
关注
  • 5
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Unity中简单定时器TimeManager
duanzhiyong666的博客
04-27 2199
看到项目中有TimeManager一个类，用来创建一个time，优点是可以随时创建一个Update，包括多久后执行，执行多少次等等，摆脱Mono中的Update的不便之处。 下面贴上代码： public enum Z_TimerType {     FRAME,     TIMER, } ...
Unity 时间管理工具
cjc52294的博客
05-24 848
之前写了一个计时器，用一个单例 TimeManager 中的一个存储委托的字典，在Update反复执行实现，调用方法注册实现，倒计时为0时调用委托，同时从字典中移除，注销没有想到好方法，凑合着先用。 这两天需要一个技能流程配置，我的技能可能会有冲刺后攻击，也可能只有冲刺，也可能只有攻击。如果分别在对象上写 if 各自管理流程，代码排版看着很难受，需要加很多标记变量。所以在 TimeManager 中新建一个存储委托的列表的字典，也是在 Update 中反复执行，调用方法注册...
【HSJFramework】Unity时间管理TimeManger计时器
纯技术流日常开发商业开发记录总结等
04-24 1739
每当我们需要定义新的计时器的时候就生成新的计时器并添加进表里，实时去判断当前计时器是否结束并维护这个list。
Unity定时（延迟）管理器实现
最新发布
lcy的博客
06-21 528
Unity中实现定时功能的方法有很多，比如协程、UpdateInvokeAsync等，可以说是五花八门，对于这类实现方法多、需求频繁的功能还是需要一个管理器来统一处理。
Unity 计时器管理类
司军礼的博客
08-30 1204
计时器管理类 开发原因 在项目开发阶段有很多的计时器需求，包括游戏时间计时，验证码时间计时等。如果没有一个计时器管理类，将会非常混乱，为了更好的管理计时器，封装了一个计时器管理类 功能代码解释 TimerMoudle 管理一个计时器，TimerMoudle对外公开的函数及字段如下： 函数 解释 Play(bool restart=false) 运行计时器（restart表示是否重新开始计时，默认为false继续计时） Pause() 暂停计时器 Stop() 停止计时器 Cl
【Unity Epitome】TimerManager：计时任务管理器
承续缘
06-12 2887
1、Timer timer = new Timer(); 创建时间管理器 参数(float time, TimeUnit timeUnit,bool ignoreTimeScale = false, bool autoStart = true)time:时间值、timeUnit 时间单位（帧率、秒、厘秒、毫秒）、ignoreTimeScale 忽略时间缩放（可以使游戏暂停更容易实现）、autoS...
Unity基于C#的时间管理类(TimeHelper)
weixin_43896851的博客
09-21 895
一个非常值得参考的时间管理类，非常详细的归纳了一些游戏开发中常用的使用方法，可以直接使用或按照自己的需求或想法重新封装，我在多个项目经常使用，如果大家有自己的想法欢迎在评论区分享出来，大家一起学习共同进步。
Unity时间管理器
TinyStar
08-25 546
http://www.omuying.com/article/128.aspx
基于C#的Unity AssetBundle可视化管理插件设计源码
05-27
本设计源码提供了一个基于C#的Unity AssetBundle可视化管理插件，包含445个文件，其中包括135个meta文件，132个md文档，95个cs源文件，58张jpeg图片，12张jpg图片，8张png图片，2个asmdef文件，以及1个gitignore文件...
C#开发基于Unity的角色扮演类音乐游戏源码.zip
09-27
C#开发基于Unity的角色扮演类音乐游戏源码.zipC#开发基于Unity的角色扮演类音乐游戏源码.zipC#开发基于Unity的角色扮演类音乐游戏源码.zipC#开发基于Unity的角色扮演类音乐游戏源码.zipC#开发基于Unity的角色扮演类...
UnityTimer
03-02
这个工具经过多次项目的战斗测试和改进，可以在Unity3D中进行延迟执行操作
基于Unity和C#的《HeroBorn》游戏开发
10-24
HeroBorn 是一个基于 Unity 和 C# 的游戏开发项目，旨在创建一个具有挑战性的游戏体验。游戏的主要组件包括： * 场景设计：设计游戏的场景，包括地面、围墙、炮塔、平台等。 * 角色设计：设计游戏的角色，包括移动...
基于Unity C# 参考源代码全套无偿分享
05-31
在这个“基于Unity C#参考源代码全套无偿分享”中，你将获得一系列深入理解Unity游戏开发核心概念的宝贵资源。 首先，我们要了解C#在Unity中的应用。C#是一种现代化的面向对象编程语言，Unity引擎将其作为主要的...
基于C#和Unity的迷宫自动生成源码.zip
08-09
基于C#和Unity的迷宫自动生成源码 基于C#和Unity的迷宫自动生成源码 基于C#和Unity的迷宫自动生成源码 【项目介绍】 该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 本项目适合...
Unity架构之路-小试牛刀-3-TimerManager
MrLeoLi的博客
11-03 759
时间管理类// Made by LCX. Feel free to contact with us at ant time.Thanks // QQ: 594721121 // ReSharper disable CheckNamespace using System; using System.Collections.Generic; using UnityEngine; namespace M
Unity开发--单机游戏中的时间管理(附带: Editor模式停止运行游戏调用OnApplicationQuit)
lcl20093466的博客
12-09 807
Unity时间管理(附带: Editor模式停止运行游戏调用OnApplicationQuit)
Unity-TimerMgr
Jave.Lin 的学习笔记
12-05 311
以前在开发页游的时候，自己造过很多轮子：TimerMgr 也是其一 现在用 Unity 做开发，也少不了这个功能，所以再次造了个轮子 制作这个功能目的在于，部分场景可替代使用 Unity Coroutine，或是 async/await Task.Delay，因为这两种方式都有 GC 问题 但是 TimerMgr<T>的泛型回调也有 GC 这个是 C#.NET 的问题，但是具体使用消耗最低，可以查看 Git 中的 TimerMgr.cs 的注释说明 运行效果 C# 应用层代码示例 usin
TimerManager
顶级游戏设计大师
04-04 1154
TimerManager
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值