IEnumerable jest pusty?

Question

Wiem, że to prawdopodobnie nie ma znaczenia/wpływa na wydajność w przeważającej części, ale nienawidzę idei uzyskania IEnumerable i robi .Count(). Czy istnieje IsEmpty lub NotEmpty lub jakaś funkcja? (Podobny do STL empty())

Answer 1

Chcesz metodę rozszerzenia IEnumerable.Any() (.Net Framework 3.5 i wyżej). Pozwala uniknąć liczenia elementów.

Answer 2

bez potrzeby LINQ, można wykonać następujące czynności:

bool IsEmpty(IEnumerable en) 
{ 
    foreach(var c in en) { return false; } 
    return true; 
} 

Answer 3

Na IEnumerable lub IEnumerable<T>, no.

Ale to naprawdę nie ma większego sensu. Jeśli kolekcja jest pusta i spróbujesz iterować ją przy użyciu numeru IEnumerable, wywołanie funkcji IEnumerator.MoveNext() zwróci wartość false bez żadnych kosztów wydajności.

Answer 4

Nie sądzę, że to jest właśnie dla tego Count. Poza tym, co będzie szybciej:

1. Dostęp do nieruchomości i pobierania zapisanego Integer
2. Dostęp do nieruchomości i pobierania zapisanego Boolean

Answer 5

Można użyć metody rozszerzenie takich jak Obojętnie() lub hrabia(). Count() jest droższy niż Any(), ponieważ musi wykonać całe wyliczenie, jak zauważyli inni.

Ale w przypadku leniwej oceny (np. Metody wykorzystującej wydajność), każda z nich może być kosztowna. Na przykład, z następującym IEnumerable realizacji, każde wezwanie do Obojętnie czy hrabia będzie ponosić koszty nowej obie strony do bazy:

IEnumerable<MyObject> GetMyObjects(...) 
{ 
    using(IDbConnection connection = ...) 
    { 
     using(IDataReader reader = ...) 
     { 
      while(reader.Read()) 
      { 
       yield return GetMyObjectFromReader(reader); 
      } 
     } 
    } 
} 

myślę morał brzmi:

• Jeśli tylko mieć IEnumerable<T> i chcesz zrobić coś więcej niż tylko wyliczyć (np. użyj Count lub Any), a następnie rozważ najpierw konwersję do listy (metoda rozszerzenia ToList). W ten sposób gwarantujesz wyliczenie tylko raz.

• Jeśli projektowania API, która zwraca kolekcję, należy rozważyć powrót ICollection<T> (lub nawet IList<T>) zamiast IEnumerable<T> jak wielu ludzi wydaje się polecić. W ten sposób wzmacniasz swoją umowę, aby zagwarantować, że nie będziesz leniwy (a zatem nie będzie wielokrotnej oceny).

Uwaga mówię należy rozważyć powrocie zbiór, nie zawsze zwracać kolekcję. Jak zwykle pojawiają się kompromisy, jak wynika z komentarzy poniżej.

• @KeithS myśli, nigdy nie powinno się wydajnością na DataReader, a jednocześnie nigdy nie mów nigdy, powiedziałbym, że to generalnie dobra rada, że ​​warstwa dostępu do danych powinny zwrócić ICollection<T> aniżeli leniwy ocenie IEnumerable<T>, z powodów, które daje KeithS w swoim komentarzu.

• @Bear Monkey zauważa, że ​​tworzenie instancji listy może być kosztowne w powyższym przykładzie, jeśli baza danych zwróci dużą liczbę rekordów. To też jest prawdą, aw niektórych (prawdopodobnie rzadkich) przypadkach może być właściwe ignorowanie porad @ KeithS i zwracanie leniwo wyliczonego wyliczenia, pod warunkiem, że konsument robi coś, co nie jest zbyt czasochłonne (na przykład generuje pewne wartości zagregowane).

Answer 6

Należy pamiętać, że IEnumerable to tylko interfejs. Implementacja za nim może być bardzo różna w różnych klasach (rozważmy przykład Joego). Metoda rozszerzenia IEnumerable.Any() musi być podejściem generycznym i może nie być tym, czego potrzebujesz (zgodnie z wydajnością). Yossarian sugeruje środki, które powinny działać dla wielu klas, ale jeśli podstawowa implementacja nie wykorzystuje "wydajności", możesz zapłacić cenę.

Ogólnie rzecz biorąc, jeśli trzymasz się kolekcji lub tablic zawiniętych w interfejs IEnumerable, to Cristobalito i Yossarian prawdopodobnie mają najlepsze odpowiedzi. Domyślam się, że wbudowana metoda .Any() ext robi to, co zaleca Yossarian.

Answer 7

Można również pisać własne przeciążeń metodę rozszerzenia hrabia tak:

/// <summary> 
    /// Count is at least the minimum specified. 
    /// </summary> 
    /// <typeparam name="TSource"></typeparam> 
    /// <param name="source"></param> 
    /// <param name="min"></param> 
    /// <returns></returns> 
    public static bool Count<TSource>(this IEnumerable<TSource> source, int min) 
    { 
     if (source == null) 
     { 
      throw new ArgumentNullException("source"); 
     } 
     return source.Count(min, int.MaxValue); 
    } 

    /// <summary> 
    /// Count is between the given min and max values 
    /// </summary> 
    /// <typeparam name="TSource"></typeparam> 
    /// <param name="source"></param> 
    /// <param name="min"></param> 
    /// <param name="max"></param> 
    /// <returns></returns> 
    public static bool Count<TSource>(this IEnumerable<TSource> source, int min, int max) 
    { 
     if (source == null) 
     { 
      throw new ArgumentNullException("source"); 
     } 
     if (min <= 0) 
     { 
      throw new ArgumentOutOfRangeException("min", "min must be a non-zero positive number"); 
     } 
     if (max <= 0) 
     { 
      throw new ArgumentOutOfRangeException("max", "max must be a non-zero positive number"); 
     } 
     if (min >= max) 
      throw new ArgumentOutOfRangeException("min and max", "min must be lest than max"); 

     var isCollection = source as ICollection<TSource>; 

     if (isCollection != null) 
      return isCollection.Count >= min && isCollection.Count <= max; 

     var count = 0; 
     using (var enumerator = source.GetEnumerator()) 
     { 
      while (enumerator.MoveNext()) 
      { 
       count++; 
       if (count >= min && count <= max) 
        return true; 
      } 
     } 
     return false; 
    } 

Answer 8

jeśli to nie jest nazwą rodzajową niż czymś jak ten

enumeration.Cast<object>().Any(); 

jeśli jest nazwą rodzajową, użycie rozbudowa przeliczalny jak było powiedział już:

Answer 9

Użyj Enumerable.Empty(), która zamiast IEnumerable.Any() uniemożliwi zakończenie listy o wartości NULL.