Bir sekansın belirli bir uzunluğa sahip olmasını nasıl sağlayabilirim?

Question

IEnumerable'un tam olarak tek bir öğe içerdiğini kontrol etmek istiyorum. Count() tüm listeyi numaralandırma olarak

bool hasOneElement = seq.Count() == 1 

Ancak, çok verimli değil: Bu parçacık eser yok. Açıkçası, bir listenin bittiğini bilmek veya 1'den fazla eleman içermek boş değil demektir. Bu kısa devre davranışına sahip bir uzatma yöntemi var mı?

Answer 1

Bu yapmalıyım

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

Bu tür olduğunu funky olan hile, ama muhtemelen üretim kodunda kullanılmamalıdır. Sadece yeterince açık değil. Geldiğin ben sadece gördüm:)

DÜZENLEME; eğlenceli ederken & & operatörün LHS'deki yan etki RHS uygun çalışması için gerekli olması ... sadece kötü tam olarak aynı şey ile ama keyfi bir uzunluk için. Son dönüş ifadeniz yanlış olsa da - !en.MoveNext() olmalıdır.

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

DÜZENLEME: Ve CountEquals bir özyinelemeli formu (bu kullanmayın lütfen, fonksiyonel hayranları için şimdi İşte tam ICollection/ICollection<T> için güzel bir isim (IMO), argüman denetimi ve optimizasyonu ile yöntemidir bu) espri olsun diye sadece burada:

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

DÜZENLEME: LINQ to SQL gibi bir şey için olduğunu unutmayın, basit Count() yaklaşım kullanmalıdır - o veritabanına yerine getirilirken sonra yapılması gereken izin vereceğiz çünkü fiili sonuç. Listenin sıfır veya bir öğeye sahip olup olmadığını

Answer 2

Hayır, ama tek kendin yazabilirsiniz:

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

DÜZENLEME: açıklama sonra tam için en az değiştirilmiştir. Sen hangi yapmanızı sağlayan, Cevabıma here bir göz atmak isteyebilirsiniz (sekans ICollection veya ICollection<T> bu durumda numaralandırma gerekli değildir uygulaması halinde sadece 1 numaralandırıcıyı ve kontroller kullanır) daha genel ve etkili çözüm için

Exact, AtLeast veya AtMost testlerini aradığınızı belirtin.

Answer 3

Aradığınız şeyin .Single() olduğuna inanıyorum. Tam olarak bir başkası, yakalayabileceğiniz InvalidOperationException öğesini atar.

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

Sen ayrıca bu elide olabilir, ama bunu önermiyoruz:

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

Answer 4

seq.Skip(1).Any() söyleyecektir.

Yaptığınız düzenlemenin uzunluğu kontrol etmenin en etkili yolu olduğunu düşünüyorum. Fakat bir mantık hatası var, uzunluktan daha az olan öğeler doğru olarak geri dönecek. İkinci beyannameye ne yaptığımı görün.

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

Bu nasıl?

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

Take() biz MoveNext daha count+1 den kez aramak asla emin olacaktır. Count() sadece Count üyesi bakmak için optimize edilmiştir, çünkü

Ben ICollection herhangi örneği için dikkat etmek istiyorum

, orijinal uygulama source.Count() == count daha hızlı olmalıdır.