Des Expressions Lambda C# ou de Délégués comme une des Propriétés ou des Arguments

Je suis à la recherche pour créer une Règle de classe qui valide les propriétés d'un type d'entité de l'objet. Je tiens vraiment à définir le nom de la propriété à inspecter, et de donner ensuite la classe d'un délégué ou d'une expression lambda qui sera évalué au moment de l'exécution lors de l'exécution de l'objet de sa méthode IsValid (). Quelqu'un aurait-il un extrait de quelque chose comme cela, ou des idées sur la façon de passer d'une méthode anonyme comme un argument ou bien?

Aussi, je ne suis pas sûr si je suis d'expliquer ce que je suis en train d'accomplir autant de posez des questions si je ne suis pas clair.

OriginalL'auteur JC Grubbs | 2008-09-26

  1. 6

    Vraiment, ce que vous voulez utiliser est Func<T,bool> où T est le type de l'élément que vous souhaitez valider. Ensuite, vous faites quelque chose comme cela

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

    vous pouvez stocker dans un List<Func<T,bool>>.

    Je pense que l'utilisation de Prédicat<T> peut-être un peu plus de Func<T,bool>
    Ah oui, le prédicat est grande, fondamentalement la même chose.

    OriginalL'auteur Darren Kopp

  2. 3
    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);

    Qui devrait vous obtenir a commencé. Mais, vraiment, l'héritage est beaucoup plus approprié ici. Le problème est simplement que la Validator n'a pas accès à tout état qui ne se ferme pas et de plus, cela signifie qu'il n'est pas réutilisables comme le disent les ValidationRules qui contiennent leur propre état. Comparer la classe suivante à la définition précédente de 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; }
    }
}
    Pouvez-vous développer sur l'héritage?

    OriginalL'auteur Frank Krueger

  3. 2

    Bien, tout simplement, si vous avez une classe d'Entité, et que vous voulez utiliser des expressions lambda sur cette Entité afin de déterminer si quelque chose est valide (en retournant un booléen), vous pouvez utiliser la touche Func.

    Donc, compte tenu de l'Entité:

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

    Vous pouvez définir une Règle de validation de classe pour que de cette façon:

     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);
      }
 }

    Ensuite, vous pouvez l'utiliser comme ceci:

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

 var valid = rule.IsValid(myEntity);

    De sûr, c'est juste une solution possible.

    Si vous retirez la contrainte générique ci-dessus ("T : Entité"), vous pouvez faire ce générique moteur de règles qui pourraient être utilisé avec n'importe quel POCO. Vous n'auriez pas à dériver une classe pour chaque type d'utilisation dont vous avez besoin. Donc, si je voulais utiliser cette même classe sur une zone de texte, je pourrais utiliser la suite (après la suppression de la contrainte générique):

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

    Il est assez souple de cette façon. En utilisant les expressions lambda et des génériques de l'ensemble est très puissant. Au lieu d'accepter la touche Func ou de l'Action, vous pourriez accepter une Expression> Expression>, et ont un accès direct à l'express arbre automatiquement enquêter sur des choses comme le nom d'une méthode ou d'une propriété, ce type d'expression, il est, etc. Et les gens à l'aide de votre classe ne devrait pas changer une seule ligne de code.

    OriginalL'auteur Jason Olson

  4. 1

    quelque chose comme:

    class ValidationRule
{
    private Func<bool> validation;

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

    serait plus C# 3 le style, mais est compilé pour le même code que @Frank Krueger de la réponse.
    C'est ce que vous avez demandé, mais ne vous sentez pas bien. Est-il une bonne raison pour laquelle l'entité ne peut pas être prolongé pour effectuer la validation?

    OriginalL'auteur Hamish Smith

  5. 0

    Serait une règle de définition de la syntaxe comme celui-ci pour vous?

      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;
    }

    Découvrez DDD et de la Règle INTERFACE utilisateur basée sur la Validation .NET pour plus d'informations

    OriginalL'auteur Rinat Abdullin