IEnumerable की गणना विधि नहीं है

Question 1

मेरे पास निम्न विधि है:

public bool IsValid
{
  get { return (GetRuleViolations().Count() == 0); }
}

public IEnumerable<RuleViolation> GetRuleViolations(){
  //code here
}

ऐसा क्यों है कि जब मैं .Count()ऊपर करता हूं तो यह लाल रंग में रेखांकित होता है?

मुझे निम्नलिखित त्रुटि मिली:

त्रुटि 1 'System.Collections.Generic.IEnumerable' में 'काउंट' की कोई परिभाषा नहीं है और न ही कोई विस्तार विधि 'काउंट' टाइप '' System.Collections.Generic.IEBumerable '' के पहले तर्क को स्वीकार करते हुए पाया जा सकता है (क्या आप एक याद कर रहे हैं? निर्देश या असेम्बली रेफरेंस का उपयोग करते हुए?) c: \ users \ a \ document \ visual studio 2010 \ Projects \ NerdDinner \ NerdDinner \ मॉडल \ Dinner.cs 15 47 NerdDinner

Question 2

आप जोड़ना:

using System.Linq;

अपने स्रोत के शीर्ष पर और सुनिश्चित करें कि आपको System.Core असेंबली का संदर्भ मिल गया है।

Count()System.Linq.EnumerableLINQ से ऑब्जेक्ट्स के लिए स्टेटिक क्लास और System.Linq.QueryableLINQ से SQL और अन्य आउट-ऑफ-प्रोसीजर प्रदाताओं के लिए एक विस्तार विधि है ।

संपादित करें: वास्तव में, Count()यहां का उपयोग अपेक्षाकृत अक्षम है (कम से कम LINQ से वस्तुओं में)। आप सभी जानना चाहते हैं कि क्या कोई तत्व हैं या नहीं, है ना? उस मामले में, Any()एक बेहतर फिट है:

public bool IsValid
{
  get { return !GetRuleViolations().Any(); }
}

Question 3

Any()या Count()Linq में विधियाँ केवल सामान्य प्रकारों के लिए काम करती हैं।

IEnumerable<T>

यदि आपके पास एक IEnumerableप्रकार के बिना एक सरल है , तो उपयोग करने का प्रयास करें

IEnumerable<object>

बजाय।

Question 4

IEnumerationनामक विधि नहीं है Count()। यह सिर्फ "तत्वों का अनुक्रम" है। उदाहरण के लिए उपयोग करें Listयदि आपको स्पष्ट रूप से तत्वों की संख्या की आवश्यकता है। यदि आप Linq का उपयोग करते हैं, तो ध्यान रखें, कि एक्सटेंशन विधि Count()वास्तव में हर बार आपके द्वारा कॉल करने वाले तत्वों की संख्या को फिर से गिन सकती है।

Question 5

भविष्य में इस पद पर ठोकर खाने वाले थके हुए यात्री की मदद करने के लिए .Count () के नुकसान पर सावधानी का एक छोटा और मीठा सामान्य शब्द !

लघु कथा:

निम्नलिखित काम करता है-कोई संदेह नहीं है, लेकिन अगर कोई एंबुलेबल्स किसी अंतर्निहित सरणी या सूची द्वारा समर्थित नहीं है, जो 'काउंट' है, जो आसान / प्री -कॉम्प्लेक्टेड है, तो छोटा प्रदर्शन जुर्माना हो सकता है :

public bool IsValid
{
   get { return SomeMethodReturningEnumerable().Count() <= threshold; }  <--- small performance issue here
}

public IEnumerable<SomeObject> SomeMethodReturningEnumerable(){
   yield return foo;
   yield return bar; etc
}

कॉल .Count () विधि संभवत: प्रत्येक और प्रत्येक आइटम के माध्यम से गणना करने योग्य है और फिर थ्रेशोल्ड से समग्र गणना की तुलना करेगी । हम चालाक होने के नाते थोड़ा बेहतर कर सकते हैं:

    public bool IsValid
    {
       get { return !SomeMethodReturningEnumerable().HasMoreThan(threshold); }  <--- neato!
    }

    public static bool HasLessThan<T>(this IEnumerable<T> sequence, int count) => !sequence.HasMoreThan(count - 1);

    public static bool HasLessOrEqualTo<T>(this IEnumerable<T> sequence, int count) => !sequence.HasMoreThan(count);

    public static bool HasMoreOrEqualTo<T>(this IEnumerable<T> sequence, int count) => sequence.HasMoreThan(count - 1);

    public static bool HasMoreThan<T>(this IEnumerable<T> sequence, int count) => sequence.EnumerationCounterImpl(count, equals_vs_greaterThan: false);

    public static bool HasExactly<T>(this IEnumerable<T> sequence, int count) => sequence.EnumerationCounterImpl(count, equals_vs_greaterThan: true);

    public static bool EnumerationCounterImpl<T>(this IEnumerable<T> sequence, int count, bool equals_vs_greaterThan = true) //0
    {
        if (equals_vs_greaterThan && count < 0)
            throw new ArgumentException($"{nameof(count)} is less than zero!");

        if (!equals_vs_greaterThan && count < 0)
            return true;

        var staticCount = (sequence as ICollection)?.Count                              
                          ?? (sequence as ICollection<T>)?.Count
                          ?? (sequence as IReadOnlyCollection<T>)?.Count;

        if (staticCount != null)
            return staticCount > count;

        using (var enumerator = sequence.GetEnumerator()) //1 optimization
        {
            for (int i = 0; i < count + 1; i++)
            {
                if (enumerator.MoveNext())
                    continue;

                return false;
            }

            return !equals_vs_greaterThan //     ==
                   || enumerator.MoveNext(); //  >
        }

        //0 https://blog.slaks.net/2015-01-12/linq-count-considered-occasionally-harmful/
        //1 using the enumerator directly is slightly faster than using LINQ methods   it avoids allocating an extra iterator
        //  state machine compared to using skip()
    }

वहाँ! समस्या फिर से हल हो गई लेकिन इस बार हम प्रदर्शन के प्रति सचेत हैं!

Question 6

कैसा रहेगा:

public bool IsValid
{
    get { return (GetRuleViolations().Cast<RuleViolation>().Count() == 0); }
}