为什么这些Timer事件会在不一致的时间引发？

Question

我一直在阅读Daniel Solis的Illustrated C#2008(一本优秀的书,顺便说一下),并决定花更多时间在活动上来进一步了解这个主题.我试图理解为什么每次运行程序时都会看到不同的结果,以及我可以从中学到什么.

(下面的源代码)在本书的示例代码中,有一个MyTimerClass订阅的事件System.Timers.Timer.还有另外两个类,ClassA和ClassB,它们都有写入控制台的事件处理程序(一个是静态而另一个不是).在main程序的功能中,这些类的事件处理程序与一个实例中的事件绑定在一起MyTimerClass.另一个函数通过lambda表达式添加到事件成员.

在使用作者的代码之后,我决定添加另一个类ClassC.Main我不是在程序的函数中添加事件处理程序,而是决定MyTimerClass在ClassC构造函数中创建一个单独的对象,然后订阅该MyTimerClass事件.

当我在3个不同的场合运行我的代码4.25秒时,我的结果总是以不同的顺序.从事件Main顺序的功能总是被调用ClassA,ClassB,然后LAMBDA以相同的顺序.但是,ClassC似乎总是以完全随机的顺序调用另一个事件.我还注意到第一组方法调用似乎有稍微不同的时间,而后续的组都有相同的时间.这是为什么？

(1) Event 1 - ClassA - 51:259
    Event 2 - ClassC - 51:259
(2) Event 1 - ClassB - 51:261
(3) Event 1 - Lambda - 51:262
(1) Event 1 - ClassA - 52:271
(2) Event 1 - ClassB - 52:271
(3) Event 1 - Lambda - 52:271
    Event 2 - ClassC - 52:271
(1) Event 1 - ClassA - 53:285
(2) Event 1 - ClassB - 53:285
(3) Event 1 - Lambda - 53:285
    Event 2 - ClassC - 53:285
(1) Event 1 - ClassA - 54:299
(2) Event 1 - ClassB - 54:299
(3) Event 1 - Lambda - 54:299
    Event 2 - ClassC - 54:299

(1) Event 1 - ClassA - 17:30
    Event 2 - ClassC - 17:30
(2) Event 1 - ClassB - 17:32
(3) Event 1 - Lambda - 17:33
(1) Event 1 - ClassA - 18:42
(2) Event 1 - ClassB - 18:42
(3) Event 1 - Lambda - 18:42
    Event 2 - ClassC - 18:42
(1) Event 1 - ClassA - 19:56
(2) Event 1 - ClassB - 19:56
(3) Event 1 - Lambda - 19:56
    Event 2 - ClassC - 19:56
    Event 2 - ClassC - 20:70
(1) Event 1 - ClassA - 20:70
(2) Event 1 - ClassB - 20:70
(3) Event 1 - Lambda - 20:70

(1) Event 1 - ClassA - 45:220
    Event 2 - ClassC - 45:221
(2) Event 1 - ClassB - 45:223
(3) Event 1 - Lambda - 45:223
(1) Event 1 - ClassA - 46:232
(2) Event 1 - ClassB - 46:232
(3) Event 1 - Lambda - 46:232
    Event 2 - ClassC - 46:232
    Event 2 - ClassC - 47:246
(1) Event 1 - ClassA - 47:246
(2) Event 1 - ClassB - 47:246
(3) Event 1 - Lambda - 47:246
(1) Event 1 - ClassA - 48:260
(2) Event 1 - ClassB - 48:260
(3) Event 1 - Lambda - 48:260
    Event 2 - ClassC - 48:260

这是我的控制台应用程序的源代码:

class Program
{
    static void Main(string[] args)
    {
        MyTimerClass mc = new MyTimerClass();
        ClassA ca = new ClassA();
        ClassC cc = new ClassC();

        mc.MyElapsed += ca.TimerHandlerA;
        mc.MyElapsed += ClassB.TimerHandlerB;
        mc.MyElapsed += (obj, e) =>
            {
                Console.WriteLine("(3) Event 1 - Lambda - {0}:{1}",
                    System.DateTime.Now.Second,
                    System.DateTime.Now.Millisecond);
            };

        Thread.Sleep(4250);
    }
}

class ClassA
{
    public void TimerHandlerA(Object obj, EventArgs e)
    {
        Console.WriteLine("(1) Event 1 - ClassA - {0}:{1}",
            System.DateTime.Now.Second,
            System.DateTime.Now.Millisecond);
    }
}

class ClassB
{
    public static void TimerHandlerB(Object obj, EventArgs e)
    {
        Console.WriteLine("(2) Event 1 - ClassB - {0}:{1}",
            System.DateTime.Now.Second,
            System.DateTime.Now.Millisecond);
    }
}

class ClassC
{
    public void TimerHandlerC(Object obj, EventArgs e)
    {
        Console.WriteLine("    Event 2 - ClassC - {0}:{1}",
            System.DateTime.Now.Second,
            System.DateTime.Now.Millisecond);
    }

    public ClassC()
    {
        // This will create a separate MyTimerClass and
        // attach ClassC's event handler to mc's event.
        MyTimerClass mc = new MyTimerClass();
        mc.MyElapsed += TimerHandlerC;
    }
}

public class MyTimerClass
{
    public event EventHandler MyElapsed;

    private void OnOneSecond(Object obj, EventArgs e)
    {
        if (MyElapsed != null)
            MyElapsed(obj, e);
    }

    private System.Timers.Timer MyPrivateTimer;

    public MyTimerClass()
    {
        MyPrivateTimer = new System.Timers.Timer();

        // This will attach the OnOneSecond Event Handler
        // to the system timer which will then raise
        // MyElapsed.
        MyPrivateTimer.Elapsed += OnOneSecond;

        // This sets the interval at 1 second.
        MyPrivateTimer.Interval = 1000;

        // This turns the timer on when the the class
        // is instantiated.
        MyPrivateTimer.Enabled = true;
    }
}

三个问题:

• 为什么结果每次都不同以及导致这种情况发生的原因是什么？
• 为什么第一个结果块中的时间稍微偏离,而后续的块具有相同的时间？
• 我应该从这个例子中学到什么？

Answer 1

简短的回答是,"这就像Windows计时器的工作方式." 你在这里做错了什么,你看到的结果是正常行为.

Microsoft在Windows中提供的本机计时器不能保证精确到位.如果你设置一个计时器,以每1000毫秒蜱,它保证,这将是至少 1000毫秒,但不完全相同 1000毫秒.它通常非常接近,有时甚至是精确的,但如果你需要非常高的精度计时,你需要研究其他机制.在Win32 C/C++ API级别,适当的机制是QueryPerformanceFrequency/QueryPerformanceCounter方法.在.NET中,您将使用StopWatch类来获得此功能.

至于顺序,如果在.NET中将多个处理程序附加到一个计时器,我很确定也不能保证它们将以任何给定的顺序执行.我不确定微软正在使用什么算法来解雇它们,但是你的结果清楚地表明它并不是一种保证它们有序的算法.如果您需要按顺序编写代码,则为该计时器注册一个处理程序,并以正确的顺序从该处理程序调用所有内容.

正如评论中所指出的,Windows并不是真正的高性能实时操作系统.但是,对于99.99%的桌​​面应用程序来说,这并不是必需的(因此微软的设计决定;毕竟,它主要是桌面操作系统).