/// <summary> /// Creates a Rules Engine. /// </summary> /// <param name="basedOn">Copies specific rules from base Engine</param> /// <param name="types">Copies rules for the specified types only.</param> public RulesEngine(RulesEngine basedOn, params Type[] types) { if (types == null) { throw new ArgumentNullException("types"); } if (basedOn == null) { throw new ArgumentNullException("basedOn"); } var registry = basedOn._registry.Clone(); _expressionCache = basedOn._expressionCache; foreach (var type in types) { var invokers = registry.GetInvokers(type); foreach (var invoker in invokers) { _registry.RegisterInvoker(invoker); } } }
public EnumerableCompositionInvoker(RulesEngine rulesRulesEngine, Expression <Func <T, R> > enumerableCompositionExpression) { this.rulesRulesEngine = rulesRulesEngine; _compiledExpression = enumerableCompositionExpression.Compile(); _enumerableCompositionExpression = rulesRulesEngine.ExpressionCache.Get(enumerableCompositionExpression); }
internal ForClass(RulesEngine rulesRulesEngine) { this.rulesRulesEngine = rulesRulesEngine; }
internal SetupClassEndIf(RulesEngine rulesRulesEngine, ForClassEndIf <T, ENDIF> parent, Expression <Func <T, R> > expression) { _expression = expression; _parent = parent; this.rulesRulesEngine = rulesRulesEngine; }
internal SetupClass(RulesEngine rulesRulesEngine, ForClass <T> parent, Expression <Func <T, R> > expression) { this.expression = expression; this.parent = parent; this.rulesRulesEngine = rulesRulesEngine; }
public static M CallValidateForEachElement <M, T, R>(this IMustPassRule <M, T, R> mpr, RulesEngine usingRulesEngine) where R : IEnumerable where M : ISetupClass { mpr.RulesRulesEngine.RegisterEnumerableComposition(mpr.Expression, usingRulesEngine); return(mpr.GetSelf()); }
public static M CallValidate <M, T, R>(this IMustPassRule <M, T, R> mpr, RulesEngine usingRulesEngine) where M : ISetupClass { usingRulesEngine.RegisterComposition(mpr.Expression, usingRulesEngine); return(mpr.GetSelf()); }
internal ForClassElseEndIf(RulesEngine rulesRulesEngine, ConditionalInvoker <T> conditionalInvoker, ENDIF parent) { this.rulesRulesEngine = rulesRulesEngine; this.parent = parent; this.conditionalInvoker = conditionalInvoker; }
public ConditionalInvoker(Expression <Func <T, bool> > conditionalExpression, RulesEngine parent) { condition = conditionalExpression.Compile(); this.parent = parent; this.innerTrue = new RulesEngine(); this.innerFalse = new RulesEngine(); }
public static void RegisterEnumerableComposition <T, R>(this IRegisterInvoker register, Expression <Func <T, R> > enumerableCompositionExpression, RulesEngine usingRulesEngine) where R : IEnumerable { var enumerableCompositionInvoker = new EnumerableCompositionInvoker <T, R>(usingRulesEngine, enumerableCompositionExpression); register.RegisterInvoker(enumerableCompositionInvoker); }
public static void RegisterComposition <T, R>(this IRegisterInvoker register, Expression <Func <T, R> > compositionExpression, RulesEngine usingRulesEngine) { var compositionInvoker = new CompositionInvoker <T, R>(usingRulesEngine, compositionExpression); register.RegisterInvoker(compositionInvoker); }
public CompositionInvoker(RulesEngine rulesRulesEngine, Expression <Func <T, R> > compositionExpression) { this.rulesRulesEngine = rulesRulesEngine; this.compiledExpression = compositionExpression.Compile(); this.cachedExpression = rulesRulesEngine.ExpressionCache.Get(compositionExpression); }