TakeUntil differs from Enumerable.TakeWhile in two respects. Firstly, the sense
of the predicate is reversed: it is expected that the predicate will return false
to start with, and then return true - for example, when trying to find a matching
item in a sequence.
Secondly, TakeUntil yields the element which causes the predicate to return true. For
example, in a sequence
| Copy |
---|
{ 1, 2, 3, 4, 5 } |
and with a predicate of
| Copy |
---|
x => x == 3 |
, the result would be
| Copy |
---|
{ 1, 2, 3 } |
.
TakeUntil is as lazy as possible: it will not iterate over the source sequence
until it has to, it won't iterate further than it has to, and it won't evaluate
the predicate until it has to. (This means that an item may be returned which would
actually cause the predicate to throw an exception if it were evaluated, so long as
no more items of data are requested.)