如果有个操作，我们需要过一会儿再做，或者每隔一段时间就要做一次。可以有很多种做法。

独立线程

是的，对.NET Framework本身一知半解的程序员才会使用这种方案。不过，现实中这个方案其实并不少见。

        public static void Repeat(this Action action, TimeSpan interval)
        {
            new Thread(new ThreadStart(() =>
            {
                while(true)
                {
                    Thread.Sleep(interval);
                    action();
                }
            })).Start();
        }

这个方法，相比其他方法，其实还有一个不容小觑的优势：他保证了action只被一个线程调用，如果这个action没有再在别的地方用到的话，那么action就是线程安全的。

Timer类

在.Net Framework中，一共有4个Timer类。Joe Albahari在他的《Threading in C#》中对这4个Timer进行了充分的对比分析。我就不再赘述了。

但是Timer类的缺点也很明显。

l  非线程安全。除了UI上用的两个Timer类，其它的Timer类都不保证它自己一直是被同一个线程执行。当然，这种多线程的执行方式保证了效率与触发事件的时间精度。

l  操作积压。如果一个Timer，100ms触发一次，但是每次却要执行500ms。你可以想象到，你要做的action，本质上就变成了以这样的方式被执行着：

            while(true)

                action();

如果是多线程的Timer，情况会更糟糕，你的这个action会被多个线程同时执行着。多数情况下，我们应该并不希望事情变成这个样子。但是很可惜，Timer类可不会管你的EventHandler的执行时间是多久，他只是到时间就找个线程把你的action执行一次，无论上次action有没有完成。

l  使用不便。想想我们要做什么：“延迟或定时执行一个函数。”，再来看看需要写的代码，我觉得相对于要做的操作而言，过于复杂了。

            Timer timer = new Timer(1000);

            timer.Elapsed += (sender, e) => action();

            timer.Start();

            // 不需要的时候

            timer.Dispose();

再想想，如果你同时要保证线程安全和避免操作积压，又有多少代码要写？于是，Quartz.NET诞生了，以简化这类定时执行操作的代码。

Reactive Extension

事情就可以被简化成：

         Observable.Interval(interval).Subscribe(i => action());

上面的代码的行为与使用Timer类时的行为一样，有操作积压问题。解决方法有很多。这里给出一个我觉得最简单的。

        public static void Repeat(this Action action, TimeSpan interval)
        {
            Observable.Defer(action.ToAsync())
                      .DelaySubscription(interval)
                      .Repeat().Subscribe();
        }

上面的方法，保证了每次action执行之间的时间间隔是一定的。所以不会有action积压的问题出现。