devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity：基于C#的定时回调系统(可用于客户端和服务端)_unity c#定时返回数据

作者：小丑西瓜9 | 2024-02-18 13:31:44

赞

踩

unity c#定时返回数据

本文是学习Siki学院Plane老师的《定时回调系统技术专题》视频课程的学习笔记和总结

实现功能

  1. 支持时间定时，帧定时
  2. 支持任务可循环，可取消，可替换
  3. 使用简单，调用方便

思路：

  • 如何扩展定时任务：将时间计时转为帧数计时
  • 如何扩展取消/替换定时任务：生成唯一id,通过id索引操作任务
  • 如何扩展循环定时任务：通过任务计数运算
  • 如何扩展时间单位支持：统一换算为最小的毫秒运算
  • 如何支持多线程定时任务：通过临时列表进行缓存，错开操作时间；避免使用锁，提升操作效率
  • 如何实现基础定时任务：通过Update()来检测任务条件

 需要注意的问题：

  • 多线程中的线程数据安全问题

 核心代码：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Timers;
  4.  
  5. public class PETimer {
  6.     private Action<string> taskLog;
  7.     private Action<Action<int>, int> taskHandle;
  8.     private static readonly string lockTid = "lockTid";
  9.     private DateTime startDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0);
  10.     private double nowTime;
  11.     private Timer srvTimer;
  12.     private int tid;
  13.     private List<int> tidLst = new List<int>();
  14.     private List<int> recTidLst = new List<int>();
  15.  
  16.     private static readonly string lockTime = "lockTime";
  17.     private List<PETimeTask> tmpTimeLst = new List<PETimeTask>();
  18.     private List<PETimeTask> taskTimeLst = new List<PETimeTask>();
  19.     private List<int> tmpDelTimeLst = new List<int>();
  20.  
  21.     private int frameCounter;
  22.  
  23.     private static readonly string lockFrame = "lockFrame";
  24.     private List<PEFrameTask> tmpFrameLst = new List<PEFrameTask>();
  25.     private List<PEFrameTask> taskFrameLst = new List<PEFrameTask>();
  26.     private List<int> tmpDelFrameLst = new List<int>();
  27.  
  28.     public PETimer(int interval = 0) {
  29.         tidLst.Clear();
  30.         recTidLst.Clear();
  31.  
  32.         tmpTimeLst.Clear();
  33.         taskTimeLst.Clear();
  34.  
  35.         tmpFrameLst.Clear();
  36.         taskFrameLst.Clear();
  37.  
  38.         if (interval != 0) {
  39.             srvTimer = new Timer(interval) {
  40.                 AutoReset = true
  41.             };
  42.  
  43.             srvTimer.Elapsed += (object sender, ElapsedEventArgs args) => {
  44.                 Update();
  45.             };
  46.             srvTimer.Start();
  47.         }
  48.     }
  49.  
  50.     public void Update() {
  51.         CheckTimeTask();
  52.         CheckFrameTask();
  53.  
  54.         DelTimeTask();
  55.         DelFrameTask();
  56.  
  57.         if (recTidLst.Count > 0) {
  58.             lock (lockTid) {
  59.                 RecycleTid();
  60.             }
  61.         }
  62.     }
  63.     private void DelTimeTask() {
  64.         if (tmpDelTimeLst.Count > 0) {
  65.             lock (lockTime) {
  66.                 for (int i = 0; i < tmpDelTimeLst.Count; i++) {
  67.                     bool isDel = false;
  68.                     int delTid = tmpDelTimeLst[i];
  69.                     for (int j = 0; j < taskTimeLst.Count; j++) {
  70.                         PETimeTask task = taskTimeLst[j];
  71.                         if (task.tid == delTid) {
  72.                             isDel = true;
  73.                             taskTimeLst.RemoveAt(j);
  74.                             recTidLst.Add(delTid);
  75.                             //LogInfo("Del taskTimeLst ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
  76.                             break;
  77.                         }
  78.                     }
  79.  
  80.                     if (isDel)
  81.                         continue;
  82.  
  83.                     for (int j = 0; j < tmpTimeLst.Count; j++) {
  84.                         PETimeTask task = tmpTimeLst[j];
  85.                         if (task.tid == delTid) {
  86.                             tmpTimeLst.RemoveAt(j);
  87.                             recTidLst.Add(delTid);
  88.                             //LogInfo("Del tmpTimeLst ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
  89.                             break;
  90.                         }
  91.                     }
  92.                 }
  93.             }
  94.         }
  95.     }
  96.     private void DelFrameTask() {
  97.         if (tmpDelFrameLst.Count > 0) {
  98.             lock (lockFrame) {
  99.                 for (int i = 0; i < tmpDelFrameLst.Count; i++) {
  100.                     bool isDel = false;
  101.                     int delTid = tmpDelFrameLst[i];
  102.                     for (int j = 0; j < taskFrameLst.Count; j++) {
  103.                         PEFrameTask task = taskFrameLst[j];
  104.                         if (task.tid == delTid) {
  105.                             isDel = true;
  106.                             taskFrameLst.RemoveAt(j);
  107.                             recTidLst.Add(delTid);
  108.                             break;
  109.                         }
  110.                     }
  111.  
  112.                     if (isDel)
  113.                         continue;
  114.  
  115.                     for (int j = 0; j < tmpFrameLst.Count; j++) {
  116.                         PEFrameTask task = tmpFrameLst[j];
  117.                         if (task.tid == delTid) {
  118.                             tmpFrameLst.RemoveAt(j);
  119.                             recTidLst.Add(delTid);
  120.                             break;
  121.                         }
  122.                     }
  123.                 }
  124.             }
  125.         }
  126.     }
  127.     private void CheckTimeTask() {
  128.         if (tmpTimeLst.Count > 0) {
  129.             lock (lockTime) {
  130.                 //加入缓存区中的定时任务
  131.                 for (int tmpIndex = 0; tmpIndex < tmpTimeLst.Count; tmpIndex++) {
  132.                     taskTimeLst.Add(tmpTimeLst[tmpIndex]);
  133.                 }
  134.                 tmpTimeLst.Clear();
  135.             }
  136.         }
  137.  
  138.         //遍历检测任务是否达到条件
  139.         nowTime = GetUTCMilliseconds();
  140.         for (int index = 0; index < taskTimeLst.Count; index++) {
  141.             PETimeTask task = taskTimeLst[index];
  142.             if (nowTime.CompareTo(task.destTime) < 0) {
  143.                 continue;
  144.             }
  145.             else {
  146.                 Action<int> cb = task.callback;
  147.                 try {
  148.                     if (taskHandle != null) {
  149.                         taskHandle(cb, task.tid);
  150.                     }
  151.                     else {
  152.                         if (cb != null) {
  153.                             cb(task.tid);
  154.                         }
  155.                     }
  156.                 }
  157.                 catch (Exception e) {
  158.                     LogInfo(e.ToString());
  159.                 }
  160.  
  161.                 //移除已经完成的任务
  162.                 if (task.count == 1) {
  163.                     taskTimeLst.RemoveAt(index);
  164.                     index--;
  165.                     recTidLst.Add(task.tid);
  166.                 }
  167.                 else {
  168.                     if (task.count != 0) {
  169.                         task.count -= 1;
  170.                     }
  171.                     task.destTime += task.delay;
  172.                 }
  173.             }
  174.         }
  175.     }
  176.     private void CheckFrameTask() {
  177.         if (tmpFrameLst.Count > 0) {
  178.             lock (lockFrame) {
  179.                 //加入缓存区中的定时任务
  180.                 for (int tmpIndex = 0; tmpIndex < tmpFrameLst.Count; tmpIndex++) {
  181.                     taskFrameLst.Add(tmpFrameLst[tmpIndex]);
  182.                 }
  183.                 tmpFrameLst.Clear();
  184.             }
  185.         }
  186.  
  187.         frameCounter += 1;
  188.         //遍历检测任务是否达到条件
  189.         for (int index = 0; index < taskFrameLst.Count; index++) {
  190.             PEFrameTask task = taskFrameLst[index];
  191.             if (frameCounter < task.destFrame) {
  192.                 continue;
  193.             }
  194.             else {
  195.                 Action<int> cb = task.callback;
  196.                 try {
  197.                     if (taskHandle != null) {
  198.                         taskHandle(cb, task.tid);
  199.                     }
  200.                     else {
  201.                         if (cb != null) {
  202.                             cb(task.tid);
  203.                         }
  204.                     }
  205.                 }
  206.                 catch (Exception e) {
  207.                     LogInfo(e.ToString());
  208.                 }
  209.  
  210.                 //移除已经完成的任务
  211.                 if (task.count == 1) {
  212.                     taskFrameLst.RemoveAt(index);
  213.                     index--;
  214.                     recTidLst.Add(task.tid);
  215.                 }
  216.                 else {
  217.                     if (task.count != 0) {
  218.                         task.count -= 1;
  219.                     }
  220.                     task.destFrame += task.delay;
  221.                 }
  222.             }
  223.         }
  224.     }
  225.  
  226.     #region TimeTask
  227.     public int AddTimeTask(Action<int> callback, double delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1) {
  228.         if (timeUnit != PETimeUnit.Millisecond) {
  229.             switch (timeUnit) {
  230.                 case PETimeUnit.Second:
  231.                     delay = delay * 1000;
  232.                     break;
  233.                 case PETimeUnit.Minute:
  234.                     delay = delay * 1000 * 60;
  235.                     break;
  236.                 case PETimeUnit.Hour:
  237.                     delay = delay * 1000 * 60 * 60;
  238.                     break;
  239.                 case PETimeUnit.Day:
  240.                     delay = delay * 1000 * 60 * 60 * 24;
  241.                     break;
  242.                 default:
  243.                     LogInfo("Add Task TimeUnit Type Error...");
  244.                     break;
  245.             }
  246.         }
  247.         int tid = GetTid(); ;
  248.         nowTime = GetUTCMilliseconds();
  249.         lock (lockTime) {
  250.             tmpTimeLst.Add(new PETimeTask(tid, callback, nowTime + delay, delay, count));
  251.         }
  252.         return tid;
  253.     }
  254.     public void DeleteTimeTask(int tid) {
  255.         lock (lockTime) {
  256.             tmpDelTimeLst.Add(tid);
  257.             //LogInfo("TmpDel ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
  258.         }
  259.         /*
  260.          bool exist = false;
  262.          for (int i = 0; i < taskTimeLst.Count; i++) {
  263.              PETimeTask task = taskTimeLst[i];
  264.              if (task.tid == tid) {
  265.                  //taskTimeLst.RemoveAt(i);
  266.                  for (int j = 0; j < tidLst.Count; j++) {
  267.                      if (tidLst[j] == tid) {
  268.                          //tidLst.RemoveAt(j);
  269.                          break;
  270.                      }
  271.                  }
  272.                  exist = true;
  273.                  break;
  274.              }
  275.          }
  277.          if (!exist) {
  278.              for (int i = 0; i < tmpTimeLst.Count; i++) {
  279.                  PETimeTask task = tmpTimeLst[i];
  280.                  if (task.tid == tid) {
  281.                      //tmpTimeLst.RemoveAt(i);
  282.                      for (int j = 0; j < tidLst.Count; j++) {
  283.                          if (tidLst[j] == tid) {
  284.                              //tidLst.RemoveAt(j);
  285.                              break;
  286.                          }
  287.                      }
  288.                      exist = true;
  289.                      break;
  290.                  }
  291.              }
  292.          }
  294.          return exist;
  295.          */
  296.     }
  297.     public bool ReplaceTimeTask(int tid, Action<int> callback, float delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1) {
  298.         if (timeUnit != PETimeUnit.Millisecond) {
  299.             switch (timeUnit) {
  300.                 case PETimeUnit.Second:
  301.                     delay = delay * 1000;
  302.                     break;
  303.                 case PETimeUnit.Minute:
  304.                     delay = delay * 1000 * 60;
  305.                     break;
  306.                 case PETimeUnit.Hour:
  307.                     delay = delay * 1000 * 60 * 60;
  308.                     break;
  309.                 case PETimeUnit.Day:
  310.                     delay = delay * 1000 * 60 * 60 * 24;
  311.                     break;
  312.                 default:
  313.                     LogInfo("Replace Task TimeUnit Type Error...");
  314.                     break;
  315.             }
  316.         }
  317.         nowTime = GetUTCMilliseconds();
  318.         PETimeTask newTask = new PETimeTask(tid, callback, nowTime + delay, delay, count);
  319.  
  320.         bool isRep = false;
  321.         for (int i = 0; i < taskTimeLst.Count; i++) {
  322.             if (taskTimeLst[i].tid == tid) {
  323.                 taskTimeLst[i] = newTask;
  324.                 isRep = true;
  325.                 break;
  326.             }
  327.         }
  328.  
  329.         if (!isRep) {
  330.             for (int i = 0; i < tmpTimeLst.Count; i++) {
  331.                 if (tmpTimeLst[i].tid == tid) {
  332.                     tmpTimeLst[i] = newTask;
  333.                     isRep = true;
  334.                     break;
  335.                 }
  336.             }
  337.         }
  338.  
  339.         return isRep;
  340.     }
  341.     #endregion
  342.  
  343.     #region FrameTask
  344.     public int AddFrameTask(Action<int> callback, int delay, int count = 1) {
  345.         int tid = GetTid();
  346.         lock (lockTime) {
  347.             tmpFrameLst.Add(new PEFrameTask(tid, callback, frameCounter + delay, delay, count));
  348.         }
  349.         return tid;
  350.     }
  351.     public void DeleteFrameTask(int tid) {
  352.         lock (lockFrame) {
  353.             tmpDelFrameLst.Add(tid);
  354.         }
  355.         /*
  356.         bool exist = false;
  358.         for (int i = 0; i < taskFrameLst.Count; i++) {
  359.             PEFrameTask task = taskFrameLst[i];
  360.             if (task.tid == tid) {
  361.                 //taskFrameLst.RemoveAt(i);
  362.                 for (int j = 0; j < tidLst.Count; j++) {
  363.                     if (tidLst[j] == tid) {
  364.                         //tidLst.RemoveAt(j);
  365.                         break;
  366.                     }
  367.                 }
  368.                 exist = true;
  369.                 break;
  370.             }
  371.         }
  373.         if (!exist) {
  374.             for (int i = 0; i < tmpFrameLst.Count; i++) {
  375.                 PEFrameTask task = tmpFrameLst[i];
  376.                 if (task.tid == tid) {
  377.                     //tmpFrameLst.RemoveAt(i);
  378.                     for (int j = 0; j < tidLst.Count; j++) {
  379.                         if (tidLst[j] == tid) {
  380.                             //tidLst.RemoveAt(j);
  381.                             break;
  382.                         }
  383.                     }
  384.                     exist = true;
  385.                     break;
  386.                 }
  387.             }
  388.         }
  390.         return exist;
  391.         */
  392.     }
  393.     public bool ReplaceFrameTask(int tid, Action<int> callback, int delay, int count = 1) {
  394.         PEFrameTask newTask = new PEFrameTask(tid, callback, frameCounter + delay, delay, count);
  395.  
  396.         bool isRep = false;
  397.         for (int i = 0; i < taskFrameLst.Count; i++) {
  398.             if (taskFrameLst[i].tid == tid) {
  399.                 taskFrameLst[i] = newTask;
  400.                 isRep = true;
  401.                 break;
  402.             }
  403.         }
  404.  
  405.         if (!isRep) {
  406.             for (int i = 0; i < tmpFrameLst.Count; i++) {
  407.                 if (tmpFrameLst[i].tid == tid) {
  408.                     tmpFrameLst[i] = newTask;
  409.                     isRep = true;
  410.                     break;
  411.                 }
  412.             }
  413.         }
  414.  
  415.         return isRep;
  416.     }
  417.     #endregion
  418.  
  419.     public void SetLog(Action<string> log) {
  420.         taskLog = log;
  421.     }
  422.     
  423.     public void SetHandle(Action<Action<int>, int> handle) {
  424.         taskHandle = handle;
  425.     }
  426.  
  427.     public void Reset() {
  428.         tid = 0;
  429.         tidLst.Clear();
  430.         recTidLst.Clear();
  431.  
  432.         tmpTimeLst.Clear();
  433.         taskTimeLst.Clear();
  434.  
  435.         tmpFrameLst.Clear();
  436.         taskFrameLst.Clear();
  437.  
  438.         taskLog = null;
  439.         srvTimer.Stop();
  440.     }
  441.  
  442.     public int GetYear() {
  443.         return GetLocalDateTime().Year;
  444.     }
  445.     public int GetMonth() {
  446.         return GetLocalDateTime().Month;
  447.     }
  448.     public int GetDay() {
  449.         return GetLocalDateTime().Day;
  450.     }
  451.     public int GetWeek() {
  452.         return (int)GetLocalDateTime().DayOfWeek;
  453.     }
  454.     public DateTime GetLocalDateTime() {
  455.         DateTime dt = TimeZone.CurrentTimeZone.ToLocalTime(startDateTime.AddMilliseconds(nowTime));
  456.         return dt;
  457.     }
  458.     public double GetMillisecondsTime() {
  459.         return nowTime;
  460.     }
  461.     public string GetLocalTimeStr() {
  462.         DateTime dt = GetLocalDateTime();
  463.         string str = GetTimeStr(dt.Hour) + ":" + GetTimeStr(dt.Minute) + ":" + GetTimeStr(dt.Second);
  464.         return str;
  465.     }
  466.  
  467.     #region Tool Methonds
  468.     private int GetTid() {
  469.         lock (lockTid) {
  470.             tid += 1;
  471.  
  472.             //安全代码，以防万一
  473.             while (true) {
  474.                 if (tid == int.MaxValue) {
  475.                     tid = 0;
  476.                 }
  477.  
  478.                 bool used = false;
  479.                 for (int i = 0; i < tidLst.Count; i++) {
  480.                     if (tid == tidLst[i]) {
  481.                         used = true;
  482.                         break;
  483.                     }
  484.                 }
  485.                 if (!used) {
  486.                     tidLst.Add(tid);
  487.                     break;
  488.                 }
  489.                 else {
  490.                     tid += 1;
  491.                 }
  492.             }
  493.         }
  494.  
  495.         return tid;
  496.     }
  497.     private void RecycleTid() {
  498.         for (int i = 0; i < recTidLst.Count; i++) {
  499.             int tid = recTidLst[i];
  500.  
  501.             for (int j = 0; j < tidLst.Count; j++) {
  502.                 if (tidLst[j] == tid) {
  503.                     tidLst.RemoveAt(j);
  504.                     break;
  505.                 }
  506.             }
  507.         }
  508.         recTidLst.Clear();
  509.     }
  510.     private void LogInfo(string info) {
  511.         if (taskLog != null) {
  512.             taskLog(info);
  513.         }
  514.     }
  515.     private double GetUTCMilliseconds() {
  516.         TimeSpan ts = DateTime.UtcNow - startDateTime;
  517.         return ts.TotalMilliseconds;
  518.     }
  519.     private string GetTimeStr(int time) {
  520.         if (time < 10) {
  521.             return "0" + time;
  522.         }
  523.         else {
  524.             return time.ToString();
  525.         }
  526.     }
  527.     #endregion
  528.  
  529.     class PETimeTask {
  530.         public int tid;
  531.         public Action<int> callback;
  532.         public double destTime;//单位：毫秒
  533.         public double delay;
  534.         public int count;
  535.  
  536.         public PETimeTask(int tid, Action<int> callback, double destTime, double delay, int count) {
  537.             this.tid = tid;
  538.             this.callback = callback;
  539.             this.destTime = destTime;
  540.             this.delay = delay;
  541.             this.count = count;
  542.         }
  543.     }
  544.  
  545.     class PEFrameTask {
  546.         public int tid;
  547.         public Action<int> callback;
  548.         public int destFrame;
  549.         public int delay;
  550.         public int count;
  551.  
  552.         public PEFrameTask(int tid, Action<int> callback, int destFrame, int delay, int count) {
  553.             this.tid = tid;
  554.             this.callback = callback;
  555.             this.destFrame = destFrame;
  556.             this.delay = delay;
  557.             this.count = count;
  558.         }
  559.     }
  560. }
  561.  
  562. public enum PETimeUnit {
  563.     Millisecond,
  564.     Second,
  565.     Minute,
  566.     Hour,
  567.     Day
  568. }

