IEnumerable è vuoto?

Question

So che probabilmente non importa/influisce sulle prestazioni per la maggior parte, ma odio l'idea di ottenere un IEnumerable e di fare .Count(). C'è un IsEmpty o NotEmpty o qualche funzione? (Simile a Stl vuota())

Answer 1

Si desidera il metodo di estensione IEnumerable.Any() (.Net Framework 3.5 e versioni successive). Evita il conteggio degli elementi.

Answer 2

senza bisogno di LINQ, si può fare seguente:

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

Answer 3

On IEnumerable o IEnumerable<T>, no.

Ma in realtà non ha molto senso. Se una raccolta è vuota e si tenta di iterare su di essa utilizzando IEnumerable, la chiamata a IEnumerator.MoveNext() restituirà semplicemente false senza alcun costo di prestazioni.

Answer 4

Io non la penso così, questo è ciò che è Count. Inoltre, ciò che sarà più veloce:

1. accesso a una proprietà e il recupero di una stored Integer
2. accesso a una proprietà e il recupero di una stored Boolean

Answer 5

È possibile utilizzare metodi di estensione, come qualsiasi() o Count(). Count() è più costoso di Any(), poiché deve eseguire l'intera enumerazione, come altri hanno sottolineato.

Tuttavia, nel caso di una valutazione lenta (ad esempio un metodo che utilizza la resa), può essere costoso. Ad esempio, con il IEnumerable implementazione seguente, ogni chiamata a qualunque o Count dovranno sostenere il costo di un nuovo andata e ritorno al database:

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

Credo che la morale è:

• Se solo avere un IEnumerable<T>, e si vuole fare qualcosa di più che enumerarlo (es. usare Count o Any), quindi considerare prima di convertirlo in un List (metodo di estensione ToList). In questo modo garantisci di enumerare solo una volta.

• Se si progetta un'API che restituisce un insieme, in considerazione di ritornare ICollection<T> (o anche IList<T>) piuttosto che IEnumerable<T> come molte persone sembrano raccomandare. In tal modo si rafforza il contratto per garantire nessuna valutazione pigra (e quindi nessuna valutazione multipla).

Si prega di notare che sto dicendo si dovrebbe prendere in considerazione restituire una collezione, non sempre restituire un insieme. Come sempre ci sono trade-off, come si può vedere dai commenti qui sotto.

• @KeithS pensa si dovrebbe mai cedere su un DataReader, e mentre non ho mai dire mai, direi che è generalmente un buon consiglio che un Data Access Layer dovrebbe restituire un ICollection<T> piuttosto che un pigro-valutato IEnumerable<T>, per le ragioni che KeithS dà nel suo commento.

• @Bear Monkey osserva che l'istanziazione di un elenco può essere costosa nell'esempio precedente se il database restituisce un numero elevato di record. Anche questo è vero, e in alcuni casi (probabilmente rari) potrebbe essere opportuno ignorare il consiglio di @ KeithS e restituire un'enumerazione valutata pigramente, a condizione che il consumatore stia facendo qualcosa che non richiede troppo tempo (ad esempio generando alcuni valori aggregati).

Answer 6

Tenere presente che IEnumerable è solo un'interfaccia. L'implementazione alla base può essere molto diversa da una classe all'altra (si consideri l'esempio di Joe). Il metodo di estensione IEnumerable.Any() deve essere un approccio generico e potrebbe non essere quello che desideri (rendimento saggio). Yossarian suggerisce un mezzo che dovrebbe funzionare per molte classi, ma se l'implementazione sottostante non usa "yield" si potrebbe comunque pagare un prezzo.

In genere, se ci si attiene a raccolte o array racchiusi in un'interfaccia IEnumerable, Cristobalito e Yossarian probabilmente hanno le risposte migliori. La mia ipotesi è il built-in metodo .ny() ext fa quello che Yossarian raccomanda.

Answer 7

è anche possibile scrivere un proprio metodo di estensione Conte sovraccarichi in questo modo:

/// <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

se non è generica di smth come questo

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

se è generico, uso estensione di Enumerable come era detto già

Answer 9

Utilizzare Enumerable.Empty() che anziché IEnumerable.Any() impedirà di terminare con l'elenco Null.