如何实现定时推送？

Achieves，这层里实现之前定义的接口，这里写成抽象类是为了后面方便扩展。

using System;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using DelayMessageApp.Interfaces;

namespace DelayMessageApp.Achieves.base
{
public abstract class baseQueue : IRingQueue
{
    private long _pointer = 0L;
    private ConcurrentBag>[] _arraySlot;
    private int ArrayMax;

    /// 

    /// Ring queue.
    /// 
    public ConcurrentBag>[] ArraySlot
    {
 get { return _arraySlot ?? (_arraySlot = new ConcurrentBag>[ArrayMax]); }
    }
    
    public baseQueue(int arrayMax)
    {
 if (arrayMax < 60 && arrayMax % 60 == 0)
     throw new Exception("Ring queue length cannot be less than 60 and is a multiple of 60 .");

 ArrayMax = arrayMax;
    }

    public void Add(long delayTime, Action action)
    {
 Add(delayTime, action, default(T));
    }

    public void Add(long delayTime,Action action,T data)
    {
 Add(delayTime, action, data,0);
    }

    public void Add(long delayTime, Action action, T data,long id)
    {
 NextSlot(delayTime, out long cycle, out long pointer);
 ArraySlot[pointer] =  ArraySlot[pointer] ?? (ArraySlot[pointer] = new ConcurrentBag>());
 var baseTask = new baseTask(cycle, action, data,id);
 ArraySlot[pointer].Add(baseTask);
    }

    /// 

    /// Remove tasks based on ID.
    /// 
    /// 
    public void Remove(long id)
    {
 try
 {
     Parallel.ForEach(ArraySlot, (ConcurrentBag> collection, ParallelLoopState state) =>
     {
  var resulTask = collection.FirstOrDefault(p => p.Id == id);
  if (resulTask != null)
  {
      collection.TryTake(out resulTask);
      state.Break();
  }
     });
 }
 catch (Exception e)
 {
     Console.WriteLine(e);
 }
    }
    
    public void Start()
    {
 while (true)
 {
     RightMovePointer();
     Thread.Sleep(1000);
     Console.WriteLine(DateTime.Now.ToString());
 }
    }

    /// 

    /// Calculate the information of the next slot.
    /// 
    /// Delayed execution time.
    /// Number of turns.
    /// Task location.
    private void NextSlot(long delayTime, out long cycle,out long index)
    {
 try
 {
     var circle = delayTime / ArrayMax;
     var second = delayTime % ArrayMax;
     var current_pointer = GetPointer();
     var queue_index = 0L;

     if (delayTime - ArrayMax > ArrayMax)
     {
  circle = 1;
     }
     else if (second > ArrayMax)
     {
  circle += 1;
     }

     if (delayTime - circle * ArrayMax < ArrayMax)
     {
  second = delayTime - circle * ArrayMax;
     }

     if (current_pointer + delayTime >= ArrayMax)
     {
  cycle = (int)((current_pointer + delayTime) / ArrayMax);
  if (current_pointer + second - ArrayMax < 0)
  {
      queue_index = current_pointer + second;
  }
  else if (current_pointer + second - ArrayMax > 0)
  {
      queue_index = current_pointer + second - ArrayMax;
  }
     }
     else
     {
  cycle = 0;
  queue_index = current_pointer + second;
     }
     index = queue_index;
 }
 catch (Exception e)
 {
     Console.WriteLine(e);
     throw;
 }
    }

    /// 

    /// Get the current location of the pointer.
    /// 
    /// 
    private long GetPointer()
    {
 return Interlocked.Read(ref _pointer);
    }

    /// 

    /// Reset pointer position.
    /// 
    private void ReSetPointer()
    {
 Interlocked.Exchange(ref _pointer, 0);
    }

    /// 

    /// Pointer moves clockwise.
    /// 
    private void RightMovePointer()
    {
 try
 {
     if (GetPointer() >= ArrayMax - 1)
     {
  ReSetPointer();
     }
     else
     {
  Interlocked.Increment(ref _pointer);
     }

     var pointer = GetPointer();
     var taskCollection = ArraySlot[pointer];
     if (taskCollection == null || taskCollection.Count == 0) return;

     Parallel.ForEach(taskCollection, (baseTask task) =>
     {
  if (task.Cycle > 0)
  {
      task.SubCycleNumber();
  }

  if (task.Cycle <= 0)
  {
      taskCollection.TryTake(out task);
      task.TaskAction(task.Data);
  }
     });
 }
 catch (Exception e)
 {
     Console.WriteLine(e);
     throw;
 }
    }
}
}


using System;
using System.Threading;
using DelayMessageApp.Interfaces;

namespace DelayMessageApp.Achieves.base
{
public class baseTask : ITask
{
    private long _cycle;
    private long _id;
    private T _data;

    public Action TaskAction { get; set; }

    public long Cycle
    {
 get { return Interlocked.Read(ref _cycle); }
 set { Interlocked.Exchange(ref _cycle, value); }
    }

    public long Id
    {
 get { return _id; }
 set { _id = value; }
    }

    public T Data
    {
 get { return _data; }
 set { _data = value; }
    }

    public baseTask(long cycle, Action action, T data,long id)
    {
 Cycle = cycle;
 TaskAction = action;
 Data = data;
 Id = id;
    }

    public baseTask(long cycle, Action action,T data)
    {
 Cycle = cycle;
 TaskAction = action;
 Data = data;
    }

    public baseTask(long cycle, Action action)
    {
 Cycle = cycle;
 TaskAction = action;
    }
    
    public void SubCycleNumber()
    {
 Interlocked.Decrement(ref _cycle);
    }
}
}

public static void Start()
{
    //1.Initialize queues of different granularity.
    IRingQueue minuteRingQueue = new MinuteQueue();

    //2.Open thread.
    var lstTasks = new List
    {
 Task.Factory.StartNew(minuteRingQueue.Start)
    };

    //3.Add tasks performed in different periods.
    minuteRingQueue.Add(5, new Action((NewsModel newsObj) =>
    {
 Console.WriteLine(newsObj.News);
    }), new NewsModel() { News = "Trump's visit to China！" });

    minuteRingQueue.Add(10, new Action((NewsModel newsObj) =>
    {
 Console.WriteLine(newsObj.News);
    }), new NewsModel() { News = "Putin Pu's visit to China！" });

    minuteRingQueue.Add(60, new Action((NewsModel newsObj) =>
    {
 Console.WriteLine(newsObj.News);
    }), new NewsModel() { News = "Eisenhower's visit to China！" });

    minuteRingQueue.Add(120, new Action((NewsModel newsObj) =>
    {
 Console.WriteLine(newsObj.News);
    }), new NewsModel() { News = "Xi Jinping's visit to the US！" });

    //3.Waiting for all tasks to complete is usually not completed. Because there is an infinite loop.
    //F5 Run the program and see the effect.
    Task.WaitAll(lstTasks.ToArray());
    Console.Read();
}