将此C＃代码重构为更加优雅的版本

Question

我试图将此代码重构为更优雅的版本。任何人都可以请帮忙。

• 问题出现在哪里，作为以后比较的第一个评估结果的标志？
• 我要避免使用，如果/开关，如果可能的
• 我应该删除操作员级和eval分成And和Or类，但不会太多不同的充我觉得

---

public interface IEval<T> 
{ 
    Func<T, bool> Expression { get; } 
    Operator Operator { get; } 
    string Key { get; } 
} 

---

public static bool Validate<T>(this T o, IList<IEval<T>> conditions) 
{ 
    var returnResult = true; 
    var counter = 0; 

    foreach (var condition in conditions) 
    { 
     var tempResult = condition.Expression(o); 

     if (counter == 0) //don't like this 
     { 
      returnResult = tempResult; 
      counter++; 
     } 
     else 
     { 
      switch (condition.Operator) //don't like this 
      { 
       case Operator.And: 
        returnResult &= tempResult; 
        break; 
       case Operator.Or: 
        returnResult |= tempResult; 
        break; 
       default: 
        throw new NotImplementedException(); 
      } 
     } 
    } 

    return returnResult; 
} 

谢谢！

代码更新时间：

public interface IEval<T> 
{ 
    Func<T, bool> Expression { get; } 
    bool Eval(bool against, T t); 
} 

public class AndEval<T> : IEval<T> 
{ 
    public Func<T, bool> Expression { get; private set; } 

    public AndEval(Func<T, bool> expression) 
    { 
     Expression = expression; 
    } 

    public bool Eval(bool against, T t) 
    { 
     return Expression.Invoke(t) & against; 
    } 
} 

public class OrEval<T> : IEval<T> 
{ 
    public Func<T, bool> Expression { get; private set; } 

    public OrEval(Func<T, bool> expression) 
    { 
     Expression = expression; 
    } 

    public bool Eval(bool against, T t) 
    { 
     return Expression.Invoke(t) | against; 
    } 
} 

public static class EvalExtensions 
{ 
    public static bool Validate<T>(this T t, IList<IEval<T>> conditions) 
    { 
     var accumulator = conditions.First().Expression(t); 

     foreach (var condition in conditions.Skip(1)) 
     { 
      accumulator = condition.Eval(accumulator, t); 
     } 

     return accumulator; 
    } 
} 

Answer 1

试试这个（假设条件不为空）

var accumulator = conditions.First().Expression(0); 

foreach (var condition in conditions.Skip(1)) 
{ 
    accumulator = condition.Operation.Evaluate(
     condition.Expression(0), accumulator); 
} 

class AddOperation : Operation 
{ 
    public override int Evaluate(int a, int b) 
    { 
     return a & b; 
    } 
} 

你的想法。你可以把它更加紧凑通过定义条件的方法，使得它自身运行的表达式（），并将结果传递的第一个参数来评估：

condition.Evaluate(accumulator); 

class Condition 
{ 
    public int Evaluate(int argument) 
    { 
     return Operation.Evaluate(Expression(0), argument); 
    } 
} 

（也是一个不相关的建议：永远不会调用可变tempSomething，这是恶业和给人的印象是，你不知道到底读者的特定变量的角色）

Answer 2

我能想到的唯一的事情就是：

if语句，它有一个检查你有至少2个条件。

然后，而不是一个foreach，使用一个常规的语句与计数器开始在第二个条件。

如果您没有条件，则返回true。取决于您的其他业务逻辑。

如果您有一个条件，那么取值。无论如何，我相信操作执行的switch语句将是必要的...除非您更改代码以执行某种类型的脚本，这是您实际执行的操作。我认为这更糟糕。

Answer 3

消除if/switch的一个通用模式是将if后面的逻辑放置在正在操作的类中。我对您的域名不太了解，无法判断这是否适用于此。

要应用该模式，IEval将用另一种方法扩展，例如，

IEval<T>.PerformOperation(T tempResult) 

根据具体的操作，它符合IEval的每一个具体的实施将然后实现PerformOperation，而不是使用一个枚举，指示操作的类型。

（不确定tempResult是否基于您的代码是T类型）。

然后，而不是开关，写

returnResult = condition.PerformOperation(tempResult); 

Answer 4

我不喜欢的唯一的事情是，你有一个变量称为柜台，将永远是0或1。我想使它成为一个bool isFirst代替。如果你想摆脱的开关，你可以用

public interface IEval<T>{ 
    Func<T, bool> Expression { get; } 
    Func<bool, bool, bool> Combinator { get; } 
    string Key { get; } 
} 

取代你IEval接口你的组合则方法将是要么根据所需的

public Func<bool, bool, bool> Combinator { 
    get { return (b1, b2) => b1 | b2; } 
} 

或

public Func<bool, bool, bool> Combinator { 
    get { return (b1, b2) => b1 & b2; } 
} 

操作。

可能矫枉过正返回一个代表，不过，或许只是添加一个方法bool Combine(bool value1, bool value2)

Answer 5

下面的算法表现出短路（它停止评估一旦条件是已知的假）。它具有相同的基本设计，但它在开始时有效地使用了隐含的true && ...以使事情变得更加清洁。

public static bool Validate<T>(this T o, IList<IEval<T>> conditions) 
{ 
    bool result = true; 
    Operator op = Operator.And; 
    var conditionIter = conditions.GetEnumerator(); 

    while (result && conditionIter.MoveNext()) 
    { 
     bool tempResult = conditionIter.Current.Expression(o); 
     switch (op) 
     { 
      case Operator.And: 
       result &= tempResult; 
       break; 
      case Operator.Or: 
       result |= tempResult; 
       break; 
      default: 
       throw new NotImplementedException(); 
     } 
     op = condition.Operator; 
    } 

    return result; 
} 

Answer 6

我会用LINQ方法去。像 -

public static bool Validate<T>(this T o, IList<IEval<T>> conditions) 
{ 
    return conditions 
     .Skip(1) 
     .Aggregate(
      conditions.First().Expression(o), 
      (a, b) => b.Operator == Operators.Or ? (a || b.Expression(o)) : (a && b.Expression(o)) 
     ); 
} 

或者，如果你不喜欢三元操作或需要更多的可扩展性和更好的方法，你可以使用字典存储和与运营商相关的查询功能。

public static bool Validate<T>(this T o, IList<IEval<T>> conditions) 
{ 
    return conditions 
     .Skip(1) 
     .Aggregate(
      conditions.First().Expression(o), 
      (a, b) => operators[b.Operator](a, b.Expression(o)) 
     ); 
} 

public static Dictionary<Operator, Func<bool, bool, bool>> operators = new Dictionary<Operator, Func<bool, bool, bool>>() 
{ 
    {Operator.And, (a, b) => a && b}, 
    {Operator.Or, (a, b) => a || b} 
}