我有一个存储以下内容的数据库表：
RuleID objectProperty ComparisonOperator TargetValue
1 age 'greater_than' 15
2 username 'equal' 'some_name'
3 tags 'hasAtLeastOne' 'some_tag some_tag2'
现在假设我有这些规则的集合：
List<Rule> rules = db.GetRules();
现在我也有一个用户的实例：
User user = db.GetUser(....);
我将如何循环这些规则，并应用逻辑并执行比较等？
if(user.age > 15)
if(user.username == "some_name")
由于对象的属性(如"age"或"user_name"(与比较运算符"great_than"和"equal"一起存储在表中，我怎么可能这样做？
C# 是一种静态类型语言，因此不确定如何继续前进。
此代码段将规则编译为快速可执行代码(使用表达式树(，并且不需要任何复杂的 switch 语句：
(编辑：使用通用方法的完整工作示例(
public Func<User, bool> CompileRule(Rule r)
{
var paramUser = Expression.Parameter(typeof(User));
Expression expr = BuildExpr(r, paramUser);
// build a lambda function User->bool and compile it
return Expression.Lambda<Func<User, bool>>(expr, paramUser).Compile();
}
然后你可以写：
List<Rule> rules = new List<Rule> {
new Rule ("Age", "GreaterThan", "21"),
new Rule ( "Name", "Equal", "John"),
new Rule ( "Tags", "Contains", "C#" )
};
// compile the rules once
var compiledRules = rules.Select(r => CompileRule(r)).ToList();
public bool MatchesAllRules(User user)
{
return compiledRules.All(rule => rule(user));
}
以下是 BuildExpr 的实现：
Expression BuildExpr(Rule r, ParameterExpression param)
{
var left = MemberExpression.Property(param, r.MemberName);
var tProp = typeof(User).GetProperty(r.MemberName).PropertyType;
ExpressionType tBinary;
// is the operator a known .NET operator?
if (ExpressionType.TryParse(r.Operator, out tBinary)) {
var right = Expression.Constant(Convert.ChangeType(r.TargetValue, tProp));
// use a binary operation, e.g. 'Equal' -> 'u.Age == 21'
return Expression.MakeBinary(tBinary, left, right);
} else {
var method = tProp.GetMethod(r.Operator);
var tParam = method.GetParameters()[0].ParameterType;
var right = Expression.Constant(Convert.ChangeType(r.TargetValue, tParam));
// use a method call, e.g. 'Contains' -> 'u.Tags.Contains(some_tag)'
return Expression.Call(left, method, right);
}
}
请注意，我使用了"GreaterThan"而不是"greater_than"等 - 这是因为"GreaterThan"是运算符的 .NET 名称，因此我们不需要任何额外的映射。
如果您需要自定义名称，您可以构建一个非常简单的字典，并在编译规则之前翻译所有运算符：
var nameMap = new Dictionary<string, string> {
{ "greater_than", "GreaterThan" },
{ "hasAtLeastOne", "Contains" }
};
为简单起见，代码使用类型"用户"。可以将 User 替换为泛型类型 T，以便为任何类型的对象提供通用规则编译器。此外，代码应处理错误，例如未知的运算符名称。
请注意，甚至在引入表达式树 API 之前，使用 Reflection.Emit 就可以动态生成代码。方法LambdaExpression.Compile((在幕后使用Reflection.Emit(您可以使用ILSpy看到这一点(。
下面是一些按原样编译并完成工作的代码。基本上使用两个字典，一个包含从运算符名称到布尔函数的映射，另一个包含从 User 类型的属性名称到用于调用属性 getter(如果公共(的 PropertyInfos 的映射。将 User 实例和表中的三个值传递给静态 Apply 方法。
class User
{
public int Age { get; set; }
public string UserName { get; set; }
}
class Operator
{
private static Dictionary<string, Func<object, object, bool>> s_operators;
private static Dictionary<string, PropertyInfo> s_properties;
static Operator()
{
s_operators = new Dictionary<string, Func<object, object, bool>>();
s_operators["greater_than"] = new Func<object, object, bool>(s_opGreaterThan);
s_operators["equal"] = new Func<object, object, bool>(s_opEqual);
s_properties = typeof(User).GetProperties().ToDictionary(propInfo => propInfo.Name);
}
public static bool Apply(User user, string op, string prop, object target)
{
return s_operators[op](GetPropValue(user, prop), target);
}
private static object GetPropValue(User user, string prop)
{
PropertyInfo propInfo = s_properties[prop];
return propInfo.GetGetMethod(false).Invoke(user, null);
}
#region Operators
static bool s_opGreaterThan(object o1, object o2)
{
if (o1 == null || o2 == null || o1.GetType() != o2.GetType() || !(o1 is IComparable))
return false;
return (o1 as IComparable).CompareTo(o2) > 0;
}
static bool s_opEqual(object o1, object o2)
{
return o1 == o2;
}
//etc.
#endregion
public static void Main(string[] args)
{
User user = new User() { Age = 16, UserName = "John" };
Console.WriteLine(Operator.Apply(user, "greater_than", "Age", 15));
Console.WriteLine(Operator.Apply(user, "greater_than", "Age", 17));
Console.WriteLine(Operator.Apply(user, "equal", "UserName", "John"));
Console.WriteLine(Operator.Apply(user, "equal", "UserName", "Bob"));
}
}
我构建了一个规则引擎，它采用了与您在问题中概述的方法不同的方法，但我认为您会发现它比您当前的方法灵活得多。
您当前的方法似乎专注于单个实体"用户"，并且您的持久规则标识"属性名称"、"运算符"和"值"。 相反，我的模式将谓词(Func<T，bool>(的C#代码存储在数据库的"表达式"列中。 在当前设计中，使用代码生成，我从数据库中查询"规则"，并使用"规则"类型编译程序集，每个类型都有一个"测试"方法。 以下是实现每个规则的接口的签名：
public interface IDataRule<TEntity>
{
/// <summary>
/// Evaluates the validity of a rule given an instance of an entity
/// </summary>
/// <param name="entity">Entity to evaluate</param>
/// <returns>result of the evaluation</returns>
bool Test(TEntity entity);
/// <summary>
/// The unique indentifier for a rule.
/// </summary>
int RuleId { get; set; }
/// <summary>
/// Common name of the rule, not unique
/// </summary>
string RuleName { get; set; }
/// <summary>
/// Indicates the message used to notify the user if the rule fails
/// </summary>
string ValidationMessage { get; set; }
/// <summary>
/// indicator of whether the rule is enabled or not
/// </summary>
bool IsEnabled { get; set; }
/// <summary>
/// Represents the order in which a rule should be executed relative to other rules
/// </summary>
int SortOrder { get; set; }
}
表达式"在应用程序首次执行时编译为"Test"方法的主体。 如您所见，表中的其他列也显示为规则的第一类属性，以便开发人员可以灵活地为用户获取失败或成功通知的方式创建体验。
在应用程序期间，生成内存中程序集是 1 次，通过在评估规则时不必使用反射，因此可以提高性能。 在运行时检查表达式，因为如果属性名称拼写错误等，程序集将无法正确生成。
创建内存中程序集的机制如下：
- 从数据库加载规则
- 遍历规则和每个规则，使用 StringBuilder 和一些字符串连接编写表示从 IDataRule 继承的类的文本
- 使用 CodeDOM 编译 -- 更多信息
这实际上非常简单，因为对于大多数人来说，此代码是构造函数中的属性实现和值初始化。 除此之外，唯一的其他代码是表达式。
注意：由于 CodeDOM 中的限制，表达式必须是 .NET 2.0(无 lambda 或其他 C# 3.0 功能(存在限制。
下面是一些示例代码。
sb.AppendLine(string.Format("tpublic class {0} : SomeCompany.ComponentModel.IDataRule<{1}>", className, typeName));
sb.AppendLine("t{");
sb.AppendLine("ttprivate int _ruleId = -1;");
sb.AppendLine("ttprivate string _ruleName = "";");
sb.AppendLine("ttprivate string _ruleType = "";");
sb.AppendLine("ttprivate string _validationMessage = "";");
/// ...
sb.AppendLine("ttprivate bool _isenabled= false;");
// constructor
sb.AppendLine(string.Format("ttpublic {0}()", className));
sb.AppendLine("tt{");
sb.AppendLine(string.Format("tttRuleId = {0};", ruleId));
sb.AppendLine(string.Format("tttRuleName = "{0}";", ruleName.TrimEnd()));
sb.AppendLine(string.Format("tttRuleType = "{0}";", ruleType.TrimEnd()));
sb.AppendLine(string.Format("tttValidationMessage = "{0}";", validationMessage.TrimEnd()));
// ...
sb.AppendLine(string.Format("tttSortOrder = {0};", sortOrder));
sb.AppendLine("tt}");
// properties
sb.AppendLine("ttpublic int RuleId { get { return _ruleId; } set { _ruleId = value; } }");
sb.AppendLine("ttpublic string RuleName { get { return _ruleName; } set { _ruleName = value; } }");
sb.AppendLine("ttpublic string RuleType { get { return _ruleType; } set { _ruleType = value; } }");
/// ... more properties -- omitted
sb.AppendLine(string.Format("ttpublic bool Test({0} entity) ", typeName));
sb.AppendLine("tt{");
// #############################################################
// NOTE: This is where the expression from the DB Column becomes
// the body of the Test Method, such as: return "entity.Prop1 < 5"
// #############################################################
sb.AppendLine(string.Format("tttreturn {0};", expressionText.TrimEnd()));
sb.AppendLine("tt}"); // close method
sb.AppendLine("t}"); // close Class
除此之外，我确实创建了一个名为"DataRuleCollection"的类，它实现了ICollection>。 这使我能够创建"TestAll"功能和索引器，用于按名称执行特定规则。 下面是这两种方法的实现。
/// <summary>
/// Indexer which enables accessing rules in the collection by name
/// </summary>
/// <param name="ruleName">a rule name</param>
/// <returns>an instance of a data rule or null if the rule was not found.</returns>
public IDataRule<TEntity, bool> this[string ruleName]
{
get { return Contains(ruleName) ? list[ruleName] : null; }
}
// in this case the implementation of the Rules Collection is:
// DataRulesCollection<IDataRule<User>> and that generic flows through to the rule.
// there are also some supporting concepts here not otherwise outlined, such as a "FailedRules" IList
public bool TestAllRules(User target)
{
rules.FailedRules.Clear();
var result = true;
foreach (var rule in rules.Where(x => x.IsEnabled))
{
result = rule.Test(target);
if (!result)
{
rules.FailedRules.Add(rule);
}
}
return (rules.FailedRules.Count == 0);
}
更多代码：有人请求与代码生成相关的代码。 我将该功能封装在一个名为"RulesAssemblyGenerator"的类中，我将在下面介绍该类。
namespace Xxx.Services.Utils
{
public static class RulesAssemblyGenerator
{
static List<string> EntityTypesLoaded = new List<string>();
public static void Execute(string typeName, string scriptCode)
{
if (EntityTypesLoaded.Contains(typeName)) { return; }
// only allow the assembly to load once per entityType per execution session
Compile(new CSharpCodeProvider(), scriptCode);
EntityTypesLoaded.Add(typeName);
}
private static void Compile(CodeDom.CodeDomProvider provider, string source)
{
var param = new CodeDom.CompilerParameters()
{
GenerateExecutable = false,
IncludeDebugInformation = false,
GenerateInMemory = true
};
var path = System.Reflection.Assembly.GetExecutingAssembly().Location;
var root_Dir = System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "Bin");
param.ReferencedAssemblies.Add(path);
// Note: This dependencies list are included as assembly reference and they should list out all dependencies
// That you may reference in your Rules or that your entity depends on.
// some assembly names were changed... clearly.
var dependencies = new string[] { "yyyyyy.dll", "xxxxxx.dll", "NHibernate.dll", "ABC.Helper.Rules.dll" };
foreach (var dependency in dependencies)
{
var assemblypath = System.IO.Path.Combine(root_Dir, dependency);
param.ReferencedAssemblies.Add(assemblypath);
}
// reference .NET basics for C# 2.0 and C#3.0
param.ReferencedAssemblies.Add(@"C:WINDOWSMicrosoft.NETFrameworkv2.0.50727System.dll");
param.ReferencedAssemblies.Add(@"C:Program FilesReference AssembliesMicrosoftFrameworkv3.5System.Core.dll");
var compileResults = provider.CompileAssemblyFromSource(param, source);
var output = compileResults.Output;
if (compileResults.Errors.Count != 0)
{
CodeDom.CompilerErrorCollection es = compileResults.Errors;
var edList = new List<DataRuleLoadExceptionDetails>();
foreach (CodeDom.CompilerError s in es)
edList.Add(new DataRuleLoadExceptionDetails() { Message = s.ErrorText, LineNumber = s.Line });
var rde = new RuleDefinitionException(source, edList.ToArray());
throw rde;
}
}
}
}
如果有任何其他问题或意见或对进一步代码示例的要求，请告诉我。
反射是你最通用的答案。您有三列数据，需要以不同的方式处理它们：
-
您的字段名称。反射是从编码字段名称中获取值的方法。
-
您的比较运算符。这些应该有数量有限，因此案例陈述应该最容易处理它们。特别是因为它们中的一些(具有一个或多个(稍微复杂一些。
-
您的比较价值。如果这些都是直线值，那么这很容易，尽管您将多个条目分开。但是，如果它们也是字段名称，您也可以使用反射。
我会采取一种更像的方法：
var value = user.GetType().GetProperty("age").GetValue(user, null);
//Thank you Rick! Saves me remembering it;
switch(rule.ComparisonOperator)
case "equals":
return EqualComparison(value, rule.CompareTo)
case "is_one_or_more_of"
return IsInComparison(value, rule.CompareTo)
等等。
它使您可以灵活地添加更多选项进行比较。这也意味着您可以在 Compare 方法中编写可能需要的任何类型验证，并使它们根据需要复杂。这里还可以选择将 CompareTo 评估为对另一行的递归调用，或评估为字段值，可以像这样完成：
return IsInComparison(value, EvaluateComparison(rule.CompareTo))
这一切都取决于未来的可能性。
如果您只有少数属性和运算符，则阻力最小的路径是将所有检查编码为特殊情况，如下所示：
public bool ApplyRules(List<Rule> rules, User user)
{
foreach (var rule in rules)
{
IComparable value = null;
object limit = null;
if (rule.objectProperty == "age")
{
value = user.age;
limit = Convert.ToInt32(rule.TargetValue);
}
else if (rule.objectProperty == "username")
{
value = user.username;
limit = rule.TargetValue;
}
else
throw new InvalidOperationException("invalid property");
int result = value.CompareTo(limit);
if (rule.ComparisonOperator == "equal")
{
if (!(result == 0)) return false;
}
else if (rule.ComparisonOperator == "greater_than")
{
if (!(result > 0)) return false;
}
else
throw new InvalidOperationException("invalid operator");
}
return true;
}
如果您有很多属性，您可能会发现表驱动的方法更可口。 在这种情况下，您将创建一个静态Dictionary，将属性名称映射到与 Func<User, object> 匹配的委托。
如果在编译时不知道属性的名称，或者希望避免每个属性出现特殊情况，并且不想使用表方法，则可以使用反射来获取属性。 例如：
var value = user.GetType().GetProperty("age").GetValue(user, null);
但是由于TargetValue可能是一个string，如有必要，您需要注意从规则表中进行类型转换。
使用扩展方法的面向数据类型的方法怎么样：
public static class RoleExtension
{
public static bool Match(this Role role, object obj )
{
var property = obj.GetType().GetProperty(role.objectProperty);
if (property.PropertyType == typeof(int))
{
return ApplyIntOperation(role, (int)property.GetValue(obj, null));
}
if (property.PropertyType == typeof(string))
{
return ApplyStringOperation(role, (string)property.GetValue(obj, null));
}
if (property.PropertyType.GetInterface("IEnumerable<string>",false) != null)
{
return ApplyListOperation(role, (IEnumerable<string>)property.GetValue(obj, null));
}
throw new InvalidOperationException("Unknown PropertyType");
}
private static bool ApplyIntOperation(Role role, int value)
{
var targetValue = Convert.ToInt32(role.TargetValue);
switch (role.ComparisonOperator)
{
case "greater_than":
return value > targetValue;
case "equal":
return value == targetValue;
//...
default:
throw new InvalidOperationException("Unknown ComparisonOperator");
}
}
private static bool ApplyStringOperation(Role role, string value)
{
//...
throw new InvalidOperationException("Unknown ComparisonOperator");
}
private static bool ApplyListOperation(Role role, IEnumerable<string> value)
{
var targetValues = role.TargetValue.Split(' ');
switch (role.ComparisonOperator)
{
case "hasAtLeastOne":
return value.Any(v => targetValues.Contains(v));
//...
}
throw new InvalidOperationException("Unknown ComparisonOperator");
}
}
比你可以像这样评估：
var myResults = users.Where(u => roles.All(r => r.Match(u)));
虽然回答"如何实现规则引擎？(在 C# 中("问题是按顺序执行一组给定的规则，这通常被认为是一个幼稚的实现(并不意味着它不起作用：-(
在您的情况下，它似乎"足够好"，因为您的问题似乎更多的是"如何按顺序运行一组规则"，如果您配备了最新的 C# 版本，lambda/表达式树(Martin 的答案(无疑是最优雅的方式。
但是，对于更高级的方案，下面是指向实际上在许多商业规则引擎系统中实现的 Rete 算法的链接，以及指向 NRuler 的链接，该算法在 C# 中的实现。
马丁的回答相当不错。我实际上做了一个和他有相同想法的规则引擎。我很惊讶它几乎是一样的。我已经包含了他的一些代码来改进它。虽然我已经让它来处理更复杂的规则。
你可以看看 Yare.NET
或在Nuget中下载它
使用工作流规则引擎怎么样？
您可以在没有工作流的情况下执行 Windows 工作流规则见盖伊·伯斯坦的博客：http://blogs.microsoft.co.il/blogs/bursteg/archive/2006/10/11/RuleExecutionWithoutWorkflow.aspx
要以编程方式创建规则，请参阅 Stephen Kaufman 的 WebLog
http://blogs.msdn.com/b/skaufman/archive/2006/05/15/programmatically-create-windows-workflow-rules.aspx
我添加了规则和规则之间的实现我添加了类 RuleExpression，它表示树的根，可以是叶子是简单的规则，也可以是和，或二进制表达式，因为它们没有规则并且有表达式：
public class RuleExpression
{
public NodeOperator NodeOperator { get; set; }
public List<RuleExpression> Expressions { get; set; }
public Rule Rule { get; set; }
public RuleExpression()
{
}
public RuleExpression(Rule rule)
{
NodeOperator = NodeOperator.Leaf;
Rule = rule;
}
public RuleExpression(NodeOperator nodeOperator, List<RuleExpression> expressions, Rule rule)
{
this.NodeOperator = nodeOperator;
this.Expressions = expressions;
this.Rule = rule;
}
}
public enum NodeOperator
{
And,
Or,
Leaf
}
我有另一个类将规则表达式编译为一个Func<T, bool>:
public static Func<T, bool> CompileRuleExpression<T>(RuleExpression ruleExpression)
{
//Input parameter
var genericType = Expression.Parameter(typeof(T));
var binaryExpression = RuleExpressionToOneExpression<T>(ruleExpression, genericType);
var lambdaFunc = Expression.Lambda<Func<T, bool>>(binaryExpression, genericType);
return lambdaFunc.Compile();
}
private static Expression RuleExpressionToOneExpression<T>(RuleExpression ruleExpression, ParameterExpression genericType)
{
if (ruleExpression == null)
{
throw new ArgumentNullException();
}
Expression finalExpression;
//check if node is leaf
if (ruleExpression.NodeOperator == NodeOperator.Leaf)
{
return RuleToExpression<T>(ruleExpression.Rule, genericType);
}
//check if node is NodeOperator.And
if (ruleExpression.NodeOperator.Equals(NodeOperator.And))
{
finalExpression = Expression.Constant(true);
ruleExpression.Expressions.ForEach(expression =>
{
finalExpression = Expression.AndAlso(finalExpression, expression.NodeOperator.Equals(NodeOperator.Leaf) ?
RuleToExpression<T>(expression.Rule, genericType) :
RuleExpressionToOneExpression<T>(expression, genericType));
});
return finalExpression;
}
//check if node is NodeOperator.Or
else
{
finalExpression = Expression.Constant(false);
ruleExpression.Expressions.ForEach(expression =>
{
finalExpression = Expression.Or(finalExpression, expression.NodeOperator.Equals(NodeOperator.Leaf) ?
RuleToExpression<T>(expression.Rule, genericType) :
RuleExpressionToOneExpression<T>(expression, genericType));
});
return finalExpression;
}
}
public static BinaryExpression RuleToExpression<T>(Rule rule, ParameterExpression genericType)
{
try
{
Expression value = null;
//Get Comparison property
var key = Expression.Property(genericType, rule.ComparisonPredicate);
Type propertyType = typeof(T).GetProperty(rule.ComparisonPredicate).PropertyType;
//convert case is it DateTimeOffset property
if (propertyType == typeof(DateTimeOffset))
{
var converter = TypeDescriptor.GetConverter(propertyType);
value = Expression.Constant((DateTimeOffset)converter.ConvertFromString(rule.ComparisonValue));
}
else
{
value = Expression.Constant(Convert.ChangeType(rule.ComparisonValue, propertyType));
}
BinaryExpression binaryExpression = Expression.MakeBinary(rule.ComparisonOperator, key, value);
return binaryExpression;
}
catch (FormatException)
{
throw new Exception("Exception in RuleToExpression trying to convert rule Comparison Value");
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
我已经为用dotnet编写的丰富且高性能的规则引擎创建了一个包，请查看此存储库以获取更多信息。安装后，您可以像以下一样简单地使用它：
var engine = new RulesService<TestModel>(new RulesCompiler(), new LazyCache.Mocks.MockCachingService());
var matchingRules = engine.GetMatchingRules(
new TestModel { NumericField = 5 },
new[] {
new RulesConfig {
Id = Guid.NewGuid(),
RulesOperator = Rule.InterRuleOperatorType.And,
RulesGroups = new RulesGroup[] {
new RulesGroup {
RulesOperator = Rule.InterRuleOperatorType.And,
Rules = new[] {
new Rule {
ComparisonOperator = Rule.ComparisonOperatorType.Equal,
ComparisonValue = 5.ToString(),
ComparisonPredicate = nameof(TestModel.NumericField)
}
}
}
}
}
});