如何处置 LargeIntervalTimer

Question

我正在使用 OpenNetCF 的 LargeIntervalTimer 在特定条件下在特定屏幕上进行轮询。

因为我不希望计时器不断触发，所以一旦不再需要它，我就会尝试将其丢弃，但是在 UI 线程中调用 Dispose() 或将 Enabled 设置为 false 通常会挂起应用程序。

我尝试将计时器处理代码移动到计时器的线程上（通过在 tick 方法中调用它），这只会使挂起更加一致（尽管在单独的线程中，以便应用程序的其余部分继续工作）。

有没有人见过这个计时器的类似问题，如果是的话，你是如何解决这些问题的？

启动代码：

_timer = new LargeIntervalTimer();
_timer.OneShot = false;
_timer.Tick += TimerTick;
_timer.Interval = new TimeSpan(0, 0, 30);
_timer.FirstEventTime = DateTime.Now.AddSeconds(30);
_timer.Enabled = true;

关闭代码：

if (_timer != null)
{
    _timer.Enabled = false;
    _timer.Dispose();
    _timer = null;
}

Answer 1

查看 LIT 源代码，我没有看到任何处理它会导致任何问题的原因。 Dispose 如下所示：

public void Dispose()
{
    lock (m_interlock)
    {
        m_disposing = true;

        if (Enabled)
        {
            Enabled = false;
        }

        if (m_quitHandle != null)
        {
            m_quitHandle.Set();
            m_quitHandle.Close();
            m_quitHandle = null;
        }
    }
}

如您所见，它将 Enabled 设置为 false，然后设置 WaitHandle。

Enabled 实现同样简单：

public bool Enabled
{
    get { return m_enabled; }
    set
    {
        lock (m_interlock)
        {
            m_cachedEnabled = value;

            if ((m_enabled && value) || (!m_enabled && !value))
            {
                return;
            }

            m_enabled = value;

            // force any existing waiting threads to exit
            if(ThreadCount > 0)
            {
                m_quitHandle.Set();
                Thread.Sleep(1);
            }

            if (m_enabled)
            {
                // start the wait thread
                ThreadPool.QueueUserWorkItem(InternalThreadProc);
            }
        }
    }
}

基本上，如果我们禁用并且启用，则将设置 Dispose 将设置的相同 WaitHandle。冗余，是的，​​但不是问题。 SetEvent 不是时钟调用，因此此代码是调用的直接结果而发生的所有事情，并且应该是唯一会影响“挂起”场景的事情。但为了完整起见，让我们看看这个事件触发了什么。下面是工作线程过程（主要是 LIT 类的主要内容）：

private void InternalThreadProc(object state)
{
    ThreadCount++;

    int source;
    string eventName = Guid.NewGuid().ToString();
    EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset, eventName);

    try
    {
        while (m_enabled)
        {
            if (m_disposing) return;

            if (m_useFirstTime)
            {
                Notify.RunAppAtTime(string.Format(@"\\.\Notifications\NamedEvents\{0}", 
                    eventName), m_firstTime);
                m_useFirstTime = false;
            }
            else
            {
                // set up the next event
                Notify.RunAppAtTime(string.Format(@"\\.\Notifications\NamedEvents\{0}", 
                    eventName), DateTime.Now.Add(m_interval));
                m_firstTime = DateTime.MinValue;
            }

            if (m_disposing) return;
            source = OpenNETCF.Threading.EventWaitHandle.WaitAny(new WaitHandle[] 
                     { waitHandle, m_quitHandle });

            // see if it's the event
            if (source == 0)
            {
                m_cachedEnabled = null;

                // fire the event if we have a listener
                if (Tick != null)
                {
                    // we need to decouple this call from the current thread 
                    // or the lock will do nothing
                    ThreadPool.QueueUserWorkItem(new WaitCallback(
                        delegate
                        {
                            Tick(this, null);
                        }));
                }

                if (OneShot)
                {
                    if (m_cachedEnabled != null)
                    {
                        m_enabled = (m_cachedEnabled == true);
                    }
                    else
                    {
                        m_enabled = false;
                    }
                }
            }
            else
            {
                m_enabled = false;
            }
        }
    }
    finally
    {
        waitHandle.Close();
        ThreadCount--;
        if (ThreadCount == 0)
        {
            m_quitHandle.Reset();
        }
    }
}

大约一半时，您将看到一个 source = WaitAny 调用，这是捕获该事件的地方。当调用上面片段中的事件时，它只是返回 1，这会将我们带到将 m_enabled 设置为 false 的 else，然后退出 while 循环并运行 finally堵塞。当所有线程都已退出并且完成时，finally 块会重置等待句柄。同样，非常简单，而且我认为没有任何悬念的潜力。

此时，我所能建议的就是将 Debug.Writeline 调用放入 LIT 源中，以查看您的用例中发生了什么。它可能会更多地揭示您的环境中发生的导致不良行为的原因。

请记住，处置 LIT 仍可能会使操作系统通知队列中的单个通知处于活动状态，因此注册的事件仍将再次触发。这仍然应该具有零影响，因为我们不再监听它，所以它只会在没有听众的情况下触发，这不是问题。