C# - Lambda-Ausdrücke oder Delegierten als Eigenschaften oder Argumente

Ich bin auf der Suche zum erstellen einer Gültigkeitsregel-Klasse, überprüft die Eigenschaften einer Entität vom Typ Objekt. Ich würde wirklich gerne, um den Namen der Eigenschaft, um zu überprüfen, und geben Sie der Klasse ein Delegierter oder ein lambda-Ausdruck wird zur Laufzeit ausgewertet, wenn das Objekt führt die IsValid () - Methode. Hat jemand ein snippet, so etwas wie dies, oder irgendwelche Ideen auf, wie übergeben Sie eine anonyme Methode als argument oder Eigentum?

Auch, ich bin mir nicht sicher, ob ich erkläre, was ich bin versucht zu erreichen, also bitte Fragen stellen, wenn ich mich nicht klar ist.

InformationsquelleAutor JC Grubbs | 2008-09-26

c#lambda

6

Wirklich, was Sie verwenden möchten, ist Func<T,bool> wobei T der Typ des Elements, das Sie überprüfen möchten. Dann würden Sie so etwas tun
```
validator.AddValidation(item => (item.HasEnoughInformation() || item.IsEmpty());
```
könnten Sie lagern Sie Sie in einem List<Func<T,bool>>.
- Ich denke, mit Prädikat<T> könnte ein bisschen mehr als Func - <T,bool>
- Ah ja, mit dem Prädikat " groß ist, im Grunde die gleiche Sache.
InformationsquelleAutor Darren Kopp

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

Dass sollte Ihnen den Einstieg. Aber, wirklich, die Vererbung ist weit mehr angemessen. Das problem ist einfach, dass die Validator nicht haben Zugang zu jedem Staat, dass es nicht in der Nähe, über, dies bedeutet, dass es nicht so wiederverwendbar wie sagen ValidationRules enthalten Ihren eigenen Staat. Vergleichen Sie die folgende Klasse, um die Vorherige definition der 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; }
    }
}

Kann man erweitern auf die Vererbung Sinn?

InformationsquelleAutor Frank Krueger

2

Gut, einfach, wenn man eine Entity-Klasse, und Sie möchten, um die Verwendung von lambda-Ausdrücken auf, die Unternehmen bestimmen, ob etwas gültig ist (Rückgabe boolean), könnte man eine Func.

So, da ein Unternehmen:
```
 class Entity
 {
      public string MyProperty { get; set; }
 }
```
Könnten Sie eine Gültigkeitsregel-Klasse für die, die wie dieses:
```
 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);
      }
 }
```
Dann können Sie es wie folgt:
```
 var myEntity = new Entity() { MyProperty = "Hello World" };
 var rule = new ValidationRule<Entity>(entity => entity.MyProperty == "Hello World");

 var valid = rule.IsValid(myEntity);
```
Natürlich, das ist nur eine mögliche Lösung.

Wenn Sie entfernen die generische Einschränkung oben ("wo T : Entity"), Sie könnten dieses eine generische Regel-engine, die verwendet werden könnten, mit jedem POCO. Würden Sie nicht haben, leiten Sie eine Klasse für jede Art der Verwendung, die Sie benötigen. Also, wenn ich wollte mit diesem derselben Klasse in einem Textfeld, die ich verwenden könnte, den folgenden (nach dem entfernen der generische Einschränkung):
```
 var rule = new ValidationRule<TextBox>(tb => tb.Text.Length > 0);
 rule.IsValid(myTextBox);
```
Es ist ziemlich flexibel, auf diese Weise. Lambda-Ausdrücke und generics sind zusammen sehr mächtig. Statt zu akzeptieren Func oder Aktion, könnte man akzeptieren, Ausdruck> oder der Ausdruck> und haben direkten Zugang auf die express-Baum automatisch untersuchen, Dinge wie den Namen der Methode oder Eigenschaft, welche Art von Ausdruck es ist, etc. Und Menschen, die mit Ihrer Klasse nicht eine einzige Zeile code.

InformationsquelleAutor Jason Olson
1

etwas wie:
```
class ValidationRule
{
    private Func<bool> validation;

    public ValidationRule(Func<bool> validation)
    {
        this.validation = validation;
    }
    public bool IsValid()
    {
        return validation();
    }
}
```
wäre mehr C# 3 style, aber kompiliert wird, den gleichen code wie @Frank Krüger seine Antwort.
Dies ist, was Sie gefragt haben, fühlen sich aber nicht Recht. Gibt es einen guten Grund, warum die Entität kann nicht erweitert werden, um die Validierung?

InformationsquelleAutor Hamish Smith

Wäre ein Regel-definition syntax wie diese Arbeit für Sie?

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

Check-out DDD und regelbezogene UI-Validierung .NET weitere Informationen

InformationsquelleAutor Rinat Abdullin

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.