Looking for simple rules-engine library in .NET

Question

Does anyone know of a good .NET library rules library (ideally open-source)? I need something that can do nested logic expressions, e.g., (A AND B) AND (B OR C OR D). I need to do comparisons of object properties, e.g., A.P1 AND B.P1. (Ideally, I could compare any property -- A.P1 AND B.P2).

It should store the rules in a database (I've got a lot of simple configurable logic). And it should have a rule creation/management API. The management tool would have to inspect the instances to determine which properties are available and which constraints exist.

Thanks!

---

Oh, one more thing. As a rules-engine, I need to include the concept of Actions (Commands). These are what execute when the expression returns:

If (expression.Evaluation) { actions.Execute(); }

So I see a rule as something like:

class Rule
{
    Expression Exp;
    Actions[] Actions;
    Run() 
    { 
        if(Exp.Evaluate()) 
        { 
            foreach(action in Actions) 
            { 
                action.Execute(); 
            }
        } 
    }
}

Solution 1

Agreeing with will I would say use something from the workflow engine family although not workflow. Examine System.Workflow.Activities.Rules Namespace a little bit - it's supported in .Net 3, and built into .Net3.5. You have everything in hand for free to use like you mentioned :

• RuleCondition for conditions , RuleAction for actions

• standardized format for describing metacode (CodeDom - CodeExpressions)

• you can plugin any kind of complexity into that (to tell the truth except Linq and lambdas and so extension methods of some kind) via TypeProviders

• there's a builtin editor for rule editing with intellisense

• as the rule is serializable it can be easily persisted

• if you meant to use the rules over a database scheme then via typeprovider it can be implemented too

For a starter : Using rules outside of a workflow

Ps.: we're using it extensively and there're much more in that namespace than you ever imagine -> a complete meta algorithm language

And the most important : it's easy to use - really

Solution 2

Here is a class I have used in the past. It evaluates strings just like eval() does in Javascript.

String result = ExpressionEvaluator.EvaluateToString("(2+5) < 8");

All you need to do is construct a string to be evaluated from your business objects and this will take care of all the complicated nested logic etc.

using System;
using System.CodeDom.Compiler;
using System.Globalization;
using System.Reflection;
using Microsoft.JScript;

namespace Common.Rule
{
  internal static class ExpressionEvaluator
  {
    #region static members
    private static object _evaluator = GetEvaluator();
    private static Type _evaluatorType;
    private const string _evaluatorSourceCode =
        @"package Evaluator
            {
               class Evaluator
               {
                  public function Eval(expr : String) : String 
                  { 
                     return eval(expr); 
                  }
               }
            }";

    #endregion

    #region static methods
    private static object GetEvaluator()
    {
      CompilerParameters parameters;
      parameters = new CompilerParameters();
      parameters.GenerateInMemory = true;

      JScriptCodeProvider jp = new JScriptCodeProvider();
      CompilerResults results = jp.CompileAssemblyFromSource(parameters, _evaluatorSourceCode);

      Assembly assembly = results.CompiledAssembly;
      _evaluatorType = assembly.GetType("Evaluator.Evaluator");

      return Activator.CreateInstance(_evaluatorType);
    }

    /// <summary>
    /// Executes the passed JScript Statement and returns the string representation of the result
    /// </summary>
    /// <param name="statement">A JScript statement to execute</param>
    /// <returns>The string representation of the result of evaluating the passed statement</returns>
    public static string EvaluateToString(string statement)
    {
      object o = EvaluateToObject(statement);
      return o.ToString();
    }

    /// <summary>
    /// Executes the passed JScript Statement and returns the result
    /// </summary>
    /// <param name="statement">A JScript statement to execute</param>
    /// <returns>The result of evaluating the passed statement</returns>
    public static object EvaluateToObject(string statement)
    {
      lock (_evaluator)
      {
        return _evaluatorType.InvokeMember(
                    "Eval",
                    BindingFlags.InvokeMethod,
                    null,
                    _evaluator,
                    new object[] { statement },
                    CultureInfo.CurrentCulture
                 );
      }
    }
    #endregion
  }    
}

Solution 3

None of the open sourced .NET rules-engine have support for storing rules in the database. The only ones that stored the rules in a database are commercial. I've created some UIs for custom rule engines that run off the database, but this can be non-trivial to implement. That's usually the main reason you won't see that feature for free.

As far as I know, none of them will meet all of your criteria, but here is a list of the ones I know of:

Simplest one is SRE
http://sourceforge.net/projects/sdsre/

One with rule management UI is NxBRE
http://www.agilepartner.net/oss/nxbre/

Drools.NET uses JBOSS rules
http://droolsdotnet.codehaus.org/

I personally haven't used any of them, because all of the projects I worked with never wanted to use something built in-house. Most business think that this is pretty easy to do, but end up wasting too much time coding and implementing it. This is one of those areas that the Not Invented Here Syndrome (NIH) rules.

Solution 4

Well, since logical expression are just a subset of mathematical expression, you may want to try NCalc - Mathematical Expressions Evaluator for .NET over on CodePlex.

Solution 5

I've used this http://www.codeproject.com/KB/recipes/Flee.aspx with success in the past. Give it a try.

View more solutions

Comments

[pmlarocque]

Drools.NET is not a good idea, depends on a JVM implementation in .Net still in beta, tried it, and it's really not production ready IMHO.

[Kurtz]

Has anyone here used SRE? What was the experience?

[Kurtz]

Hey, that's actually pretty neat. Although from the examples, I think there could be a more elegant way of evaluating delegate expressions. This could be the an extension point to insert some reflection on the expression operands.

[Kurtz]

Right, I understand the use of Lambda expressions and would use them if I were building this from scratch. But, I'm hoping the guts of this library already exists or can be cobbled together.

[Scott Dorman]

Not that I know of...there are several rules engine type libraries available but none of them are particularly simple and/or efficient and none make use of lambda expressions.

[Brian Scott]

great post, that's what we used in the past and found it pretty powerful to leverage the rules engine part outwith of all the windows workflow framework.

[Admin]

I tried your code on my web app. Unfortunatelly dynamic compilation doesn't work with web apps because of permissions on asp temp folder.

[Firestrand]

Defunct now. Try somewhere else.

[Chriseyre2000]

This is an improved serilizer for the WWF rules engine: github.com/chriseyre2000/perfectstorm/tree/master

[jayasurya_j]

The link provided in the answer is broken, please update