public static RuleMethod CreateRuleMethod(Type pTargetType, string pPropertyName, object pMissingValue) { PropertyRequiredRuleArgs args = new PropertyRequiredRuleArgs(pTargetType, pPropertyName); RuleMethod rule = new RuleMethod(PropertyRequiredHandler, args); return(rule); }
private void CheckRuleX(RuleMethod pRule) { bool passed = pRule.Invoke(mTarget); if (passed) { BrokenRulesX.Remove(pRule.RuleName); } else { BrokenRulesX.Add(pRule); } }
/// <summary>Check a particular RuleMethod.</summary> public void CheckRule(RuleMethod rule) { if (!Enabled) { return; } if (rule is MultiPropertyRuleMethod) { CheckMultiPropertyRuleX((MultiPropertyRuleMethod)rule); } else { CheckRuleX(rule); } }
/// <summary>Creates and adds a RuleMethod to the list of rules to be enforced.</summary> /// <param name="pHandler">The handler that implements the rule. Should be a static delegate.</param> /// <param name="pPropertyName">The property name of the target type, /// where the rule implementation can retrievethe value to be validated. /// </param> /// <returns>The added RuleMethod.</returns> /// <remarks> /// <para> /// A rule is implemented by a method which conforms to the /// method signature defined by the RuleHandler delegate. /// </para><para> /// The propertyName may be used by the method that implements the rule /// in order to retrieve the value to be validated. /// </para><para> /// If the rule implementation is inside the target object class then it probably has /// direct access to all data (even though the handler is a static delegate). /// If the rule implementation is outside the target class /// then it will need to use reflection to dynamically invoke this property to retrieve /// the value to be validated. /// </para> /// </remarks> public RuleMethod Add(RuleHandler pHandler, string pPropertyName) { RuleMethod method = new RuleMethod(pHandler, pPropertyName); return(AddX(pPropertyName, method)); }
/// <summary>Remove a specific rule from the rule list.</summary> public void Remove(RuleMethod pMethod) { Remove(pMethod.RuleHandler, pMethod.RuleArgs); }
private RuleMethod AddX(string pPropertyName, RuleMethod pMethod) { GetRulesForProperty(pPropertyName).Add(pMethod); return(pMethod); }
/// <summary>Adds the RuleMethod to the list of rules to be enforced.</summary> /// <param name="pMethod">The RuleMethod that implements the rule.</param> /// <returns>The added RuleMethod.</returns> /// <remarks> /// A rule is implemented by a method which conforms to the /// method signature defined by the RuleHandler delegate. /// </remarks> public RuleMethod Add(RuleMethod pMethod) { return(AddX(pMethod.RuleArgs.PropertyName, pMethod)); }
/// <summary>Creates and adds a RuleMethod to the list of rules to be enforced.</summary> /// <param name="pHandler">The handler that implements the rule. Should be a static delegate.</param> /// <param name="args"> /// A RuleArgs object specifying the property name (or group name) and other arguments /// passed to the rule method</param> /// <returns>The added RuleMethod.</returns> /// <remarks> /// A rule is implemented by a delegate which conforms to the /// method signature defined by the RuleHandler delegate. /// </remarks> public RuleMethod Add(RuleHandler pHandler, RuleArgs args) { RuleMethod method = new RuleMethod(pHandler, args); return(AddX(args.PropertyName, method)); }
internal BrokenRule(RuleMethod rule) : this(rule.RuleName, rule.RuleArgs.Description, rule.RuleArgs.PropertyName, null) { }
public static RuleMethod Add(RuleList pRuleList, string pPropertyName) { RuleMethod rule = CreateRuleMethod(pRuleList.TargetType, pPropertyName); return(pRuleList.Add(rule)); }
/// <summary>Create BrokenRule from this RuleMethod and add it to the collection .</summary> /// <remarks>Removes any previous version of this rule first.</remarks> internal void Add(RuleMethod pRule) { Remove(pRule.RuleName); Add(new BrokenRule(pRule)); }