मैं कैसे सुनिश्चित करूं कि अनुक्रम की निश्चित लंबाई हो?

Question

मैं यह देखना चाहता हूं कि IEnumerable में बिल्कुल एक तत्व है।

bool hasOneElement = seq.Count() == 1 

हालांकि यह, बहुत ही कुशल नहीं है के रूप में Count() पूरी सूची की गणना होगी: यह टुकड़ा काम करता है। जाहिर है, एक सूची जानना खाली है या 1 से अधिक तत्व शामिल हैं इसका मतलब है कि यह खाली नहीं है। क्या कोई विस्तार विधि है जिसमें यह शॉर्ट-सर्किटिंग व्यवहार है?

Answer 1

यह करना चाहिए:

public static bool ContainsExactlyOneItem<T>(this IEnumerable<T> source) 
{ 
    using (IEnumerator<T> iterator = source.GetEnumerator()) 
    { 
     // Check we've got at least one item 
     if (!iterator.MoveNext()) 
     { 
      return false; 
     } 
     // Check we've got no more 
     return !iterator.MoveNext(); 
    } 
} 

आप आगे इस छिपाना सकता है, लेकिन मैं आपको ऐसा करने के संकेत नहीं करते:

public static bool ContainsExactlyOneItem<T>(this IEnumerable<T> source) 
{ 
    using (IEnumerator<T> iterator = source.GetEnumerator()) 
    { 
     return iterator.MoveNext() && !iterator.MoveNext(); 
    } 
} 

यह की तरह है चाल जो फंकी है, लेकिन शायद उत्पादन कोड में इस्तेमाल नहीं किया जाना चाहिए। यह बस पर्याप्त स्पष्ट नहीं है। तथ्य यह है & & ऑपरेटर की एलएचएस में पक्ष प्रभाव के लिए आवश्यक है कि आरएचएस उचित रूप से काम करने के लिए सिर्फ बुरा है ... जबकि बहुत मज़ा;)

संपादित करें: मैं बस देखा है कि आप के लिए आया था बिल्कुल एक ही चीज़ के साथ लेकिन मनमाने ढंग से लंबाई के लिए। आपका अंतिम रिटर्न स्टेटमेंट गलत है - यह !en.MoveNext() वापस होना चाहिए। CountEquals की एक पुनरावर्ती प्रपत्र (इस का उपयोग नहीं करें कार्यात्मक प्रशंसकों के लिए अब और,:

public static bool CountEquals<T>(this IEnumerable<T> source, int count) 
{ 
    if (source == null) 
    { 
     throw new ArgumentNullException("source"); 
    } 
    if (count < 0) 
    { 
     throw new ArgumentOutOfRangeException("count", 
               "count must not be negative"); 
    } 
    // We don't rely on the optimizations in LINQ to Objects here, as 
    // they have changed between versions. 
    ICollection<T> genericCollection = source as ICollection<T>; 
    if (genericCollection != null) 
    { 
     return genericCollection.Count == count; 
    } 
    ICollection nonGenericCollection = source as ICollection; 
    if (nonGenericCollection != null) 
    { 
     return nonGenericCollection.Count == count; 
    } 
    // Okay, we're finally ready to do the actual work... 
    using (IEnumerator<T> iterator = source.GetEnumerator()) 
    { 
     for (int i = 0; i < count; i++) 
     { 
      if (!iterator.MoveNext()) 
      { 
       return false; 
      } 
     } 
     // Check we've got no more 
     return !iterator.MoveNext(); 
    } 
} 

संपादित करें: यहाँ ICollection/ICollection<T> के लिए एक अच्छे नाम (IMO), तर्क की जाँच और अनुकूलन के साथ एक पूर्ण विधि है , यह केवल यहाँ गिगल्स के लिए है):

public static bool CountEquals<T>(this IEnumerable<T> source, int count) 
{ 
    if (source == null) 
    { 
     throw new ArgumentNullException("source"); 
    } 
    if (count < 0) 
    { 
     throw new ArgumentOutOfRangeException("count", 
               "count must not be negative"); 
    } 
    using (IEnumerator<T> iterator = source.GetEnumerator()) 
    { 
     return IteratorCountEquals(iterator, count); 
    } 
} 

private static bool IteratorCountEquals<T>(IEnumerator<T> iterator, int count) 
{ 
    return count == 0 ? !iterator.MoveNext() 
     : iterator.MoveNext() && IteratorCountEquals(iterator, count - 1); 
} 

संपादित करें: एसक्यूएल के लिए LINQ की तरह कुछ के लिए ध्यान दें कि, आप सरल Count() दृष्टिकोण का उपयोग करना चाहिए - क्योंकि यह है कि यह डेटाबेस के बजाय प्राप्त करने में कठिनाई के बाद किया जाना करने की अनुमति देंगे वास्तविक परिणाम।

Answer 2

नहीं है, लेकिन आप एक अपने आप को लिख सकते हैं:

public static bool HasExactly<T>(this IEnumerable<T> source, int count) 
{ 
    if(source == null) 
     throw new ArgumentNullException("source"); 

    if(count < 0) 
     return false; 

    return source.Take(count + 1).Count() == count; 
} 

संपादित करें: स्पष्टीकरण के बाद बिल्कुल करने के लिए कम से कम से बदल दिया है।

एक अधिक सामान्य और कुशल समाधान के लिए (जो केवल 1 प्रगणक और चेक का उपयोग करता है, तो अनुक्रम को लागू करता है ICollection या ICollection<T> जिसमें मामले गणन आवश्यक नहीं है), तो आपको मेरा उत्तर here पर एक नज़र लेने के लिए चाहते हो सकता है, जो आप की सुविधा देता है निर्दिष्ट करें कि आप Exact, AtLeast, या AtMost परीक्षणों की तलाश में हैं या नहीं।

Answer 3

मुझे विश्वास है कि आप जो खोज रहे हैं वह .Single() है। बिल्कुल एक के अलावा कुछ भी अवैधऑपरेशन अपवाद को फेंक देगा जिसे आप पकड़ सकते हैं।

http://msdn.microsoft.com/nb-no/library/bb155325.aspx

Answer 4

seq.Skip(1).Any() आपको बताएगा कि सूची में शून्य या एक तत्व है या नहीं।

मुझे लगता है कि आपके द्वारा किए गए संपादन की लंबाई लंबाई की जांच करने का सबसे प्रभावी तरीका है। लेकिन एक तर्क गलती है, लंबाई से कम वस्तुएं सच हो जाएंगी। देखें कि मैंने दूसरे रिटर्न स्टेटमेंट में क्या किया है।

public static bool LengthEquals<T>(this IEnumerable<T> en, int length) 
    { 
     using (var er = en.GetEnumerator()) 
     { 
      for (int i = 0; i < length; i++) 
      { 
       if (!er.MoveNext()) 
        return false; 
      } 
      return !er.MoveNext(); 
     } 
    } 

Answer 5

इस बारे में कैसे?

public static bool CountEquals<T>(this IEnumerable<T> source, int count) { 
    return source.Take(count + 1).Count() == count; 
} 

Take() हम फोन कभी नहीं MoveNextcount+1 से अधिक बार यकीन है कि कर देगा।

मैं ध्यान दें कि ICollection के किसी भी उदाहरण के लिए करना चाहते हैं, मूल कार्यान्वयन source.Count() == count तेजी क्योंकि Count() सिर्फ Count सदस्य को देखने के लिए अनुकूलित है होना चाहिए।