À procura de uma biblioteca de motores de regras simples in.NET [fechado]
alguém conhece uma boa biblioteca de regras da biblioteca. net (idealmente open-source)? Eu preciso de algo que possa fazer expressões lógicas aninhadas, por exemplo, (A E B) e (B ou C ou D). Eu preciso fazer comparações de propriedades de objetos, por exemplo, A. P1 E B. P1. (Idealmente, eu poderia comparar qualquer propriedade -- A. P1 e B. P2).
ele deve armazenar as regras em um banco de dados (eu tenho um monte de lógica simples configurável). E deve ter uma API de criação de regras / gestão. A ferramenta de gestão teria de inspecionar as instâncias para determinar quais propriedades estão disponíveis e quais restrições existem.
Obrigado!Mais uma coisa. Como um motor de regras, eu preciso incluir o conceito de ações (comandos). Estes são os que executam quando a expressão retorna:
If (expression.Evaluation) { actions.Execute(); }
Então, vejo uma regra como algo do género:
class Rule
{
Expression Exp;
Actions[] Actions;
Run()
{
if(Exp.Evaluate())
{
foreach(action in Actions)
{
action.Execute();
}
}
}
}
15 answers
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.
Tanto quanto sei, nenhum deles irá cumprir todos os teus critérios,mas aqui está uma lista dos que conheço:O mais simples é SRE
http://sourceforge.net/projects/sdsre/
http://www.agilepartner.net/oss/nxbre/
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).
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 .
O Gestor de regras irá gerar uma solução visual studio funcional para si. Isso deve fazê-lo começar rapidamente. Basta carregar no ficheiro \ Export e seleccionar as regras WFRules formato.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.
Só sei disso Porque já usei o utilitário de códigos de código inteligente de lá antes.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:
Experimenta. http://rulesengine.codeplex.com/
É um motor C# Open-Source que funciona com árvores de expressão.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.