/// <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);
}
