计时器类，应用在一个拍卖程序

   /// <summary>
    /// 提供计时器服务
    /// </summary>
    public class TimerService
    {
        private static TimerService _Instance = null;

        public static TimerService Instance
        {
            get
            {
                if (_Instance == null)
                {
                    //实例化对象，并启动计时器服务
                    _Instance = new TimerService();
                    _Instance.timer = new System.Timers.Timer();
                    _Instance.timer.Interval = 1000;
                    _Instance.timer.Elapsed += _Instance.Timer_Elapsed;
                    _Instance.timer.Start();
                }
                return _Instance;
            }
        }

        /// <summary>
        /// 定时器读写锁
        /// </summary>
        private UsingLock<Object> Lock = new UsingLock<object>();

        /// <summary>
        /// 已注册的事件列表
        /// </summary>
        private List<TimerEventInfomation> SubscribedEvents = new List<TimerEventInfomation>();

        /// <summary>
        /// 计时器，每秒计时一次
        /// </summary>
        private System.Timers.Timer timer = new System.Timers.Timer();

        /// <summary>
        /// 获取当前时间戳
        /// </summary>
        /// <returns></returns>
        private long GetTime()
        {
            return GetTime(DateTime.Now);
        }

        /// <summary>
        /// 获取指定日期时间的时间戳
        /// </summary>
        /// <param name="time"></param>
        /// <returns></returns>
        public static long GetTime(DateTime time)
        {
            return Convert.ToInt32(time.Subtract(DateTime.Parse("1970-01-01")).TotalSeconds);
        }

        /// <summary>
        /// 每秒触发一次该事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            var time = GetTime();
            using (Lock.Write())
            {
                var triggers = this.SubscribedEvents.Where(t => t.EventTime == time).ToList();
                foreach (var item in triggers)
                {
                    //异步执行回调
                    item.EventCallback?.BeginInvoke(item, new AsyncCallback((d) => { }), null);
                }
                //移除全部本次已回调的对象列表
                foreach (var item in triggers)
                {
                    this.SubscribedEvents.Remove(item);
                }
            }
        }

        /// <summary>
        /// 添加一个事件到计时器
        /// </summary>
        /// <param name="info"></param>
        public void Add(TimerEventInfomation info)
        {
            using (Lock.Write())
            {
                if (info.EventTime <= GetTime())
                {
                    return;
                }
                Logs.Info($"为活动{info.ActiveID}新增计时器 -> " + Newtonsoft.Json.JsonConvert.SerializeObject(info));
                this.SubscribedEvents.Add(info);
            }
        }

        /// <summary>
        /// 无则新增，有则更新，新增返回true，更新返回false
        /// </summary>
        /// <param name="info"></param>
        public bool Set(TimerEventInfomation info)
        {
            using (Lock.Write())
            {
                var obj = this.SubscribedEvents.Where(t => t.ActiveID == info.ActiveID && t.Category == info.Category).FirstOrDefault();
                if (obj == null)
                {
                    obj.EventTime = info.EventTime;
                    obj.callbackObject = info.callbackObject;
                    obj.EventCallback = info.EventCallback;
                    Logs.Info($"为活动{info.ActiveID}更新计时器 -> " + Newtonsoft.Json.JsonConvert.SerializeObject(info));
                    return false;
                }
                else
                {
                    this.SubscribedEvents.Add(info);
                    Logs.Info($"为活动{info.ActiveID}新增计时器 -> " + Newtonsoft.Json.JsonConvert.SerializeObject(info));
                    return true;
                }
            }
        }

        /// <summary>
        /// 清空指定活动的计时器
        /// </summary>
        public int Remove(int ActiveID)
        {
            using (Lock.Write())
            {
                var Removes = this.SubscribedEvents.FindAll(t => t.ActiveID == ActiveID).ToList();
                if (Removes != null && Removes.Count > 0)
                {
                    Logs.Info($"移除活动{ActiveID}全部计时器 -> " + Newtonsoft.Json.JsonConvert.SerializeObject(Removes));
                }
                return this.SubscribedEvents.RemoveAll(t => t.ActiveID == ActiveID);
            }
        }

        /// <summary>
        /// 移除掉指定类别的计时器，通常应用在举牌倒计时器，或者报名倒计时器，报名人满即将开始时自动清除报名倒计时器，或者活动成功结束后需要清理掉倒计时器
        /// </summary>
        /// <param name="ActiveID"></param>
        /// <param name="category"></param>
        public int Remove(int ActiveID, TimerEventInfomationCategorys category)
        {
            using (Lock.Write())
            {
                return this.SubscribedEvents.RemoveAll(t => t.ActiveID == ActiveID && t.Category == category);
            }
        }

        /// <summary>
        /// 重载版本
        /// </summary>
        /// <param name="ActiveID"></param>
        /// <param name="eventTime"></param>
        /// <param name="sender"></param>
        /// <param name="callback"></param>
        public void Add(int ActiveID, DateTime eventTime, object sender, Action<Object> callback)
        {
            if (eventTime <= DateTime.Now) { return; }
            using (Lock.Write())
            {
                var info = new TimerEventInfomation() { ActiveID = ActiveID, EventTime = GetTime(eventTime), callbackObject = sender, EventCallback = callback };
                Logs.Info($"为活动{info.ActiveID}新增计时器 -> " + Newtonsoft.Json.JsonConvert.SerializeObject(info));
                this.SubscribedEvents.Add(info);
            }
        }

        /// <summary>
        /// 用于重置符合指定条件的计时器计时时间
        /// </summary>
        /// <param name="ActiveID"></param>
        /// <param name="category"></param>
        /// <param name="time"></param>
        public void ResetTime(int ActiveID, TimerEventInfomationCategorys category, DateTime time)
        {
            if (time <= DateTime.Now) { return; }
            using (Lock.Write())
            {
                var ms = this.SubscribedEvents.Where(t => t.ActiveID == ActiveID && t.Category == category).ToList();
                ms.ForEach(new Action<TimerEventInfomation>((t) =>
                {
                    t.EventTime = GetTime(time);
                }));
                Logs.Info($"为活动{ActiveID}更新类别{category.ToString()}计时器时间 -> " + Newtonsoft.Json.JsonConvert.SerializeObject(ms));
            }
        }

        /// <summary>
        /// 计时器事件消息对象
        /// </summary>
        public class TimerEventInfomation
        {
            /// <summary>
            /// 关联此事件的活动ID，用于批量重置或清除指定活动的全部事件
            /// </summary>
            public int ActiveID { get; set; }

            /// <summary>
            /// 标识，用于对计时器事件归类，方便通过该标识结合
            /// </summary>
            public TimerEventInfomationCategorys Category { get; set; } = TimerEventInfomationCategorys.通用;

            /// <summary>
            /// 事件时间，指定事件触发的具体时间
            /// </summary>
            public long EventTime { get; set; }

            /// <summary>
            /// 回调时的参数对象
            /// </summary>
            public Object callbackObject = null;

            /// <summary>
            /// 定时器自动触发的回调事件，当事件引发时，自动触发该回调
            /// </summary>
            public Action<Object> EventCallback { get; set; }
        }

        /// <summary>
        /// 归类枚举
        /// </summary>
        public enum TimerEventInfomationCategorys
        {
            通用 = 0,
            /// <summary>
            /// 表明活动已经开始，举牌进行中，等待目标时间表明倒计时时间已到
            /// </summary>
            落拍倒计时 = 2,
            /// <summary>
            /// 应用于定时开拍类活动，表示定时开拍，非定拍类活动不会使用到此枚举
            /// </summary>
            定拍倒计时 = 3,
            /// <summary>
            /// 开拍倒计时，指活动正式开始前的30秒倒计时期间，定时该计时器用于处理活动正式开始
            /// </summary>
            开拍倒计时 = 4,
            /// <summary>
            /// 托管自动举牌，人工出价类，每次有人出价时，自动重置，用于从托管用户中获取一个用户自动执行举牌，时间为倒计时剩余3秒时。举牌的同时自动重置。
            /// </summary>
            托管自动举牌 = 5,
            /// <summary>
            /// 提供给新活动自动轮询的计时器对象
            /// </summary>
            新活动轮询 = 6
        }
    }