Who should execute Child Object Business Rules

Reply

JonnyBee replied on Sat, Jun 2 2012 1:41 AM

rated by 0 users

MarcBoissonneault:

public DateTime Start
{
       get { return GetProperty(StartProperty); }
       set
       {
                ((ICheckRules)this).SuppressRuleChecking();
                SetProperty(StartProperty, value.Date);
                ((ICheckRules)this).ResumeRuleChecking();
        }
}

This is the same as:

public DateTime Start
{
       get { return GetProperty(StartProperty); }
       set { LoadProperty(StartProperty, value.Date); }
}

My preference is to make "expensive rule" into async rules.

The primary goal of Business Rules is to

• give user feedback on errors as soon as possible after edit
• only execute relevant rules for the edit made

So the expensive rule should

• run asyncronously on the client (CanRunInCheckRules = false, CanRunAsAffectedProperty = false)
• if you do NOT trust the data in the database then run expensive rule synchronously in data access)

Imagine a list of N Bar items and you execute all rules for each bar - no matter if the user has made an edit to one, two or all items? That would really slow down your app, wouldn't it?

So I would consider to add an CPUIntensiveCommand with async dataportal call:

  [Serializable]
  public class CPUIntensiveCommand : CommandBase<CPUIntensiveCommand>
  {
 
    //public static readonly PropertyInfo<string> Param1Property = RegisterProperty<string>(c => c.Param1);
    //public string Param1
    //{
    //  get { return ReadProperty(Param1Property); }
    //  private set { LoadProperty(Param1Property, value); }
    //}
 
    public static readonly PropertyInfo<int> ResultProperty = RegisterProperty<int>(c => c.Result);
    public int Result
    {
      get { return ReadProperty(ResultProperty); }
      private set { LoadProperty(ResultProperty, value); }
    }
 
    #region Factory Methods
 
    public static void BeginExecute(string param1, object userState, EventHandler<DataPortalResult<CPUIntensiveCommand>> callback)
    {
      var cmd = new CPUIntensiveCommand();
      // cmd.Param = param1;
      DataPortal.BeginExecute<CPUIntensiveCommand>(cmd, callback, userState);
    }
 
    public static CPUIntensiveCommand Execute(string param1)
    {
      CPUIntensiveCommand cmd = new CPUIntensiveCommand();
      // cmd.Param = param1;
      return DataPortal.Execute<CPUIntensiveCommand>(cmd);
    }
 
    public CPUIntensiveCommand()
    { /* require use of factory methods */ }
 
    #endregion
 
    #region Server-side Code
 
    private static int count = 0;
 
    protected void DataPortal_Execute()
    {
      Thread.Sleep(2500);
 
      count++;
      Result = count;
    }
 
    #endregion
  }

and make the rule run asyncronously
  public class CPUIntensiveRule : PropertyRule
  {
    public CPUIntensiveRule(IPropertyInfo primaryProperty, string errorMessage)
      : base(primaryProperty)
    {
      MessageText = errorMessage;
      CanRunAsAffectedProperty = false;
      CanRunInCheckRules = false;
      IsAsync = true;
    }
 
    protected override void Execute(RuleContext context)
    {
        CPUIntensiveCommand.BeginExecute(string.Empty, context, Complete);
    }
 
    private void Complete(object sender, DataPortalResult<CPUIntensiveCommand> e)
    {
      var context = (RuleContext) e.UserState;
      if (e.Object.Result % 3 == 1)
        context.AddErrorResult(PrimaryProperty, GetMessage());
      context.Complete();
     }
  }

And you should also look at Csla.Xaml.ViewModelBase to show an indicator to the user that 
the object is "busy" and get "bindable" meta properties (CanSave, IsDirty etc).