如何使用同一计时器在不同的时间间隔执行不同的方法

Question

I used timer.elapsed but this one just can call methods with the same interval of time for example

timer.interval = 1000;
timer.elapsed += first();
timer.elapsed+=  second();

this call first and second every 1 second and i need call one at 3 seconds and the other at 5 seconds.

Answer 1

You can simply use multiple timers.

 timer1.Inverval = 3000;
 timer1.Elapsed += first();

 timer2.Interval = 5000;
 timer2.Elapsed += second();

Answer 2

如果您真的不能添加多个计时器（为什么不这样做），只需计算两个间隔的最大公约数（GCD）（例如，如果一个函数需要每30秒执行一次，而一个函数需要每45秒执行一次，那么GCD为5秒钟，因此将计时器设置为每5秒钟触发一次，但应每6秒钟启动一次计时器启动一次FunctionA，并每9秒钟执行一次FunctionB。

Answer 3

If you really want to do it using just a single timer:

You will need to maintain a list in which each entry contains a reference to the method to call, and the time at which it should be invoked. (Must use absolute time values for this, not intervals.)

1. Walk through the list, find the entry with the smallest time value, (the time that is closest to now,) and set the timer to fire at that point in time.

2. When the timer fires, walk through the list again, and invoke any methods whose time-to-invoke is less-than-or-equal to now. For each method invoked, calculate the next time-to-invoke that method.

3. Go to step 1.

In doing so, you will essentially be re-implementing the timer mechanism of the .Net runtime, which is an exercise in futility. So, you would be much better off not doing it this way, and using multiple timers instead.

Answer 4

I'm not really sure why you'd want to do this, but you could do something similar to the following:

public class MultiIntervalTimer: IDisposable
{
    private readonly Timer innerTimer;
    private readonly IReadOnlyDictionary<int, MultiIntervalTimerCallbackInfo> callbackInfos;
    private long totalElapsedMiliseconds;
    private readonly int innerTimerInterval;
    private object syncRoot = new object();
    private bool disposed;

    public MultiIntervalTimer(Dictionary<int, MultiIntervalTimerCallbackInfo> callbacks, int dueTime)
    {
        if (callbacks == null)
            throw new ArgumentNullException(nameof(callbacks));

        var innerTimerCallback = new TimerCallback(innerCallback);
        callbackInfos = new Dictionary<int, MultiIntervalTimerCallbackInfo>(callbacks);
        innerTimerInterval = getGreatestCommonDivisor(callbacks.Keys);
        innerTimer = new Timer(innerTimerCallback, null, dueTime, innerTimerInterval);
    }

    public void Dispose()
    {
        if (disposed)
            return;

        innerTimer.Dispose();
        disposed = true;
    }

    private static int getGreatestCommonDivisor(IEnumerable<int> numbers)
    {
        Debug.Assert(numbers != null);
        Debug.Assert(numbers.Any());
        var numbersArray = numbers.ToArray();

        if (numbersArray.Length == 1)
            return numbersArray[0];

        if (numbersArray.Length == 2)
            return getGreatestCommonDivisor(numbersArray[0], numbersArray[1]);

        var trimmedNumbersArray = new int[numbersArray.Length - 1];
        Array.Copy(numbersArray, 1, trimmedNumbersArray, 0, trimmedNumbersArray.Length);
        return getGreatestCommonDivisor(numbersArray[0], getGreatestCommonDivisor(trimmedNumbersArray));
    }

    private static int getGreatestCommonDivisor(int left, int right)
    {
        while (right != 0)
        {
            var temp = right;
            right = left % right;
            left = temp;
        }

        return left;
    }

    private void innerCallback(object state)
    {
        Debug.Assert(syncRoot != null);
        Debug.Assert(!disposed);
        var elapsed = 0L;

        lock (syncRoot)
        {
            totalElapsedMiliseconds += innerTimerInterval;
            elapsed = totalElapsedMiliseconds;
        }

        foreach (var callback in callbackInfos.Where(c => elapsed % c.Key == 0))
        {
            callback.Value?.Callback(callback.Value.State);
        }
    }
}

public class MultiIntervalTimerCallbackInfo
{
    public MultiIntervalTimerCallbackInfo(TimerCallback callback, object state)
    {
        if (callback == null)
            throw new ArgumentNullException(nameof(callback));

        Callback = callback;
        State = state;
    }

    public TimerCallback Callback { get; }
    public object State { get; }
}

And a way to use it:

public class State
{
    public State()
        :this(0)
    { }

    private State(int count)
    {
        Count = count;
    }

    public int Count { get; private set; }

    public void IncrementCount() => Count++;
}

public static void Main(string[] args)
{
    var state = new State();
    bool stop = false;
    var intervalCallback1 = new MultiIntervalTimerCallbackInfo(new System.Threading.TimerCallback(c =>
                                                                                                  {
                                                                                                      Console.WriteLine($"Interval 1: Call #{state.Count}. Thread Id: {Thread.CurrentThread.ManagedThreadId}");
                                                                                                      state.IncrementCount();
                                                                                                  }), state);

    var intervalCallback2 = new MultiIntervalTimerCallbackInfo(new System.Threading.TimerCallback(c =>
                                                                                                  {
                                                                                                      Console.WriteLine($"Interval 2: Call #{state.Count}. Thread Id: {Thread.CurrentThread.ManagedThreadId}");
                                                                                                      state.IncrementCount();
                                                                                                  }), state);
    var intervalCallback3 = new MultiIntervalTimerCallbackInfo(new System.Threading.TimerCallback(c =>
                                                                                                  {
                                                                                                      Console.WriteLine($"Interval 3: Call #{state.Count}. Thread Id: {Thread.CurrentThread.ManagedThreadId}");
                                                                                                      state.IncrementCount();
                                                                                                  }), state);
    var intervalCallback4 = new MultiIntervalTimerCallbackInfo(new System.Threading.TimerCallback(c =>
                                                                                                  {
                                                                                                      Console.WriteLine($"Interval 4: Call #{state.Count}.  Thread Id: {Thread.CurrentThread.ManagedThreadId}.\r\n Exiting loop", state);
                                                                                                      stop = true;
                                                                                                  }), state);

    var callbacks = new Dictionary<int, MultiIntervalTimerCallbackInfo>() { { 50, intervalCallback1 },
                                                                            { 100, intervalCallback2 },
                                                                            { 200, intervalCallback3  },
                                                                            { 2000, intervalCallback4 } };

    using (var timer = new MultiIntervalTimer(callbacks, 1000))
    {
        while (!stop)
        {

        }
    }

    Console.WriteLine($"Total calls: {state.Count}.");
    Console.ReadLine();
}

I've barely tested this and I haven't spent too much time thinking about all the implications of the multithreading going on and the required locking / synchronisation, so take this code as a very preliminary approach.