Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


ASP.NET database models provide a connection from C# code to a physical database. The Microsoft Entity Framework optional packages contain methods and structures to represent tables as entity lists. This lesson creates a sample ASP.NET site from a template and adds the necessary files and code changes to link to and create a database.

Data Projects

The **Pages** folder tree contains all of the Razor Pages (.cshtml) with their associated `PageModel` class files (.cs). Open the **Index.cshtml** page to see how Razor markup is used. Notice it starts with the directive `@page` followed by `@model IndexModel`. The rest of the page is a mix of C# code and HTML markup.

Our data project requires several new pages that will live under this folder.

Inspect the Index File

The file **_ViewStart.cshtml** is a hidden (starts with _) page that is included in all other pages. A common use for this is setting the layout page so all pages have a consistent header, left navigation, and footer.

Inspect the _ViewStart File

The file **Startup.cs** has a class constructor that is passed a configuration object defined by the interface `IConfiguration`. This interface requires the `ConfigureServices()` and `Configure()` methods. Services are bodies of C# code that are accessible to all pages and classes in your project. In this case, the `AddRazorPages()` service is added to support UI pages with Razor syntax. The `Configure()` method adds additional features:
* `UseHttpRedirection` (reroutes HTTP requests to HTTPS)
* `UseStaticFiles` (allows JS, CSS, images, and other static files)
* `UseRouting` (manages the URL in the browser)
* `UseAuthorization` (allows login and user personalization)
* `UseEndpoints` (which calls `MapRazorPages()` to establish URL routing).

Inspect the Startup File

It is easy to make changes to the default site template. This is an iterative process of code editing, saving, and running the site to see the result. Let’s make some simple changes to the **_Layout.cshtml** page so that a more useful header and footer are displayed on every page.

Make Some Basic UI Changes

**_ViewImports.cshtml** is a hidden page that is included at the top of each of the other pages. It is commonly used to add `using` statements so all code has access to the correct namespaces and assemblies.

Our data project only uses the default include statements of this feature.

Inspect the _ViewImports File

Our site will take advantage of the popular CSS style framework called Bootstrap. Note the version number and refer [to the Bootstrap site](https://getbootstrap.com) for styling examples.

Inspect the bootstrap.css File

Larger ASP.NET projects often work with data stored in a database. A database is a program that allows data to be easily accessed, manipulated, and updated. The database can persist data in memory or on disk and is managed by a service that runs on a server or in the cloud. Our goal is to attach a database to an ASP.NET web site and store some data in row and column format.

An ASP.NET Core starter site is needed to demonstrate this concept. The .NET Core command line utility `dotnet` can create a new project and build all the files necessary to get us up and running. The checkpoints below walk you through the starter site and explain the folder and file structure. Every one of these items will be used in some way as we develop a complete database connected solution.

There is a basic sequence of tasks required to create the database and a set of pages necessary to **C**reate, **R**ead, **U**pdate, and **D**elete data items (often referred to by the acronym **CRUD**). All the tasks are managed by C# code in a set of [NuGet packages](https://www.nuget.org/). The following exercises demonstrate these tasks.

Not all ASP.NET sites need database management so this feature is added separately. Our sample uses an open source database called [SQLite](https://sqlite.org/index.html) and the Microsoft open source [**E**ntity **F**ramework tools](https://docs.microsoft.com/en-us/aspnet/entity-framework) (often called EF). EF is a Microsoft data framework that uses C# classes and methods to represent data entities. There are many alternative frameworks including micro-ORMs (**O**bject **R**elational **M**apping) like Dapper, NHibernate, and SQLAlchemy.

Our sample site will store the names of continents and countries so it will be called RazorCountry.

Build a Project from a Template

Use the file manager to expand the **Properties** folder and open **launchSettings.json**. This file defines launch parameters with options for authentication and the web server hosting environment. Look here to see what port number will be used when testing your site in a browser.

Inspect the launchSettings File

Use the file manager to open **Index.cshtml.cs** to see how the `PageModel` class is built for the page. Notice that the class name matches the Razor page name with the suffix Model. These classes must inherit from the `PageModel` class. By default, a logger service is injected into the constructor for the `PageModel`. This enables centralized error logging.

We will use the same injection approach to access our data services.

Inspect the Index Page Model File

Use the file manager to expand the **Shared** folder and open **_Layout.cshtml**. This hidden page defines the HTML for the header, left navigation, and footer. There are two special directives used in this page. `@RenderBody()` is replaced with the markup from each page that uses _Layout. In this case it lives inside a `<div class="container">`. This is a bootstrap CSS convention that provides correct spacing and padding. The second directive is `@RenderSection`. This will be replaced by `<script>` blocks as needed for things like input validation.

Inspect the _Layout File

The file **appsettings.json** stores application level settings. The application (project) can access these settings in code. Things like logging levels and database connection strings are stored here. The app settings can change from one environment to another and it is common to have separate files for Development, User Acceptance, and Production.

Inspect the appsettings File

Use the file manager to open the **wwwroot** folder. All static files are stored here. There are default folders for **css** (styles), **js** (front end JavaScript code), and **lib** (third party libraries). Open lib to see that jquery and bootstrap are available.

Data validation requires JavaScript files which are stored in the **wwwroot/scripts** area.

Inspect the site.css File

The file **RazorCountry.csproj** is open. This is a project file for .NET Core. It uses markup syntax to store the `<TargetFramework>`. Additional frameworks added to the project will be listed here, but we'll be using the provided `netcoreapp3.1`, which signifies .NET Core framework, version 3.1.

Additional tools added to the project will appear here including Entity Framework support for a SQLite database.

Inspect the Project File

The file **Program.cs** with the `Main()` method is the starting point for a .NET Core program. It calls the `CreateHostBuilder(args)` method and passes in any arguments from the command line. Method chaining is used to `Build()` the web site and `Run()` it. `CreateHostBuilder()` uses the `Host` service to configure a web site using a `webBuilder` that calls the `Startup()` class.