Лямбда-выражения C# или делегаты как свойства или аргументы

Действительно, то, что Вы хотите использовать, Func<T,bool> где T является типом объекта, Вы хотите проверить. Затем Вы сделали бы что-то вроде этого

validator.AddValidation(item => (item.HasEnoughInformation() || item.IsEmpty());

Вы могли сохранить их в a List<Func<T,bool>>.

class ValidationRule {
    public delegate bool Validator();

    private Validator _v;

    public ValidationRule(Validator v) { _v = v; }

    public Validator Validator {
        get { return _v; }
        set { _v = value; }
    }

    public bool IsValid { get { return _v(); } }
}

var alwaysPasses = new ValidationRule(() => true);
var alwaysFails = new ValidationRule(() => false);

var textBoxHasText = new ValidationRule(() => textBox1.Text.Length > 0);

Это должно запустить Вас. Но, действительно, наследование является намного более соответствующим здесь. Проблема состоит просто в том что Validator не имеет доступа ни к какому состоянию, которое он не закрывает, это означает, что не является столь допускающим повторное использование, как говорят ValidationRules это содержит их собственное состояние. Сравните следующий класс с предыдущим определением textBoxHasText.

interface IValidationRule {
    bool IsValid { get; }
}

class BoxHasText : IValidationRule {
    TextBox _c;

    public BoxHasText(TextBox c) { _c = c; }

    public bool IsValid {
        get { return _c.Text.Length > 0; }
    }
}

Ну, просто, если у Вас есть класс Объекта, и Вы хотите использовать лямбда-выражения на том Объекте, чтобы определить, допустимо ли что-то (возврат булевской переменной), Вы могли бы использовать Func.

Так, учитывая Объект:

 class Entity
 {
      public string MyProperty { get; set; }
 }

Вы могли определить класс ValidationRule для того как это:

 class ValidationRule<T> where T : Entity
 {
      private Func<T, bool> _rule;

      public ValidationRule(Func<T, bool> rule)
      {
           _rule = rule;
      }

      public bool IsValid(T entity)
      {
           return _rule(entity);
      }
 }

Затем Вы могли использовать его как это:

 var myEntity = new Entity() { MyProperty = "Hello World" };
 var rule = new ValidationRule<Entity>(entity => entity.MyProperty == "Hello World");

 var valid = rule.IsValid(myEntity);

Конечно, это - всего одно возможное решение.

Если Вы удаляете универсальное ограничение выше ("где T: Объект"), Вы могли сделать это универсальным механизмом правил, который мог использоваться с любым ПОСТЕПЕННО. Вы не должны были бы получать класс для каждого типа использования, в котором Вы нуждаетесь. Таким образом, если бы я хотел использовать этот тот же класс на TextBox, то я мог бы использовать следующее (после удаления универсального ограничения):

 var rule = new ValidationRule<TextBox>(tb => tb.Text.Length > 0);
 rule.IsValid(myTextBox);

Это довольно гибко этот путь. Используя лямбда-выражения и дженерики вместе очень мощно. Вместо того, чтобы принять Func или Action, Вы могли принять Выражение> или Выражение> и иметь прямой доступ к специальному дереву для автоматического исследования вещей как название метода или свойства, какое выражение это и т.д. И люди, использующие Ваш класс, не должны были бы изменять одну строку кода.

Синтаксис определения правила хотел бы эту работу за Вас?

  public static void Valid(Address address, IScope scope)
  {
    scope.Validate(() => address.Street1, StringIs.Limited(10, 256));
    scope.Validate(() => address.Street2, StringIs.Limited(256));
    scope.Validate(() => address.Country, Is.NotDefault);
    scope.Validate(() => address.Zip, StringIs.Limited(10));

    switch (address.Country)
    {
      case Country.USA:
        scope.Validate(() => address.Zip, StringIs.Limited(5, 10));
        break;
      case Country.France:
        break;
      case Country.Russia:
        scope.Validate(() => address.Zip, StringIs.Limited(6, 6));
        break;
      default:
        scope.Validate(() => address.Zip, StringIs.Limited(1, 64));
        break;
    }

Проверьте DDD и Правило управляемая Проверка UI в.NET для получения дополнительной информации

что-то как:

class ValidationRule
{
    private Func<bool> validation;

    public ValidationRule(Func<bool> validation)
    {
        this.validation = validation;
    }
    public bool IsValid()
    {
        return validation();
    }
}

был бы больше стиля C# 3, но компилируется в тот же код как @Frank ответ Krueger. Это - то, что Вы попросили, но не чувствуете себя хорошо. Существует ли серьезное основание, почему объект не может быть расширен для выполнения проверки?