c# - 实时、迭代应用架构

Question

很抱歉提出抽象问题，但我正在寻找一些关于在循环中执行一些等效操作的应用程序类型的示例/建议/文章，并且循环的每次迭代都应该在特定时间部分公开其结果(例如， 10 秒)。

我的应用程序在外部 WCF 服务和本地数据库之间进行数据同步。在每次迭代中，应用程序都会检索将请求传递给 WCF 服务的数据更改，并将更改放入数据库，反之亦然。此应用程序最严格的要求之一是迭代应每十秒触发一次。

那么问题就来了。我如何保证迭代将完成不超过 10 秒？

我猜这种类型的应用程序称为实时应用程序(以实时操作系统的方式)。

我们使用的 DAL 组件随机地对连接超时行为起作用。因此数据库操作可能需要超过 10 秒的时间。

这是一次迭代的估计代码:

        Stopwatch s1 = new Stopwatch();
        s1.Start();
        Parallel.ForEach(Global.config.databases, new ParallelOptions { MaxDegreeOfParallelism = -1 }, (l) =>            
        {
            Console.WriteLine("Started for {0}", l.key.name);                
            DB db = new DB(l.connectionString);

            DateTime lastIterationTS = GetPreviousIterationTS(l.id);

            ExternalService serv = new ExternalService(l.id);
            List<ChangedData> ChangedDataDb = db.GetChangedData(DateTime.Now.AddSeconds((lastIterationTS == DateTime.MinValue) ? -300 : -1 * (DateTime.Now - lastIterationTS).Seconds));

            List<Data> ChangedDataService = serv.GetModifiedData();                

                    Action syncDBChanges = new Action(() =>
                        {
                            // Изменения в БД                                   
                            foreach (ChangedData d in ChangedDataDb)
                            {
                                try
                                {
                                    // ...
                                    // analyzing & syncing
                                }
                                catch (Exception e)
                                {
                                    logger.InfoEx("Exception_SyncDatabase", e.ToString());
                                }
                            }
                        }
                    );

                    Action syncService = new Action(() =>
                    {                            
                        foreach (Data d in ChangedDataService)
                        {
                            try
                            {
                                // ...
                                // analyzing & syncing
                            }
                            catch (Exception e)
                            {
                                logger.InfoEx("Exception_SyncService", e.ToString());
                            }
                        }
                    });

                    List<WaitHandle> handles = new List<WaitHandle>();
                    IAsyncResult ar1 = syncDBChanges.BeginInvoke(syncDBChanges.EndInvoke, null);
                    IAsyncResult ar2 = syncService.BeginInvoke(syncService.EndInvoke, null);

                    handles.Add(ar1.AsyncWaitHandle);
                    handles.Add(ar2.AsyncWaitHandle);

                    WaitHandle.WaitAll(handles.ToArray(), (int)((Global.config.syncModifiedInterval - 1) * 1000));
                    SetCurrentIterationTS(l.id);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    logger.InfoEx("Exception_Iteration", e.ToString());
                    continue;
                }
            }
            logger.InfoEx("end_Iteration", IterationContextParams);
        }
        );
        s1.Stop();
        Console.WriteLine("Main iteration done for {0}...", s1.Elapsed);        

Answer 1

您可以考虑几个选项...

1. 如果迭代超过 10 秒，则终止该迭代，并希望下一次迭代能够完成该过程。这种方法的问题是很可能所有迭代都不会完成，因此同步过程永远不会发生。我会推荐以下选项...

2. 如果迭代花费的时间超过 10 秒，请等待它完成并跳过下一次迭代。这样您就可以确保该过程至少完成一次。以下是一个简化的代码示例，供引用...

   class Updater
   {
       Timer timer = new Timer();
       public object StateLock = new object();
       public string State;
   
       public Updater()
       {
           timer.Elapsed += timer_Elapsed;
           timer.Interval = 10000;
           timer.AutoReset = true;
           timer.Start();
       }
   
       void timer_Elapsed(object sender, ElapsedEventArgs e)
       {
           if (State != "Running")
           {
               Process();
           }
       }
   
       private void Process()
       {
           try
           {
               lock (StateLock)
               {
                   State = "Running";
               }
   
               // Process
   
               lock (StateLock)
               {
                   State = "";
               }
           }
           catch
           {
               throw;
           }
       }
   }
   

...

class Program
{
    static void Main(string[] args)
    {
        Updater updater = new Updater();
        Console.ReadLine();
    }
}