Soul2-Library/General/utils/TimerUtils.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using Timer = System.Timers.Timer;

namespace Soul2.General.utils
{
    /// <summary>
    /// 扩展System.Timers.Timer
    /// By Soul2
    /// </summary>
    public static class TimerUtils
    {
        private const int default_loop_times = 512;

        /// <summary>
        /// 一次性计时器
        /// 运行结束后自动销毁
        /// </summary>
        /// <param name="timer"></param>
        /// <param name="time"></param>
        /// <param name="callback"></param>
        /// <returns></returns>
        public static Timer startOnce(this Timer timer, double time, Action<Timer> callback)
        {
            void onElapsed(object source, ElapsedEventArgs e)
            {
                callback(timer);
                timer.destroy();
            }
            return run(timer, (int)(time * 1000), false, onElapsed);
        }
        public static Timer startOnce(this Timer timer, double time, Action callback)
        {
            return timer.startOnce(time, (t) => callback?.Invoke());
        }

        /// <summary>
        /// 循环计时器
        /// 可以指定运行次数
        /// 运行结束后自动销毁
        /// </summary>
        /// <param name="timer">计时器</param>
        /// <param name="time">时长</param>
        /// <param name="times">次数</param>
        /// <param name="callback"></param>
        /// <returns></returns>
        public static Timer startLoop(this Timer timer, double time, int times, Action<Timer, int> callback)
        {
            int run_times = 0;
            void onElapsed(object source, ElapsedEventArgs e)
            {
                run_times += 1;
                if (run_times <= times)
                {
                    callback(timer, run_times);
                }
                else
                {
                    timer.destroy();
                }
            }
            return run(timer, (int)(time * 1000), true, onElapsed);
        }

        public static Timer startLoop(this Timer timer, double time, int times, Action<Timer> callback)
        {
            return timer.startLoop(time, times, (t, i) => callback?.Invoke(t));
        }

        public static Timer startLoop(this Timer timer, double time, int times, Action<int> callback)
        {
            return timer.startLoop(time, times, (t, i) => callback?.Invoke(i));
        }

        public static Timer startLoop(this Timer timer, double time, int times, Action callback)
        {
            return timer.startLoop(time, times, (t, i) => callback?.Invoke());
        }

        /// <summary>
        /// 循环计时器
        /// 默认运行次数512
        /// </summary>
        /// <param name="timer">计时器</param>
        /// <param name="time">时长</param>
        /// <param name="times">次数</param>
        /// <param name="callback"></param>
        /// <returns></returns>
        public static Timer startKeep(this Timer timer, double time, Action<Timer, int> callback, int times = default_loop_times)
        {
            int run_times = 0;
            void onElapsed(object source, ElapsedEventArgs e)
            {
                run_times += 1;
                if (run_times <= times)
                {
                    callback(timer, run_times);
                }
                else
                {
                    timer.destroy();
                }
            }
            return run(timer, (int)(time * 1000), true, onElapsed);
        }
        public static Timer startKeep(this Timer timer, double time, Action<int> callback, int times = default_loop_times)
        {
            return timer.startKeep(time, (t, i) => callback?.Invoke(i));
        }
        public static Timer startKeep(this Timer timer, double time, Action<Timer> callback, int times = default_loop_times)
        {
            return timer.startKeep(time, (t, i) => callback?.Invoke(t));
        }
        public static Timer startKeep(this Timer timer, double time, Action callback, int times = default_loop_times)
        {
            return timer.startKeep(time, (t, i) => callback?.Invoke());
        }

        public static void destroy(this Timer timer)
        {
            if (timer.Enabled)
            {
                timer.Stop();
            }
            timer.Dispose();
        }

        // -----------------------------------------

        private static Timer run(Timer timer, int interval, bool loop, ElapsedEventHandler elapsed)
        {
            timer.Elapsed += elapsed;
            timer.Interval = interval;
            timer.AutoReset = loop;
            timer.Start();
            return timer;
        }

        public static Timer startOnce(double time, Action<Timer> callback)
        {
            return new Timer().startOnce(time, callback);
        }
        public static Timer startOnce(double time, Action callback)
        {
            return new Timer().startOnce(time, callback);
        }

        // -----------------------------------------

        public static Timer startLoop(double time, int times, Action<Timer, int> callback)
        {
            return new Timer().startLoop(time, times, callback);
        }
        public static Timer startLoop(double time, int times, Action<Timer> callback)
        {
            return new Timer().startLoop(time, times, callback);
        }
        public static Timer startLoop(double time, int times, Action<int> callback)
        {
            return new Timer().startLoop(time, times, callback);
        }
        public static Timer startLoop(double time, int times, Action callback)
        {
            return new Timer().startLoop(time, times, callback);
        }

        // -----------------------------------------

        public static Timer startKeep(double time, Action<Timer, int> callback, int times = default_loop_times)
        {
            return new Timer().startKeep(time, callback, times);
        }
        public static Timer startKeep(double time, Action<int> callback, int times = default_loop_times)
        {
            return new Timer().startKeep(time, callback, times);
        }
        public static Timer startKeep(double time, Action<Timer> callback, int times = default_loop_times)
        {
            return new Timer().startKeep(time, callback, times);
        }
        public static Timer startKeep(double time, Action callback, int times = default_loop_times)
        {
            return new Timer().startKeep(time, callback, times);
        }

    }
}