c# - 闭包与类？

Question

我有一个我希望能够处理的“规则”的概念。因此，我创建了以下界面:

  public interface IRule<T>
  {
    Boolean IsSatisfiedBy(T value);
    String GetViolationMessage(T value);
  }

我曾计划创建一系列“规则”类来表示系统当前支持的各种规则，例如:

  public class MatchesPatternRule : IRule<String>
  {
    private readonly Regex _regex;
    private readonly String _pattern;

    public MatchesPatternRule(String pattern)
    {
      Verify.IsFalse(String.IsNullOrWhiteSpace(pattern));

      _regex = new Regex(pattern);
      _pattern = pattern;
    }

    public Boolean IsSatisfiedBy(String value)
    {
      return _regex.IsMatch(value);
    }

    public String GetViolationMessage(String value)
    {
      return String.Format(RuleMessage.MatchesPatternViolation, _pattern, value);
    }
  }

然后规则将通过各种扩展方法使用，例如:

public static ValidationContext<String> MatchesPattern(this ValidationContext<String> context, String pattern)
{
  context.AddRule(new MatchesPatternRule(pattern));
  return context;
}

但是，我目前有 20 多个规则的计划，并且 MatchesPatternRule 类可以通过编写如下扩展方法轻松替换:

public static ValidationContext<String> MatchesPattern(this ValidationContext<String> context, String pattern)
  where T : IComparable
{
  Verify.IsFalse(String.IsNullOrWhiteSpace(pattern));

  Regex regex = new Regex(pattern);
  context.AddRule(value => regex.IsMatch(value), value => String.Format(RuleMessage.MatchesPatternViolation, _pattern, value));
  return context;
}

想知道哪种方法更好，为什么？两者都很容易测试并最终达到最终结果。任何见解将不胜感激!

更新

根据 Tom 的反馈，我想我已经选择了一种折衷的方法。我将创建一个静态类来保存每个“规则”的扩展方法。这将确保任何给定的规则都很容易找到，并使我的代码井井有条，同时减少总体代码量。

  public static class MatchesPatternRule
  {
    public static ValidationContext<String> MatchesPattern(this ValidationContext<String> context, String pattern)
    {
      return MatchesPattern<T>(context, pattern, pattern, RegexOptions.None);
    }

    public static ValidationContext<String> MatchesPattern(this ValidationContext<String> context, String pattern, String friendlyPattern)
    {
      return MatchesPattern<T>(context, pattern, friendlyPattern, RegexOptions.None);
    }

    public static ValidationContext<String> MatchesPattern(this ValidationContext<String> context, String pattern, RegexOptions options)
    {
      return MatchesPattern<T>(context, pattern, pattern, options);
    }

    public static ValidationContext<String> MatchesPattern(this ValidationContext<String> context, String pattern, String friendlyPattern, RegexOptions options)
    {
      Verify.IsFalse(String.IsNullOrWhiteSpace(pattern));

      Regex regex = new Regex(pattern);
      context.AddRule(value => regex.IsMatch(value), value => String.Format(RuleMessage.MatchesPatternViolation, _pattern, value));

      return context;
    }
  }

Answer 1

我不是 C# 用户，但在 Ruby 和 Scala 中，人们有类似的选择。在类似这种情况下，拥有一个遵循特定接口(interface)的类似乎与闭包有类似的用途，尽管有更多的样板。由于他们在技术上追求相同的目标，因此问题肯定会变成最适合上下文的社交。

那些应该编写这些规则的人是否足够聪明以解决闭包问题？如果不是，基于类的解决方案可能是更好用的解决方案。如果我戴上我的 Java 程序员试图理解所有这些 C# 幻想的帽子，基于类的解决方案可能比必须学习所有这些奇怪的功能性东西要容易一些——我知道奇怪的功能性东西，但我可以想象自己不知道它!只有您可以决定什么对将要编写规则的人来说是最好的。如果您是唯一必须编写规则的人，那就发疯吧!从美学角度选择您喜欢的任何东西。

文档和元数据怎么样？ future 的可扩展性？如果您需要向规则添加额外的字段怎么办？记录基于类的解决方案比基于闭包的解决方案更容易吗？如果您必须找到并更改一条规则，哪条规则会更容易做到？