使用示例代码

PETimer控制台工程案例代码：

  1. using System;
  2. using System.Threading;
  3. using System.Collections.Generic;
  4.  
  5. namespace ConsoleProjects {
  6.     class Program {
  7.         private static readonly string obj = "lock";
  8.  
  9.         static void Main(string[] args) {
  10.             Console.WriteLine("Test Start!");
  11.             //Test1();
  12.             Test2();
  13.         }
  14.  
  15.         //第一种用法：运行线程检测并处理任务
  16.         static void Test1() {
  17.             //运行线程驱动计时
  18.             PETimer pt = new PETimer();
  19.             pt.SetLog((string info) => {
  20.                 Console.WriteLine("LogInfo:" + info);
  21.             });
  22.  
  23.             pt.AddTimeTask((int tid) => {
  24.                 Console.WriteLine("Process线程ID:{0}", Thread.CurrentThread.ManagedThreadId.ToString());
  25.             }, 10, PETimeUnit.Millisecond, 0);
  26.  
  27.             while (true) {
  28.                 pt.Update();
  29.             }
  30.         }
  31.  
  32.         //第二种用法：独立线程检测并处理任务
  33.         static void Test2() {
  34.             Queue<TaskPack> tpQue = new Queue<TaskPack>();
  35.             //独立线程驱动计时
  36.             PETimer pt = new PETimer(5);
  37.             pt.SetLog((string info) => {
  38.                 Console.WriteLine("LogInfo:" + info);
  39.             });
  40.  
  41.  
  42.             int id = pt.AddTimeTask((int tid) => {
  43.                 Console.WriteLine("Process线程ID:{0}", Thread.CurrentThread.ManagedThreadId.ToString());
  44.             }, 3000, PETimeUnit.Millisecond, 0);
  45.  
  46.             //设置回调处理器
  47.             /*
  48.             pt.SetHandle((Action<int> cb, int tid) => {
  49.                 if (cb != null) {
  50.                     lock (obj) {
  51.                         tpQue.Enqueue(new TaskPack(tid, cb));
  52.                     }
  53.                 }
  54.             });
  55.             */
  56.             while (true) {
  57.                 string ipt = Console.ReadLine();
  58.                 if (ipt == "a") {
  59.                     pt.DeleteTimeTask(id);
  60.                 }
  61.  
  62.  
  63.                 if (tpQue.Count > 0) {
  64.                     TaskPack tp = null;
  65.                     lock (obj) {
  66.                         tp = tpQue.Dequeue();
  67.                     }
  68.                     tp.cb(tp.tid);
  69.                 }
  70.             }
  71.         }
  72.     }
  73.  
  74.     //任务数据包
  75.     class TaskPack {
  76.         public int tid;
  77.         public Action<int> cb;
  78.         public TaskPack(int tid, Action<int> cb) {
  79.             this.tid = tid;
  80.             this.cb = cb;
  81.         }
  82.     }
  83. }

