我有一个db表，存储如下:
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")
由于对象的属性，如'年龄'或'user_name'存储在表中，以及比较操作符'great_than'和'equal'，我怎么可能做到这一点?
c#是一种静态类型语言，所以不知道该如何发展。
如果你只有少量的属性和操作符，那么阻力最小的方法就是将所有检查都编码为如下的特殊情况:
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，对象>。
如果在编译时不知道属性的名称，或者希望避免每个属性的特殊情况，并且不想使用表方法，则可以使用反射来获取属性。例如:
var value = user.GetType().GetProperty("age").GetValue(user, null);
但是由于TargetValue可能是一个字符串，如果有必要，您需要注意从规则表进行类型转换。
如果你只有少量的属性和操作符，那么阻力最小的方法就是将所有检查都编码为如下的特殊情况:
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，对象>。
如果在编译时不知道属性的名称，或者希望避免每个属性的特殊情况，并且不想使用表方法，则可以使用反射来获取属性。例如:
var value = user.GetType().GetProperty("age").GetValue(user, null);
但是由于TargetValue可能是一个字符串，如果有必要，您需要注意从规则表进行类型转换。
我为和或规则之间添加了实现
我添加了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
}
我有另一个类编译ruleExpression到一个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);
}
}
反思是最通用的答案。你有三列数据，它们需要以不同的方式处理:
字段名。反射是从编码字段名中获取值的方法。
比较运算符。它们的数量应该是有限的，因此case语句应该最容易处理它们。特别是其中一些(有一个或多个)稍微复杂一些。
你的比较值。如果这些都是直值，那么这很容易，尽管您需要将多个条目分开。但是，如果它们也是字段名，也可以使用反射。
我会采取这样的方法:
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 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)));
