在加工过程中,你可能会试图拆解时间,例如:

// Just in case someone wants to inherit your class and lock it as well ...
private static object _padlock = new object();
try
{
  serviceTimer.Stop(); 

  lock (_padlock)
    { 
        // do some heavy processing... 
    } 
}
finally
{
  serviceTimer.Start(); 
}

http://www.ohchr.org。 执行部分第1段没有具体说明,重新启用是否只是由时间推算,还是服务多读。 越晚,如果时间被拦截(AutoReset或人工操作)则不必再锁定。

You don t need the lock in this case. Set timer.AutoReset=false before starting it. Restart the timer in the handler after you are done with your processing. This will ensure that the timer fires 60 seconds after each task.

在其他答复方面也有类似的改动,使时间者能够保持定时,而且只能在能够打上锁时,而不是停止工作。

在以往活动中担任主管:

if (Monitor.TryEnter(locker)
{
    try
    {
        // Do your work here.
    }
    finally
    {
        Monitor.Exit(locker);
    }
}

进行快速检查,看看看服务是否运行。 如果它正在运行,它就会绕过这次事件,等待下一场火灾。

Timer serviceTimer = new Timer();
serviceTimer.Interval = 60;
serviceTimer.Elapsed += new ElapsedEventHandler(serviceTimer_Elapsed);
serviceTimer.Start();
bool isRunning = false;
void serviceTimer_Elapsed(object sender, ElapsedEventArgs e)
{
    lock (this)
    {
        if(isRunning)
            return;
        isRunning = true;
    }
    try
    {
    // do some heavy processing...
    }
    finally
    {
        isRunning = false;
    }
}

我建议你不要让时间在进行处理时打上。

Set the Timers AutoReset to false. And start it at the end. Here s a full answer you might be interested in Needed: A Windows Service That Executes Jobs from a Job Queue in a DB; Wanted: Example Code

其他选择可能是利用“后方工作”班,或“后方工作”班。

背景工作者很容易就目前仍在进行的处理进行选择检查,同时处理1个项目。 托马普勒将使你能够继续将各种物品(如有必要)排在背景线上。

根据您的描述,我假定你正在一个数据库中查询各个项目。 在这种情况下,我将利用ThreadPool把工作推向背景,而不是放慢/停止检查机制。

www.un.org/Depts/DGACM/index_spanish.htm 对于一个处,我确实建议你研究如何使用ThreadPool办法。 这样,你就可以每60秒与你的时间对新物品进行核对,然后对新物品进行盘问,让你去。 净数字显示,分配给每个项目的资金有多少,而且只是继续把这些项目推到桌面上。

<><>For Example>: 如果你只使用一台时间,你有5个新行,需要65秒的加处理时间。 采用ThreadPool办法,将在65秒中完成,有5个背景工作项目。 采用时间办法,这将需要4+分钟(你将在每行之间等待一分钟),这还可能导致对正在处理的其他工作的反馈。

这方面的一个例子是应如何做到这一点:

Timer serviceTimer = new Timer();
    void startTimer()
    {
        serviceTimer.Interval = 60;
        serviceTimer.Elapsed += new ElapsedEventHandler(serviceTimer_Elapsed);
        serviceTimer.AutoReset = false;
        serviceTimer.Start();
    }
    void serviceTimer_Elapsed(object sender, ElapsedEventArgs e)
    {
        try
        {
            // Get your rows of queued work requests

            // Now Push Each Row to Background Thread Processing
            foreach (Row aRow in RowsOfRequests)
            {
                ThreadPool.QueueUserWorkItem(
                    new WaitCallback(longWorkingCode), 
                    aRow);
            }
        }
        finally
        {
            // Wait Another 60 Seconds and check again
            serviceTimer.Stop();
        }
    }

    void longWorkingCode(object workObject)
    {
        Row workRow = workObject as Row;
        if (workRow == null)
            return;

        // Do your Long work here on workRow
    }

采用追溯性延期办法解决该问题的方法非常困难。 在这里,可以读到更完整的解释:。

public static IDisposable ScheduleRecurringAction(
    this IScheduler scheduler,
    TimeSpan interval,
    Action action)
{
    return scheduler.Schedule(
        interval, scheduleNext =>
    {
        action();
        scheduleNext(interval);
    });
}

TimeSpan interval = TimeSpan.FromSeconds(5);
Action work = () => Console.WriteLine("Doing some work...");

var schedule = Scheduler.Default.ScheduleRecurringAction(interval, work);          

Console.WriteLine("Press return to stop.");
Console.ReadLine();
schedule.Dispose();