Make sure you've got our birds less loaded in this C# REPL for this video.

Most of our LINQ operators return an Enumerable,

what if we needed to be something else like a list or an array?

The one I use most often is ToList,

birds.Where b goes to

b.color equals Red and then I will call ToList.

Its usefulness might not be apparent though,

remember when we talked about deferred execution.

Since we're in the C# REPL, our queries are getting evaluated immediately.

If we assign a LINQ expression to a variable,

var redBirds equals birds.Where b goes to b.Color equals Red.

It doesn't get evaluated until we iterate on it.

So calling ToList or any of the other conversion operators

iterates through the sequence to produce the result.

And so our query is executed.

RedBirds.ToList.

Similarly, there's ToArray.

RedBirds.ToArray and now we have an array.

There's a few more conversion operators that can be useful in some edge cases,

like if you need a lookup or a dictionary.

I've linked to those in the notes.

You should check them out and think about how you could use them in a LINQ query.

>> Wow, that's a lot of operators we just used.

Did you take notes?

I find myself constantly looking up syntax and documentation on LINQ operators,

especially for ones I don't use very often.

We learn to use quantifiers to see if a sequence contains

elements that fit a condition.

Element operators to pick single elements out of a sequence.

We use partitioning operators to obtain a subset of a sequence and

joins to join multiple sequences together.

We performed aggregations to analyze our sequences.

We use set operations to remove duplicates and merge separate sequences into one.

We then learned we can use LINQ to generate sequences and

finally, to convert them to different types of sequences.

We've been working in workspaces this whole time.

You'll find that as you advance to coding in an IDE like Visual Studio.

The built in features will help you remember the usage without having

to look up the documentation.

Let's take a quick peek at how using an IDE

can help us jog our memories when writing LINQ queries.

>> I've got a blank console application here in Visual Studio,

let's create a list of numbers like we did earlier.

Var numbers equals new list of int and

we'll initialize it, 2,

4, 8, 16, 32, 64.

Okay, so we don't have the System.Linq namespace.

Let's look at what Visual Studio's IntelliSense tells us we can call

on the numbers variable.

So you'll notice we don't have any of the LINQ methods we've been using.

Just the normal list methods, so

let's add the System.Linq namespace using System.Linq.

Now, I'll type a period and it gives us a lot more methods, look at all those.

So notice the little arrow icon right here.

If I click on this, that arrow is indicating that it's an extension method.

And you can see here that we've got the definition and

the syntax for each of these.

Let's call the Where operator, we've used that a lot.

Where n goes to n is greater than 10.

If I hover over the n here,

notice that it's telling me the n parameter is an integer.

How helpful is that?

It can be really useful when writing LINQ queries.

So you see how Visual Studio gives us a lot of documentation, so

we don't necessarily have to go and find it ourselves.

What a huge help.