CSLA0017 - Should it check for Add() Methods in Called Methods within Execute?

[mtavares628]

My code is triggering a bunch of warnings for analyzer CSLA0017 because I am calling the Add() methods from another method being called within Execute. My scenario for doing this is as follows:

My business object processes some rules differently based on a closing date field, where if there is a closing date then, my business rules should run with error severity, but otherwise the rules should run with warning severity. To set this up, I've created a chained rule that checks this field, and based on whether it is empty or not, it calls the same dependent rule, but passing in the severity when adding the rule. Then, I created a subclass of CommonBusinessRule that has a function that sets the context Add() method based on the severity.

So my Execute looks like this:

protected override void Execute(IRuleContext context)
            {
                int advLivingArrangmentID = context.GetInputValue<int>(AdvLivingArrangementIDProperty);
                string LivingArrangementExplanation = context.GetInputValue<string>(PrimaryProperty);
                if (string.IsNullOrEmpty(LivingArrangementExplanation))
                {
                    var cmd = DataPortal.Create<LivingArrangementRequiresExplanationCommand>(advLivingArrangmentID, NdrnCommon.GetUserAdvocacyGroup());
                    cmd = DataPortal.Execute<LivingArrangementRequiresExplanationCommand>(cmd);
                    if (cmd is object && cmd.RequiresExplanation)
                    {
                        SetContext(context, MessageText);
                    }
                }
            }

And the SetContext looks like this:

protected void SetContext(Csla.Rules.IRuleContext context, string desc)
        {
            SetContext(context, desc, Severity);
        }

        protected void SetContext(Csla.Rules.IRuleContext context, string desc, RuleSeverity sev)
        {
            switch (sev)
            {
                case RuleSeverity.Error:
                    {
                        context.AddErrorResult(desc);
                        break;
                    }

                case RuleSeverity.Information:
                    {
                        context.AddInformationResult(desc);
                        break;
                    }

                case RuleSeverity.Warning:
                    {
                        context.AddWarningResult(desc);
                        break;
                    }

                case RuleSeverity.Success:
                    {
                        context.AddSuccessResult(false);
                        break;
                    }

            }
        }

So my question is, should the analyzer be adjusted to check for those Add() methods in any called sub-methods, or should I just be relaxing that analyzer in my project?

[rockfordlhotka]

I suggest relaxing the analyzer in that file by using a #pragma

[mtavares628]

I can certainly do that, since I'm sure what I'm doing isn't a typical use case, but it also looks like this analyzer also gets triggered for Chained Rules as well:

protected override void Execute(IRuleContext context)
{
    SmartDate CloseDate = context.GetInputValue<SmartDate>(CloseDateProperty);
    SmartDate ClosingDatestamp = context.GetInputValue<SmartDate>(ClosingDateStampProperty);

    if (CloseDate.IsEmpty || !ClosingDatestamp.IsEmpty)
    {
        // If we haven't filled in the close date, or if the item has already been closed then it is only a warning
        var chainedContext = context.GetChainedContext(WarningInnerRule);

        WarningInnerRule.Execute(chainedContext);
    }
    else
    {
        var chainedContext = context.GetChainedContext(ErrorInnerRule);

        ErrorInnerRule.Execute(chainedContext);
    }
}

I would think that the analyzer should also take context.GetChainedContext() into account.

[rockfordlhotka]

I am not against such a change. I do need someone to learn how the analyzers work, as the original author has moved on to other things and is no longer available to maintain them.