Recherche d'une bibliothèque de moteur de règles simple dans .NET
Quelqu'un connaît-il une bonne bibliothèque de règles de bibliothèque .NET (idéalement open-source)? J'ai besoin de quelque chose qui puisse faire des expressions logiques imbriquées, par exemple, (A ET B) ET (B OR C OR D). J'ai besoin de faire des comparaisons de les propriétés des objets, par exemple, A.P1 ET B.P1. (Idéalement, je pourrais comparer n'importe quelle propriété - A.P1 ET B.P2).
Il devrait stocker les règles dans une base de données (j'ai beaucoup de logique configurable simple). Et il devrait avoir une API de création/gestion de règles. L'outil de gestion devrait inspecter les instances pour déterminer quelles propriétés sont disponibles et quelles contraintes existent.
Merci!
Oh, encore une chose. En tant que moteur de règles, je dois inclure le concept d'actions (commandes). Voici ce qui s'exécute lorsque l'expression revient:
If (expression.Evaluation) { actions.Execute(); }
Je vois donc une règle comme quelque chose comme:
class Rule
{
Expression Exp;
Actions[] Actions;
Run()
{
if(Exp.Evaluate())
{
foreach(action in Actions)
{
action.Execute();
}
}
}
}
En accord avec la volonté, je dirais utiliser quelque chose de la famille des moteurs de workflow, mais pas un workflow. Examinez System.Workflow.Activities.Rules Espace de noms un peu - il est pris en charge dans .Net 3 et intégré à .Net3.5. Vous avez tout en main gratuitement à utiliser comme vous l'avez mentionné:
RuleCondition pour les conditions, RuleAction pour les actions
format normalisé pour décrire le métacode (CodeDom - CodeExpressions)
vous pouvez y brancher n'importe quel type de complexité (pour dire la vérité sauf Linq et lambdas et donc les méthodes d'extension d'une certaine sorte) via TypeProviders
il y a un éditeur intégré pour l'édition de règles avec intellisense
comme la règle est sérialisable, elle peut facilement persister
- si vous vouliez utiliser les règles sur un schéma de base de données, alors via typeprovider, il peut également être implémenté
Pour un débutant: tilisation de règles en dehors d'un workflow
Ps .: nous l'utilisons largement et il y a beaucoup plus dans cet espace de noms que vous ne l'imaginez -> un langage de méta algorithme complet
Et le plus important: il est facile à utiliser - vraiment
Voici une classe que j'ai utilisée dans le passé. Il évalue les chaînes comme eval () le fait en Javascript.
String result = ExpressionEvaluator.EvaluateToString("(2+5) < 8");
Tout ce que vous devez faire est de construire une chaîne à évaluer à partir de vos objets métier et cela prendra en charge toute la logique imbriquée compliquée, 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
}
}
Aucun des moteurs de règles .NET open source ne prend en charge le stockage des règles dans la base de données. Les seuls qui ont stocké les règles dans une base de données sont commerciaux. J'ai créé des interfaces utilisateur pour les moteurs de règles personnalisés qui fonctionnent à partir de la base de données, mais cela peut être non trivial à mettre en œuvre. C'est généralement la principale raison pour laquelle vous ne verrez pas cette fonctionnalité gratuitement.
Pour autant que je sache, aucun d'entre eux ne répondra à tous vos critères, mais voici une liste de ceux que je connais:
Le plus simple est SRE
http://sourceforge.net/projects/sdsre/
L'un avec l'interface de gestion des règles est NxBRE
http://www.agilepartner.net/oss/nxbre/
Drools.NET utilise les règles JBOSS
http://droolsdotnet.codehaus.org/
Personnellement, je n'en ai utilisé aucun, car tous les projets avec lesquels j'ai travaillé n'ont jamais voulu utiliser quelque chose de construit en interne. La plupart des entreprises pensent que c'est assez facile à faire, mais finissent par perdre trop de temps à le coder et à le mettre en œuvre. C'est l'un de ces domaines régis par le Syndrome non inventé ici (NIH).
Eh bien, puisque l'expression logique n'est qu'un sous-ensemble de l'expression mathématique, vous voudrez peut-être essayer NCalc - Évaluateur d'expressions mathématiques pour .NET sur CodePlex.
La solution MS officielle pour cela est Windows Workflow . Bien que je n'appellerais pas cela "simple", il répond à toutes vos spécifications (ce qui nécessiterait de toute façon un cadre complet).
J'ai utilisé cela http://www.codeproject.com/KB/recipes/Flee.aspx avec succès dans le passé. Essaie.
Windows Workflow Foundation vous offre un moteur d'inférence de chaînage direct gratuit. Et vous pouvez l'utiliser sans la partie workflow. La création et la modification de règles conviennent aux développeurs.
Si vous souhaitez que des non-programmeurs éditent et gèrent les règles, vous pouvez essayer Rule Manager .
Le gestionnaire de règles générera pour vous une solution de studio visuel fonctionnelle. Cela devrait vous permettre de démarrer assez rapidement. Cliquez simplement sur Fichier\Exporter et sélectionnez le format WFRules.
Vous pouvez également consulter notre produit sur http://www.FlexRule.com
FlexRule est une infrastructure de moteur de règles métier avec prise en charge de trois moteurs; Moteur procédural, moteur d'inférence et moteur RuleFlow. Son moteur d'inférence est une inférence de chaînage direct qui utilise une implémentation améliorée de l'algorithme Rete.
Je regarderais Windows Workflow. Les moteurs de règles et les workflows ont tendance à démarrer simplement et à devenir progressivement plus complexes. Quelque chose comme Windows Workflow Foundation n'est pas trop difficile à démarrer et offre une marge de croissance. Voici un article qui montre qu'il n'est pas trop difficile de lancer un moteur de workflow simple.
Jetez un oeil à Logician: tutorial/overview on CodeProject
Projet: page/source sur SourceForge
Peut-être consultez SmartRules . Ce n'est pas gratuit, mais l'interface semble assez simple.
Je ne le sais que parce que j'ai déjà utilisé l'utilitaire SmartCode codegen.
Voici un exemple de règle du site 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
Essayez http://rulesengine.codeplex.com/
Il s'agit d'un moteur de règles C # Open-Source qui fonctionne avec les arbres d'expression.
Vous pouvez utiliser un RuEn, un moteur de règles basé sur des attributs open source simple créé par moi:
Ce n'est pas gratuit, car vous ne pouvez pas facilement le démêler de sa parenté BizTalk, mais les composants du moteur de règles métier de BizTalk sont une entité distincte du moteur BizTalk de base lui-même, et comprennent un moteur de règles très puissant qui comprend une règle/stratégie basée GUI. S'il y avait une version gratuite de cela, cela répondrait à vos besoins (acheter BizTalk juste pour le BRE ne fonctionnerait pas vraiment commercialement.)
Selon ce que vous essayez de faire, l'utilisation d'expressions Lambda (et d'arbres d'expression) peut fonctionner pour ce concept. Essentiellement, vous fournissez une expression sous forme de chaîne qui est ensuite compilée à la volée dans une arborescence d'expression/expression lambda, que vous pouvez ensuite exécuter (évaluer). Ce n'est pas simple à comprendre au début, mais une fois que vous le faites, il est extrêmement puissant et assez simple à configurer.