Check if IEnumerable has ANY rows without enumerating over the entire list

Question

I have the following method which returns an IEnumerable of type T. The implementation of the method is not important, apart from the yield return to lazy load the IEnumerable. This is necessary as the result could have millions of items.

public IEnumerable<T> Parse()
{
    foreach(...)
    {
        yield return parsedObject;
    }
}

Problem:

I have the following property which can be used to determine if the IEnumerable will have any items:

public bool HasItems
{
    get
    {
        return Parse().Take(1).SingleOrDefault() != null;
    }
}

Is there perhaps a better way to do this?

Possible duplicate of [Howto: Count the items from a IEnumerable without iterating?](http://stackoverflow.com/questions/168901/howto-count-the-items-from-a-ienumerablet-without-iterating) — drzaus, Sep 01 '16 at 17:17

Marcus · Accepted Answer · 2013-06-04T10:41:50.160

47

IEnumerable.Any() will return true if there are any elements in the sequence and false if there are no elements in the sequence. This method will not iterate the entire sequence (only maximum one element) since it will return true if it makes it past the first element and false if it does not.

edited Jun 04 '13 at 10:41

answered Jun 04 '13 at 10:31

Marcus

8,230
11
61
88

Oh, I never knew about this overload of `Any`. But would it not also have to iterate at least once? – Dave New Jun 04 '13 at 10:35
No, it does not iterate. The Any method will return true if it makes it past the first item. – Marcus Jun 04 '13 at 10:35
5

This is not correct. It does begin to iterate the enumerable, however it does not iterate the entire thing. – Uatec Jun 04 '13 at 10:36
2

But it does not iterate the full sequence, only one item. – Marcus Jun 04 '13 at 10:37
2

@davenewza this is a linq method. Implemented as so: http://pastebin.com/Acq7WL0E – Uatec Jun 04 '13 at 10:38
@Marcus That's what I asked in my comment. But great, thanks for the answer. – Dave New Jun 04 '13 at 10:38
@Uatec: I am aware of `IEnumerable.Any(Func)`, I just didn't know about this parameterless overload. Thanks – Dave New Jun 04 '13 at 10:40
1

@BraveNewMath Works for me in LinqPad **if(!Addresses.Any()) { Addresses.Dump();** } – forcewill Feb 29 '16 at 17:11
@forcewill I trued it just now, and I didn't get the error. must have been a some other issue with the way the query was written. I don't have it anymore. – BraveNewMath Mar 05 '16 at 01:35
5

Be aware this can cause some unexpected effects. For example, if you first check for enumerable.Any() and then enter the foreach to enumerate your enumerable, you'll loose the first element of that enumerable, due to the way Any() works - it has already called e.MoveNext() once. – Mladen B. Feb 06 '17 at 15:13
15

No, that is incorrect. Any will do a MoveNext but the collection will not be modified and a following foreach will start at the first item (index = 0). This is easy for you to test yourself! – Marcus Feb 06 '17 at 15:25
2

The following foreach will start at the first item, but it will be a new enumeration. This means that you might get unexpected side effects: https://pastebin.com/y2AJvyKY – Mark Gjøl Aug 18 '17 at 13:29
1

@MladenB. you're confusing `IEnumerable` with `Enumerator`. The former produces the latter. `Any()` will use `GetEnumerator()` and indeed consume from that `Enumerator`, however any subsequent LINQ use will use a _new_ `Enumerator`. -- *However* depending on the source `IEnumerable` that may or may not produce the original item. For arrays and lists this will not happen, but with streaming enumerables you could indeed loose items. – Bouke Sep 05 '22 at 07:56
@Marcus what I tried to say is not that Any() modifies the sequence, but rather that your enumerable will be enumerated twice (if it's for example an SQL query). Any() calls MoveNext() which means it starts enumerating your sequence, so if you have a foreach loop right after a call to Any() (seen this so many times), your SQL query will be executed twice. That's the important thing I tried to draw attention to. If you materialize your enumerable into an in-memory collection, you won't feel this effect, of course, because your data is already stored in memory and accessed from there. – Mladen B. Sep 07 '22 at 07:31
@Bouke exactly like you said. It's just my poor choice of words... See my previous comment. – Mladen B. Sep 07 '22 at 07:33
@MladenB Yes, then I understand you, but I have no reason to believe that we are not talking about direct access to memory at this point and I would say, in most cases today, working with a database is normally using some sort of ORM and using IQueryable, but yeah, I agree. – Marcus Sep 09 '22 at 18:02

score 9 · Answer 2 · edited May 23 '17 at 11:54

Similar to Howto: Count the items from a IEnumerable<T> without iterating? an Enumerable is meant to be a lazy, read-forward "list", and like quantum mechanics the act of investigating it alters its state.

See confirmation: https://dotnetfiddle.net/GPMVXH

    var sideeffect = 0;
    var enumerable = Enumerable.Range(1, 10).Select(i => {
        // show how many times it happens
        sideeffect++;
        return i;
    });

    // will 'enumerate' one item!
    if(enumerable.Any()) Console.WriteLine("There are items in the list; sideeffect={0}", sideeffect);

enumerable.Any() is the cleanest way to check if there are any items in the list. You could try casting to something not lazy, like if(null != (list = enumerable as ICollection<T>) && list.Any()) return true.

Or, your scenario may permit using an Enumerator and making a preliminary check before enumerating:

var e = enumerable.GetEnumerator();
// check first
if(!e.MoveNext()) return;
// do some stuff, then enumerate the list
do {
    actOn(e.Current);  // do stuff with the current item
} while(e.MoveNext()); // stop when we don't have anything else

And updating the fiddle with the enumerator shows that the preliminary check, while still evaluating the enumerable 1 time (i.e. `sideeffect++`) doesn't result in _extra_ enumeration: https://dotnetfiddle.net/no3WoH — drzaus, Mar 17 '17 at 14:41
be aware that using Any(Func predicate) will generate "side effects" https://sharplab.io/#gist:60dd304540eee9eec3effb59ec1bb94d — Nathan Smiechowski, Jun 23 '21 at 09:34
@NathanSmiechowski yes that's what my example/fiddle is meant to show -- `sideeffect` is incremented once every time you call `.Any(with or w/o a predicate)`, since it has to enumerate at least one item from the list. — drzaus, Sep 14 '21 at 13:08

score 5 · Answer 3 · answered Mar 30 '22 at 12:15

The best way to answer this question, and to clear all doubts, is to see what the 'Any' function does.

   public static bool Any<TSource>(this IEnumerable<TSource> source) {
        if (source == null) throw Error.ArgumentNull("source");
        using (IEnumerator<TSource> e = source.GetEnumerator()) {
            if (e.MoveNext()) return true;
        }
        return false;
    }

https://github.com/microsoft/referencesource/blob/master/System.Core/System/Linq/Enumerable.cs

Check if IEnumerable has ANY rows without enumerating over the entire list

3 Answers3