Our next set of operators deal with partitioning a sequence, like finding and

extracting a subset of objects.

Let's peek at the documentation real quick.

Partitioning operators.

We've got take, skip, takeWhile, and skipWhile.

So let's switch back to work spaces and

make sure you've got your birds in your console.

I'll make sure I've got mine here.

If we need a certain number of objects from a sequence,

we can use the take operator.

Birds.Take(3).

It's more useful when you order the sequence first.

Let's get the top three birds with the shortest name.

birds.OrderBy b equals

to b.Name.Length and

then we'll take three.

Say we want the next three.

There's an operator for that.

We can skip the first three and then take the next three.

Birds.OrderBy b goes to b.

name .length and

then we'll skip three and

take three and there's the next three.

This can be really helpful when browsing results in a big sequence of objects.

If we had a thousand birds in our list and wanted to look at them all.

It wouldn't be helpful to print out all of them.

You wouldn't have enough space.

So instead we can show birds three at a time and

advance to the list with these operators.

Let's get the next set of three.

Skip six and take three.

Well it only gave us two.

There are no birds left, and it just returned all it had left.

The next two operators are similar but take a predicate.

Take while will produce all the elements up until a condition is met.

It's important to make sure the sequence is ordered correctly because it will

iterate through each element to see if the condition is met, and as soon as it's not,

it stops, birds.TakeWhile(b

Goes to b.Named.Length is less than and six.

Now that doesn't yield anything, what's the first bird in our list?

birds.First.

All right, it's a cardinal and the name Cardinal is eight characters long.

So it fail the condition immediately.

So if we ordered it by length first.

Birds.orderBy b goes to b.name.length.

And then takeWhile b goes to the same thing above.

B.name.length.

Is less than six.

And now we've got three and they all have names that are less than six characters.

There's also the skip while operator.

You should take a moment to pause this video and

write a query using the skip while operator.

That's similar to the one we just wrote.

That skips all the birds until their name is longer than six characters.

How did you do?

All we need to do is change the operator to a skip while.

Partitioning operators are useful in paging results, like with a search engine.

We'll see an example of this with our bird data later on.