c# - nrules - Buscando reglas simples: biblioteca de motores en.NET

rete algorithm c#

Question

¿Alguien sabe de una buena biblioteca de reglas de biblioteca .NET (idealmente de código abierto)? Necesito algo que pueda hacer expresiones lógicas anidadas, por ejemplo, (A y B) Y (B o C o D). Necesito hacer comparaciones de las propiedades del objeto, por ej., A.P1 Y B.P1. (Idealmente, podría comparar cualquier propiedad - A.P1 Y B.P2).

Debe almacenar las reglas en una base de datos (tengo mucha lógica configurable simple). Y debe tener una API de creación / administración de reglas. La herramienta de gestión debería inspeccionar las instancias para determinar qué propiedades están disponibles y qué restricciones existen.

¡Gracias!

Oh, una cosa más. Como motor de reglas, necesito incluir el concepto de Acciones (Comandos). Estos son los que se ejecutan cuando la expresión regresa:

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

Entonces veo una regla como algo así como:

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

Answer 1

Aquí hay una clase que he usado en el pasado. Evalúa cadenas al igual que eval () en Javascript.

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

Todo lo que necesita hacer es construir una cadena para evaluar desde sus objetos comerciales y esto se encargará de todas las complicadas lógicas anidadas, 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
  }    
}

Answer 2

Bueno, dado que la expresión lógica es solo un subconjunto de la expresión matemática, es posible que desee probar NCalc - Evaluador de Expresiones Matemáticas para .NET over en CodePlex.

Answer 3

Dependiendo de lo que esté tratando de hacer, usar expresiones Lambda (y árboles de expresión) puede funcionar para este concepto. Esencialmente, usted proporciona una expresión como una cadena que luego se compila sobre la marcha en un árbol de expresiones / expresiones lambda, que luego puede ejecutar (evaluar). No es fácil de entender al principio, pero una vez que lo haces es extremadamente potente y bastante fácil de configurar.

Answer 4

Eche un vistazo a Logician: tutorial/overview en CodeProject

Proyecto: page/source en SourceForge

Answer 5

Estoy de acuerdo con la voluntad que diría usar algo de la familia de motores de flujo de trabajo, aunque no flujo de trabajo. Examine un poco el espacio de nombres de System.Workflow.Activities.Rules : es compatible con .Net 3 y está integrado en .Net3.5. Tienes todo a mano de forma gratuita para utilizar como lo has mencionado:

• RuleCondition para condiciones, RuleAction para acciones

• formato estandarizado para describir el metacódigo (CodeDom - CodeExpressions)

• puede agregar cualquier tipo de complejidad en eso (a decir verdad, excepto Linq y lambdas y, por lo tanto, métodos de extensión) a través de TypeProviders

• hay un editor incorporado para la edición de reglas con intellisense

• como la regla es serializable, puede ser fácilmente persistida

• si pretendía usar las reglas sobre un esquema de base de datos, entonces a través de typeprovider también se puede implementar

Para empezar: usar reglas fuera de un flujo de trabajo

Ps .: lo estamos usando extensamente y hay mucho más en ese espacio de nombres de lo que imaginaste -> un lenguaje de meta algoritmo completo

Y lo más importante: es fácil de usar, realmente

Answer 6

He usado este http://www.codeproject.com/KB/recipes/Flee.aspx con éxito en el pasado. Darle una oportunidad.

Answer 7

La solución oficial de MS para esto es Windows Workflow . Aunque no lo llamaría "simple", cumple con todas sus especificaciones (lo que requeriría un amplio marco de trabajo para cumplir, de todos modos).

Answer 8

Me gustaría ver Windows Workflow. Los motores de reglas y el flujo de trabajo tienden a comenzar de manera simple y progresivamente a ser más complejos. Algo como Windows Workflow Foundation no es demasiado difícil para comenzar y proporciona espacio para el crecimiento. Aquí hay una publicación que muestra que no es muy difícil conseguir un motor de flujo de trabajo simple.

Answer 9

Ninguno de los motores .NET de fuente abierta tiene soporte para almacenar reglas en la base de datos. Los únicos que almacenaron las reglas en una base de datos son comerciales. He creado algunas interfaces de usuario para motores de reglas personalizadas que se ejecutan en la base de datos, pero esto puede ser no trivial para implementar. Esa suele ser la razón principal por la que no verá esa función de forma gratuita.

Hasta donde yo sé, ninguno de ellos cumplirá con todos sus criterios, pero aquí hay una lista de los que conozco:

El más simple es SRE
http://sourceforge.net/projects/sdsre/

Uno con la interfaz de usuario de administración de reglas es NxBRE
http://www.agilepartner.net/oss/nxbre/

Drools.NET usa las reglas de JBOSS
http://droolsdotnet.codehaus.org/

Yo personalmente no he usado ninguno de ellos, porque todos los proyectos con los que trabajé nunca quisieron usar algo construido internamente. La mayoría de los negocios piensan que esto es bastante fácil de hacer, pero terminan perdiendo demasiado tiempo codificándolo e implementándolo. Esta es una de esas áreas que gobierna el Síndrome No Inventado Aquí (NIH).

Answer 10

No es gratis, ya que no puede desenredarlo fácilmente de su origen BizTalk, pero los componentes de Business Rules Engine de BizTalk son una entidad separada del motor principal de BizTalk, y comprenden un motor de reglas muy poderoso que incluye reglas / políticas basadas GUI. Si hubiera una versión gratuita de esto, se ajustaría a sus requisitos (comprar BizTalk solo para el BRE no funcionaría comercialmente).

Answer 11

Pruebe http://rulesengine.codeplex.com/

Es un motor de reglas de código abierto de C # que funciona con árboles de expresiones.

Answer 12

Puede usar un RuEn, un motor de reglas basado en atributos de fuente abierta simple creado por mí:

http://ruen.codeplex.com

Answer 13

Tal vez revise SmartRules . No es gratis, pero la interfaz parece bastante simple.

Solo sé al respecto porque he utilizado la utilidad codegen SmartCode desde allí anteriormente.

Aquí hay una regla de ejemplo del sitio web:

BUSINESS RULES IN NATURAL LANGUAGE      

Before
If (Customer.Age > 50 && Customer.Status == Status.Active) {
policy.SetDiscount(true, 10%);
}

After (with Smart Rules)
If Customer is older than 50 and
the Customer Status is Active Then
Apply 10 % of Discount

Answer 14

También puede consultar nuestro producto en http://www.FlexRule.com

FlexRule es un framework de Business Rule Engine con soporte para tres motores; Motor de procedimiento, motor de inferencia y motor RuleFlow. Su motor de inferencia es una inferencia de encadenamiento hacia delante que utiliza una implementación mejorada del algoritmo Rete.

Answer 15

Windows Workflow Foundation le ofrece un motor de inferencia de encadenamiento directo. Y puede usarlo sin la parte del flujo de trabajo. Crear y editar reglas está bien para los desarrolladores.

Si desea que los no programadores editen y mantengan las reglas, puede probar Rule Manager .

Rule Manager generará una solución visual de estudio visual para usted. Eso debería comenzar bastante rápido. Simplemente haga clic en Archivo / Exportar y seleccione el formato WFRules.