लैम्ब्डा फनक <> और फ्लुएंट

Question

वहां बहुत सारे फ्लुएंट कार्यान्वयन हैं जो लैम्बदास के साथ काम करते हैं जो काफी साफ हैं। मैं अपने दिमाग को इसके चारों ओर लपेटना चाहता हूं ताकि मैं इनमें से कुछ चीजों को बनाना शुरू कर सकूं, लेकिन मुझे अभी तक एक स्पष्टीकरण नहीं मिला है कि मेरा दिमाग समझता है।

एक व्यक्ति सत्यापनकर्ता

public class PersonValidator : IValidator<Person> 
{ 
    public PersonValidator() 
    { 
      AddRule(p => p.FirstName).CannotBeNull().CannotBeBlank(); 
      AddRule(p => p.LastName).CannotBeNull().CannotBeBlank(); 
    } 

    public List<ValidationResult> Validate(Person p) 
    { 
     // pseudo... 
     apply all rules specified in constructor, return results 
    } 
} 

मैं इस इस तरह मेरी सत्यापनकर्ता पर एक विधि का उपयोग कर काम करने का सभी का हिस्सा पाने में कामयाब रहे है ...

public ValidationResult<T,TProp> AddRule<T,TProp>(Func<T,TProp> property) 
{ 
    ... not sure what to do here. This method gives me the ability to use the lambda 
    ... for specifying which properties i want to validate 
} 

मैं की इस सरल उदाहरण पर विचार करें फिर विस्तार विधियां बना सकते हैं जो कैनोटबेनुल और कैनोटबेई के उद्देश्यों के लिए IValidator को बढ़ाते हैं।

तो ऐसा लगता है कि मेरे पास पहली छमाही और समस्या का दूसरा आधा है लेकिन मुझे यकीन नहीं है कि उन्हें एक साथ कैसे लाया जाए।

एक सार्थक स्पष्टीकरण की तलाश में है ... मैं इसे "प्राप्त करना" चाहता हूं। :)

Answer 1

धाराप्रवाह इंटरफेस की कुंजी यह है कि कैनोटबेनुल() और कैनोटबेब्लैंक() जैसे विधियां वर्तमान उदाहरण (यानी यह) लौटाती हैं। यदि आप अपनी AddRule विधि को "धाराप्रवाह" होना चाहते हैं, तो ValidationResult को वापस करने के बजाय, आपको IValidator के वर्तमान उदाहरण को वापस करने की आवश्यकता है। आपके विस्तार विधियों को वे विस्तारित करने वाले IValidator के उदाहरण को वापस करने की भी आवश्यकता होगी।

मुझे लगता है कि आपके सटीक कार्यान्वयन को थोड़ा और जटिल होना आवश्यक हो सकता है, और उम्मीद है कि नीचे दिया गया उदाहरण कुछ अंतर्दृष्टि प्रदान करेगा।

interface IValidator<T> 
{ 
    IValidatorRule<T, TProp> AddRule<TProp>(Func<T, TProp> property); 
} 

interface IValidatorRule<T> 
{ 
    T instance { get; } 
    string PropertyName { get; } 

    ValidationResult Apply(T instance); 
} 

public static IValidatorAugmentorExtensions 
{ 
    public static IValidatorRule<T> CannotBeNull(this IValidatorRule<T> rule) 
    { 
     // ... 

     return rule; 
    } 

    public static IValidatorRule<T> CannotBeBlank(this IValidatorRule<T> rule) 
    { 
     // ... 

     return rule; 
    } 
} 

ऊपर इतना की तरह इस्तेमाल किया जा सकता है:: वही सामान्य नियम, हालांकि ... वापसी "इस" एक धाराप्रवाह इंटरफ़ेस बनाने के लिए

public class PersonValidator: IValidator<Person> 
{ 
    public PersonValidator() 
    { 
     AddRule(p => p.FirstName).CannotBeNull().CannotBeEmpty(); 
     AddRule(p => p.LastName).CannotBeNull().CannotBeEmpty(); 
    }  

    public List<ValidationResult> Validate(Person p) 
    { 
     List<ValidationResult> results = new List<ValidationResult>(); 

     foreach (IValidatorRule<Person> rule in rules) // don't know where rules is, or what the AddRule method adds to...you'll need to figure that out 
     { 
      results = rule.Apply(p); 
     } 

     return results; 
    } 
} 

ऊपर दर्शाता एक धाराप्रवाह इंटरफ़ेस बनाने के लिए कैसे एक ओर जहां , मुझे वास्तव में पता नहीं है कि यह आपको इस विशेष स्थिति में लंबे समय तक क्या खरीदता है। एक धाराप्रवाह इंटरफ़ेस की सुविधा के लिए जो आंतरिक रूप से कंक्रीट वैधकर्ताओं के लिए आंतरिक रूप से उपयोग किया जाता है, आपने अपने कोड की जटिलता को उचित मात्रा में बढ़ा दिया है, वास्तव में आपके वैधकर्ताओं के उपभोक्ताओं को उपयोगी, धाराप्रवाह इंटरफ़ेस प्रदान किए बिना। मुझे लगता है कि कंक्रीट वैधकर्ता बनाने के लिए एक धाराप्रवाह ढांचा प्रदान करने के बजाय, उन डेवलपर्स को धाराप्रवाह सत्यापन फ्रेमवर्क प्रदान करके आप अधिक मूल्य प्राप्त करेंगे, जिन्हें सत्यापन करने की आवश्यकता है।

Answer 2

जिस्टिस्ट का जवाब सही है। यहां एक अलग दृष्टिकोण के लिए यह है कि मैंने इसे कैसे पूरा किया।

public class PersonValidator : IValidator<Person> 
    { 
     List<Func<Person,bool>> validationRules = new List<Func<Person,bool>>(); 

    public PersonValidator() 
    { 
     AddRule(p => IsNullOrEmpty(p.FirstName)).AddRule(p1 => CheckLength(p1.FirstName)); 
    } 

    PersonValidator AddRule(Func<Person,bool> rule) 
    { 
     this.validationRules.Add(rule); 
     return this; 
    } 

    private bool IsNullOrEmpty(String stringToCheck) 
    { 
     return String.IsNullOrEmpty(stringToCheck); 
    } 

    private bool CheckLength(String stringToCheck) 
    { 
     return (String.IsNullOrEmpty(stringToCheck) ? false : stringToCheck.Length < 3); 
    } 

    #region IValidator<Person> Members 

    public bool Validate(Person obj) 
    { 
     return validationRules.Select(x => x(obj)).All(result => result == false); 
    } 

    #endregion 
} 



     Person test = new Person() { FirstName = null }; 
     Person test1 = new Person() { FirstName = "St" }; 
     Person valid = new Person() { FirstName = "John" }; 

     PersonValidator validator = new PersonValidator(); 
     Console.WriteLine("{0} {1} {2}", validator.Validate(test), validator.Validate(test1), validator.Validate(valid));