À procura de uma biblioteca de motores de regras simples in.NET [fechado]

• Regras relativas às condições , regras relativas às acções

• Formato normalizado para a descrição metacode (CodeDom-Codeexpressões)

• Tu. pode plugin qualquer tipo de complexidade para isso (a verdade) LINQ e lambdas e so extension métodos de algum tipo) via Fornecedores de dactilógrafos

• Há um editor de compilação para a regra edição com intellisense

• Como a regra é serializável pode ser persistir facilmente

• se pretendeu usar as regras sobre um esquema de bases de dados então via typeprovider também pode ser implementado

Para iniciador : usando regras fora de uma fluxo de trabalho

Ps.: nós estamos usando extensivamente e há muito mais nesse espaço de nomes do que você já imaginou -> uma linguagem meta algoritmo completo

E o mais importante : é fácil de usar - realmente

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

Tudo o que você precisa fazer é construir uma string para ser avaliada a partir de seus objetos de negócio e isso irá cuidar de toda a complicada lógica aninhada 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
  }    
}

Nenhum motor de regras open source.NET tem suporte para armazenar regras na base de dados. Os únicos que armazenaram as regras em uma base de dados são comerciais. Eu criei alguns UIs para motores de regras personalizados que funcionam fora do banco de dados, mas isso pode ser não-trivial para implementar. Essa é geralmente a principal razão pela qual você não vai ver esse recurso de graça.

O mais simples é SRE
http://sourceforge.net/projects/sdsre/

Drools.NET usa as regras JBOSS
http://droolsdotnet.codehaus.org/

Bem, dado que a expressão lógica é apenas um subconjunto de expressão matemática, poderá querer tentar Ncalc - Avaliador de Expressões Matemáticas para o.NET sobre o CodePlex.

A solução oficial em para isto é Windows Workflow. Embora eu não o chamaria de "simples", ele atende todas as suas especificações (o que exigiria uma estrutura extensa para atender, de qualquer forma).

Já usei isto http://www.codeproject.com/KB/recipes/Flee.aspx com sucesso no passado. Experimenta.

A Fundação Windows Workflow dá-lhe um motor de inferência livre para a frente. E você pode usá-lo sem a parte do fluxo de trabalho. Criar e editar regras é ok para os desenvolvedores.

Se quiser que os não-programadores editem e mantenham as regras, poderá experimentar o Gestor de regras .

Você pode dar uma olhada no nosso produto também em http://www.FlexRule.com

FlexRule é um motor de regras de negócio com suporte para três motores; Motor de procedimento, motor de inferência e motor RuleFlow. Seu motor de inferência é uma inferência em cadeia avançada que usa a implementação melhorada do algoritmo Rete.

Talvez verSmartRules . Não é livre, mas a interface parece simples o suficiente.

Aqui está uma regra de exemplo do Site:

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

Pode usar um RuEn, um simples motor de regras baseado em atributos abertos criado por mim:

Http://ruen.codeplex.com

Experimenta. http://rulesengine.codeplex.com/

Veja o Lógico: tutorial / overview no CodeProject

Project: page / source on SourceForge

Dependendo do que você está tentando fazer usando expressões Lambda (e árvores de expressão) pode funcionar para este conceito. Essencialmente, você fornece uma expressão como uma cadeia que é então compilada na mosca em uma árvore de expressão/expressão lambda, que você pode então executar (avaliar). Não é simples de entender no início, mas uma vez que você faz é extremamente poderoso e bastante simples de configurar.