Question

我有一个类根据变量的状态计算一些结果。

 class CalculateService
 {
      public int Num1;
      public int Num2;

      public void Num1Updated(int num1, Action<int> callback)
      {       

       var result = TimeConsumingFunction(Num1, Num2);
       callback(result;)

       } 

    public void Num2Updated(int num2, Action<int> callback)
    {        

      var result = TimeConsumingFunction(Num1, Num2);
      callback(result;)

    } 

 }

这个班级的消费者是另一个班级。该类侦听外部数据源。每次更改字段时，都会请求计算器计算结果。

    class SomeOtherClass
    {

       CalculateService serviceObj;

       void func()
      {
         ExternalData.Field1.Changed(x=>{serviceObj.Num1Updated(x, (res) => 
         {       
           UpdateUI(res);
         });

         ExternalData.Field2.Changed(x=>{serviceObj.Num2Updated(x, (res) => 
         {
           UpdateUI(res);
         });
       }
     }

问题：如果Field1和Field2在短时间内发生变化，则拨打TimeConsumingFunction()两次是浪费。我该如何解决这个问题？

也许我可以等几毫秒才打电话给TimeConsumingFunction()？

请注意，这里简化了问题。有两个以上的字段

Answer 1

事件方法似乎并不是最好的策略。我选择使用计时器以方便的间隔启动计划的计算。

在实际启动计算之前，您始终可以检查数据是否已更改，缓存上一个 tick 上的值。如果数据相同，则不做任何事情，等待下一个 tick 到处。

优点：您只会在数据有效时拨打TimeConsumingFucntion 改变。
缺点：您的用户界面无法更新＆＃34;实时＆＃34;，但是根据时间间隔，用户并不需要注意到差。

Answer 2

由于TimeConsumingFunction一侧的每次调用缓存看起来值实际上都会发生变化，因为如果使用以前的值，您将返回错误的结果。

因此，一种解决方案是从UI中提取数据而不是将其推送到UI。这样你就有一个地方可以限制通话。

类似的东西：

   ExternalData.Field1.Changed( _ => ScheduleUpdate());

   bool calculationInProgress = false;
   bool updatePending = false;
   void ScheduleUpdate()
   {
       updatePending = true;
       if (calculationInProgress)
       {
          return;
       }

       calculationInProgress = true;
       updatePending = false;
       service.ComputeAll(num1, num2,
          () => 
          {
                calculationInProgress = false;
                UpdateUI();       
                if (updatePending)
                {
                   ScheduleUpdate();
                }
          });
   }

保持状态以提高绩效

2 个答案: