[MUSIC]

Linked entities allows us to write queries against our model using C#.

This allows Visual Studio IntelliSense to assist us with the syntax of our queries

and with discovering the properties that are available on our entities.

So how does link to entities work?

LINQ Queries, either in fluent or

queries syntax, are written against one of the contexts as DbSet properties.

EF translates those link queries into the appropriate SQL statements,

which are then executed against the database.

EF then returns the query results using entity data model classes,

value types or projections into anonymous types.

In most cases, EF shields you from having to write SQL Queries,

though having a basic understanding of databases in SQL can be helpful.

That's especially true when you need to debug or troubleshoot a problem.

Before we start writing queries, let's see how we can monitor EF's database activity

so we can audit the SQL that EF generates from our link queries.

Luckily, this is easy to do.

We just need to set the context as database log property

to a method that will log messages.

We can define an anonymous method that accepts a single message parameter and

writes that parameter value to the output window using the Debug.WriteLine method.

context \.Database.Log

= (message) =>

Debug.WriteLine(message).

Be sure to add the using directive for the System.Diagnostics namespace.

Before we write our first query, let's comment out all of this

existing code by selecting the code and pressing Ctrl+K, Ctrl+C.

Let's start with the simplest query that we can write,

calling ToList on a DbSet property.

We just have the one DbSet property, comicBooks, so we'll use that one.

var comicBooks = context ComicBooks.ToList.

And let's write the number of comic books that are returned

from our query to the console.

Console.WriteLine, ("

# of comic books, (0),

comicBooks.Count").

Let's run the app.

Our query returned a total of nine comic books.

If we scroll up a bit in the output window,

we can see the queries that EF executes in order to determine if the database exists.

And if it's in sync with our model.

The last query is our comic books query.

This is a straightforward query that selects all the comic book table columns.

Every row from the table will be returned,

which in our case is nine rows as we aren't doing any filtering.

We can rewrite this query using link queries syntax.

var comicBooks = from cb

in context.ComicBooks select cb.

Once we finish rewriting the query, notice that we get an error trying to access

the Count Property on the comicBooks variable.

If we hover over the comicBooks variable,

we can see that the variables type is IQueryable of type comicBook.

The IQueryable interface extends the IEnumerable interface.

The query that is represented by the comic book's variable won't be executed until

it's enumerated, either by using a loop or by calling a method like to list or Count.

This behavior is called deferred execution.

Let's run an experiment to see deferred execution in action.

Rename the comic books variable to comingBooksQuery, and

call the to list method return in the results into the comicBooksVariable,

var comicBooks = comicBooksQuery.ToList Set a breakpoint

on the line of code containing the ToList method call.

And run the app.

Here we are at our breakpoint.

if we look in the output window, we can see that the last query that was executed

was ES query against the migration history table.

So, while we've defined our query, it hasn't been executed yet and it won't.

Not until we call the ToList method.

Press F10 to execute the next line of code.

Now in the output window, we can see that EFS executed our query.

Go ahead and press F5, and then Enter to continue execution.

Deferred execution on the surface can seem unintuitive or even disadvantageous.

Deferred execution does have its advantages.

Including the ability to execute a query more than once, or to combine or

extend the query before it's executed.

We'll see an example of the latter later in the section.

Next, let's see how we can filter the results of our query.