PETimer集成到Unity案例代码：

  1. using UnityEngine;
  2.  
  3. public class GameStart : MonoBehaviour {
  4.     PETimer pt = new PETimer();
  5.  
  6.     int tempID = -1;
  7.     private void Start() {
  8.         //时间定时
  9.         pt.AddTimeTask(TimerTask, 500, PETimeUnit.Millisecond, 3);
  10.         //帧数定时
  11.         pt.AddFrameTask(FrameTask, 100, 3);
  12.  
  13.         //定时替换/删除
  14.         tempID = pt.AddTimeTask((int tid) => {
  15.             Debug.Log("定时等待替换......");
  16.         }, 1, PETimeUnit.Second, 0);
  17.     }
  18.  
  19.     private void Update() {
  20.         pt.Update();
  21.  
  22.         //定时替换
  23.         if (Input.GetKeyDown(KeyCode.R)) {
  24.  
  25.             bool succ = pt.ReplaceTimeTask(tempID, (int tid) => {
  26.                 Debug.Log("定时等待删除......");
  27.             }, 2, PETimeUnit.Second, 0);
  28.  
  29.             if (succ) {
  30.                 Debug.Log("替换成功");
  31.             }
  32.         }
  33.  
  34.         //定时删除
  35.         if (Input.GetKeyDown(KeyCode.D)) {
  36.             pt.DeleteTimeTask(tempID);
  37.         }
  38.     }
  39.  
  40.     void TimerTask(int tid) {
  41.         Debug.Log("TimeTask:" + System.DateTime.UtcNow);
  42.     }
  43.  
  44.     void FrameTask(int tid) {
  45.         Debug.Log("FrameTask:" + System.DateTime.UtcNow);
  46.     }
  47. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/108228
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号