Entity Framework works through a context. This is a C# class that binds entity models to database tables. We create models and a context for our project and wire that up to a physical database with sample records.

Data Models

The standard project template does not include all the tools needed to work with Entity Framework. The `dotnet` command line tool can install these for you. Behind the scenes this tool downloads additional libraries (DLLs) and makes a reference in the **RazorCountry.csproj** project file.

Add Entity Framework Tools

In this lesson you learned how to build database models and connect your ASP.NET application to a working database:
* _Models_ are C# classes that define entity structure. They are defined in the **Models/** folder.
* The _connection string_ is the link from the C# code to the physical database. It's defined in **appsettings.json**.
* Three packages are required to get Entity Framework (EF) running:
```
dotnet add package Microsoft.EntityFrameworkCore.SQLite
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet add package Microsoft.EntityFrameworkCore.Tools
```
* The _context_ is a class that acts as a middle man. It has C# methods that you can call to ask the database to do something useful, like add a record or return all rows in a table. It relies on the connection string in **appsettings.json** to physically locate the database file. It is defined in the **Data/** folder.
* The EF context is added to the app by editing `Startup.ConfigureServices()` and adding new functionality in **Program.cs** (we did that by adding the `CreateDBIfNotExists()` method).


In **Startup.cs**:
```cs
public void ConfigureServices(IServiceCollection services)
{
  services.AddRazorPages();
          
  services.AddDbContext<CountryContext>(options => 
    options.UseSqlite(Configuration.GetConnectionString("CountryContext")));
}
```

In **Program.cs**:
```cs
private static void CreateDbIfNotExists(IHost host)
{
  using (var scope = host.Services.CreateScope())
  {
    var services = scope.ServiceProvider;
    var context = services.GetRequiredService<CountryContext>();
    context.Database.EnsureCreated();
  }
}
```


EF Context Review

A web site might have many services that perform different functions for any number of pages. ASP.NET uses a technique called dependency injection to expose these middle-men services to each page as needed. We will add our newly created EF context (a C# class) so it can be injected into all the pages that need it.

Wire EF Context to Project

To keep things organized, folders are created to store the C# files that represent models and data handlers. Models are C# classes that define entity structure. Each class usually maps directly to a database table. Some types of databases (called no-SQL) do not have tables per se. That is why we refer to the model class as an entity and not specifically a table. All the models will go in the **Models** folder.

The models are simple C# classes with the name representing an entity. Think of this as a spreadsheet with tables that have columns with header names and rows with data. Each sheet is an entity. Each column in the sheet has a name. The property names in the model class are the same as the spreadsheet column names. They represent the schema. One difference is that each property must have a data type. That is a basic premise of the strongly typed C# approach. Each property has a getter and setter which means it can be written to and read from. An example model class would look like this:
```csharp
public class Student
{
   public string ID { get; set; }
   public string Name { get; set; }
}
```

Add Data Models

Entity Framework integration with ASP.NET Razor pages

This diagram will help you conceptualize the Entity Framework model process in action:

* The database connection string is stored in the **AppSettings.json** file
* Models are coded as C# classes that define field properties
* The Context is also a C# class that references the connection string and model classes forming a bridge from your code to physical table storage
* The EF Context can create the database and tables or reference an existing database
* Razor pages use dependency injection to consume the EF context making all referenced tables available to your page model code
* Code in the page model interacts with the EF context to pass data from the database to the page model member variables
* This data is merged with HTML markup to create web pages that are displayed in the browser

EF Context Diagram

To support database creation and maintenance, we'll need to add some code to our site. 

The **Data** folder will store the database-specific code needed for Microsoft Entity Framework (EF). This includes the context definition and sample data, both of which are C# classes. 

Using its included code generators, EF can generate the context class for you but we will instead build this from scratch. Later in the lesson we will add sample data by building another class file and calling it each time the site is run.

The _context_ is a class that acts as a middle man. It has C# methods that you can call to ask the database to do something useful like add a record or return all rows in a table. It relies on the connection string in **appsettings.json** to physically locate the database file. 

This middle man is often referred to as a service. A web site might have many services that perform different functions for any number of pages. ASP.NET uses a technique called dependency injection to expose these middle-men services to each page as needed.

Here are the steps needed to build the context and implement it as an injectable service:

* Add a context definition which is a C# class
* Define two `DbSet` `List` objects, each representing a database table
* Include the `OnModelCreating()` method that creates tables in the database if they are needed
* Edit the **Startup.cs** file to configure the context as a service
* Edit the **Program.cs** to conditionally create the database as needed

Build the Entity Framework Context

The connection string is the link from the C# code to the physical database. The context must know where the database is located and how to authenticate to the database service. That information is usually stored in a string specific to an environment (development, testing, staging, or production). Each type of database service has a specific format for the connection string. ASP.NET provides a handy place to store strings like this. It is the file called **appsettings.json**. By convention the connection string will have the same name as the context class. We will make and explain the context class in an upcoming exercise.

Add the Database Connection String

It is useful to have repeatable data for test driven development. This can happen through a series of commands in a C# class. The class file is a bit large so we will provide it to you. This class uses basic methods from the database context to `Add()` new records and `SaveChanges()`. It also uses the LINQ statement `Any()` to see if any records currently exist.

The file **Data/DbInitializer.cs** is open. The using statements reference our model classes and `System.Linq`. We will learn a lot more about the use of LINQ with a database context in an upcoming lesson.

Line 11 calls the context `EnsureCreated()` method to make sure the database file exists. We used this in an earlier exercise to force creation of the database. This new class will now replace that line in **Program.cs**.

Line 14 uses LINQ to check for the existence of any Continents. If they exist, the sample data does not need creation so the method ends (`return` statement).

The next two sections create arrays of `Continent` and `Country` objects. The context then uses `Add()` to include them in the `DbSet` for the associated List. The final step is to `SaveChanges()` which persists the new data items into the database file.

You are welcome to add any other Continents or Countries at this time. Make up the numbers and dates, you will be able to edit these later when we create an Edit page.

Once you are satisfied with this file, we can add it to **Program.cs** so that it is called before the app is run.