Неповторно используемый таймер C#

Используйте System.Threading.Timer. Инициализируйте его с периодом Timeout.Infinite, чтобы он действовал как одноразовый таймер. Когда f() завершится, вызовите его метод Change(), чтобы перезарядить его снова.

Простой поток - самый простой способ достичь этого. Вы все еще не будете уверены, что вас вызовут "точно", когда вы хотите, но это должно быть близко..... Также вы можете решить, хотите ли вы пропустить вызовы, которые должны произойти, или попытаться наверстать упущенное... Вот простая вспомогательная процедура для создания потока.

public static Thread StartTimer(TimeSpan interval, Func<bool> operation)
{
    Thread t = new Thread(new ThreadStart(
        delegate()
        {
            DateTime when = DateTime.Now;
            TimeSpan wait = interval;
            while (true)
            {
                Thread.Sleep(wait);
                if (!operation())
                    return;
                DateTime dt = DateTime.Now;
                when += interval;
                while (when < dt)
                    when += interval;
                wait = when - dt;
            }
        }
    ));
    t.IsBackground = true;
    t.Start();
    return t;
}

Вы не можете заставить таймер звонить вам через точно запланированные интервалы. Все таймеры перезвонят вам не раньше запрошенного времени.

Некоторые таймеры лучше других (например, Windows.Forms.Timer очень нестабильный и ненадежный по сравнению с System.Threading.Timer)

Чтобы остановить повторный вызов таймера, можно остановить таймер, пока ваш метод работает. (В зависимости от типа используемого вами таймера вы либо останавливаете его и запускаете снова, когда ваш обработчик завершает работу, либо с помощью некоторых таймеров вы можете запросить один обратный вызов, а не повторять обратные вызовы, поэтому каждое выполнение вашего обработчика просто ставит в очередь следующий вызов) .

Чтобы обеспечить относительно равномерное распределение времени между этими вызовами, вы можете записать время с момента последнего выполнения обработчика и использовать его для расчета задержки до следующего события. например Если вы хотите, чтобы вас вызывали один раз в секунду и ваш таймер завершил обработку на 1.02 с, то вы можете настроить следующий обратный вызов таймера на длительность 0,98 с, чтобы учесть тот факт, что вы уже «израсходовали» часть следующего. второй во время обработки.

Вы можете использовать таймер без перезапуска, а затем вручную перезапустить таймер после завершения метода.

Обратите внимание, что это приведет к тому, что время будет несколько отличаться от того, о котором вы просите. (Между вызовами всегда будет промежуток времени t )

Вы можете решить эту проблему, установив интервал на lastTick + t - Now и немедленно запустив метод, если это <= 0 .

Остерегайтесь условий гонки, если вам нужно остановить таймер.

Как насчет использования делегатов для метода f (), постановки их в очередь в стек и извлечения стека по мере завершения работы каждого делегата? Конечно, вам еще понадобится таймер.

Простое решение:

private class Worker : IDisposable
{
    private readonly TimeSpan _interval;
    private WorkerContext _workerContext;

    private sealed class WorkerContext
    {
        private readonly ManualResetEvent _evExit;
        private readonly Thread _thread;
        private readonly TimeSpan _interval;

        public WorkerContext(ParameterizedThreadStart threadProc, TimeSpan interval)
        {
            _evExit = new ManualResetEvent(false);
            _thread = new Thread(threadProc);
            _interval = interval;
        }

        public ManualResetEvent ExitEvent
        {
            get { return _evExit; }
        }

        public TimeSpan Interval
        {
            get { return _interval; }
        }

        public void Run()
        {
            _thread.Start(this);
        }

        public void Stop()
        {
            _evExit.Set();
        }

        public void StopAndWait()
        {
            _evExit.Set();
            _thread.Join();
        }
    }

    ~Worker()
    {
        Stop();
    }

    public Worker(TimeSpan interval)
    {
        _interval = interval;
    }

    public TimeSpan Interval
    {
        get { return _interval; }
    }

    private void DoWork()
    {
        /* do your work here */
    }

    public void Start()
    {
        var context = new WorkerContext(WorkThreadProc, _interval);
        if(Interlocked.CompareExchange<WorkerContext>(ref _workerContext, context, null) == null)
        {
            context.Run();
        }
        else
        {
            context.ExitEvent.Close();
            throw new InvalidOperationException("Working alredy.");
        }
    }

    public void Stop()
    {
        var context = Interlocked.Exchange<WorkerContext>(ref _workerContext, null);
        if(context != null)
        {
            context.Stop();
        }
    }

    private void WorkThreadProc(object p)
    {
        var context = (WorkerContext)p;
        // you can use whatever time-measurement mechanism you want
        var sw = new System.Diagnostics.Stopwatch();
        int sleep = (int)context.Interval.TotalMilliseconds;
        while(true)
        {
            if(context.ExitEvent.WaitOne(sleep)) break;

            sw.Reset();
            sw.Start();

            DoWork();

            sw.Stop();

            var time = sw.Elapsed;
            if(time < _interval)
                sleep = (int)(_interval - time).TotalMilliseconds;
            else
                sleep = 0;
        }
        context.ExitEvent.Close();
    }

    public void Dispose()
    {
        Stop();
        GC.SuppressFinalize(this);
    }
}