Table of Contents

Introduction
Getting Started
Create a Web app
Create a Web API
Tutorials
Create a Razor Pages web app on Windows
Getting started with Razor Pages
Adding a model
Scaffolded Razor Pages
SQL Server LocalDB
Updating the pages
Adding search
Adding a new field
Adding validation
Create a Razor Pages web app on a Mac
Getting started with Razor Pages
Adding a model
Create a Razor Pages web app with VS Code
Getting started with Razor Pages
Adding a model
Create an MVC web app on Windows
Getting started
Adding a controller
Adding a view
Adding a model
Working with SQL Server LocalDB
Controller methods and views
Adding search
Adding a New Field
 Adding Validation
Examining the Details and Delete methods
Create an MVC web app on a Mac
Getting started
Adding a controller
Adding a view
Adding a model
Working with SQLite
Controller methods and views
Adding search
Adding a New Field
Adding Validation
Examining the Details and Delete methods
Create an MVC web app with VS Code
Getting started
Adding a controller
Adding a view
Adding a model
Working with SQLite
Controller methods and views
Adding search
Adding a New Field
Adding Validation
Examining the Details and Delete methods
Data access - working with EF Core
Getting started
Create, Read, Update, and Delete operations
Sorting, filtering, paging, and grouping
Migrations
Creating a complex data model
Reading related data
Updating related data
 Handling concurrency conflicts
Inheritance
Advanced topics
Creating backend services for mobile apps
Building Web APIs
Create a Web API
ASP.NET Web API Help Pages using Swagger
Creating backend services for native mobile applications
Fundamentals
Application Startup
Middleware
Working with Static Files
Routing
URL Rewriting Middleware
Error Handling
WebSockets
Globalization and localization
Configuration
Logging
File Providers
Dependency Injection
Working with Multiple Environments
Hosting
Session and application state
Servers
Kestrel
ASP.NET Core Module
WebListener
HTTP.sys
Request Features
Open Web Interface for .NET (OWIN)
Choose between ASP.NET Core and ASP.NET
 Choose between .NET Core and .NET Framework runtime
Microsoft.AspNetCore.All metapackage
MVC
Razor Pages
Razor syntax
Model Binding
Model validation
Views
Razor syntax
View compilation
Layout
Tag helpers
Partial views
Dependency injection into views
View components
Controllers
Routing to controller actions
File uploads
Dependency injection into controllers
Testing controllers
Advanced
Working with the Application Model
Filters
Areas
Application parts
Custom Model Binding
Custom formatters
Formatting response data
Testing and debugging
Unit testing
Integration testing
Testing controllers
 Remote debugging
Working with Data
Getting started with ASP.NET Core and Entity Framework Core using Visual Studio
ASP.NET Core with EF Core - new database
ASP.NET Core with EF Core - existing database
Getting Started with ASP.NET Core and Entity Framework 6
Azure Storage
Adding Azure Storage by using Visual Studio Connected Services
Get started with Blob storage and Visual Studio Connected Services
Get Started with Queue Storage and Visual Studio Connected Services
Get Started with Table Storage and Visual Studio Connected Services
Client-Side Development
Using Gulp
Using Grunt
Manage client-side packages with Bower
Building beautiful, responsive sites with Bootstrap
Knockout.js MVVM Framework
Using AngularJS for Single Page Apps
Using JavaScriptServices for Single Page Apps
Styling applications with Less, Sass, and Font Awesome
Bundling and minification
Building Projects with Yeoman
Using Browser Link
Mobile
Creating Backend Services for Native Mobile Applications
Hosting and deployment
Hosting
Host on Windows with IIS
Host in a Windows service
Host on Linux with Nginx
Host on Linux with Apache
Host in Docker
 Deployment
Publish to Azure with Visual Studio
Continuous deployment to Azure with Visual Studio and Git
Continuous deployment to Azure with VSTS
Publish profiles in Visual Studio
Directory structure
Security
Authentication
Community OSS authentication options
Introduction to Identity
Configure Identity
Configure Windows Authentication
Configure primary key type for Identity
Custom storage providers for ASP.NET Core Identity
Enabling authentication using Facebook, Google and other external providers
Account Confirmation and Password Recovery
Enabling QR Code generation in ASP.NET identity
Two-factor authentication with SMS
Using Cookie Authentication without ASP.NET Core Identity
Azure Active Directory
Securing ASP.NET Core apps with IdentityServer4
Authorization
Introduction
Create an app with user data protected by authorization
Simple Authorization
Role based Authorization
Claims-Based Authorization
Custom Policy-Based Authorization
Dependency Injection in requirement handlers
Resource Based Authorization
View Based Authorization
Limiting identity by scheme
 Data Protection
Introduction to Data Protection
Getting Started with the Data Protection APIs
Consumer APIs
Configuration
Extensibility APIs
Implementation
Compatibility
Enforcing SSL
Safe storage of app secrets during development
Azure Key Vault configuration provider
Anti-Request Forgery
Preventing Open Redirect Attacks
Preventing Cross-Site Scripting
Enabling Cross-Origin Requests
Performance
Caching
In-Memory Caching
Working with a Distributed Cache
Response Caching
Response Caching Middleware
Response Compression Middleware
Migration
ASP.NET to ASP.NET Core 1.x
Configuration
Authentication and Identity
Web API
HTTP Modules to Middleware
ASP.NET to ASP.NET Core 2.0
ASP.NET Core 1.x to 2.0
Authentication and Identity
API Reference
2.0 release notes
1.1 Release notes
Earlier release notes
VS 2015/project.json docs
Contribute
 Introduction to ASP.NET Core
9/12/2017 2 min to read Edit Online

By Daniel Roth, Rick Anderson, and Shaun Luttin

ASP.NET Core is a cross-platform, high-performance, open-source framework for building modern, cloud-based,
Internet-connected applications. With ASP.NET Core, you can:
Build web apps and services, IoT apps, and mobile backends.
Use your favorite development tools on Windows, macOS, and Linux.
Deploy to the cloud or on-premises
Run on .NET Core or .NET Framework.

Why use ASP.NET Core?

Millions of developers have used ASP.NET (and continue to use it) to create web apps. ASP.NET Core is a redesign
of ASP.NET, with architectural changes that result in a leaner and modular framework.
ASP.NET Core provides the following benefits:
A unified story for building web UI and web APIs.
Integration of modern client-side frameworks and development workflows.
A cloud-ready, environment-based configuration system.
Built-in dependency injection.
A lightweight, high-performance, and modular HTTP request pipeline.
Ability to host on IIS or self-host in your own process.
Can run on .NET Core, which supports true side-by-side app versioning.
Tooling that simplifies modern web development.
Ability to build and run on Windows, macOS, and Linux.
Open-source and community-focused.
ASP.NET Core ships entirely as NuGet packages. This allows you to optimize your app to include just the NuGet
packages you need. The benefits of a smaller app surface area include tighter security, reduced servicing, and
improved performance.

Build web APIs and web UI using ASP.NET Core MVC

ASP.NET Core MVC provides features that help you build web APIs and web apps:
The Model-View-Controller (MVC) pattern helps make your web APIs and web apps testable.
Razor Pages (new in 2.0) is a page-based programming model that makes building web UI easier and more
productive.
Razor syntax provides a productive language for Razor Pages and MVC Views.
Tag Helpers enable server-side code to participate in creating and rendering HTML elements in Razor files.
Built-in support for multiple data formats and content negotiation lets your web APIs reach a broad range of
clients, including browsers and mobile devices.
Model Binding automatically maps data from HTTP requests to action method parameters.
Model Validation automatically performs client and server-side validation.
Client-side development
ASP.NET Core is designed to integrate seamlessly with a variety of client-side frameworks, including AngularJS,
KnockoutJS, and Bootstrap. See Client-side development for more details.

Next steps
For more information, see the following resources:
ASP.NET Core tutorials
ASP.NET Core fundamentals
The weekly ASP.NET community standup covers the team's progress and plans and features new blogs and
third-party software.
 Getting Started with ASP.NET Core
9/12/2017 1 min to read Edit Online

NOTE
These instructions are for the latest version of ASP.NET Core. Looking to get started with an earlier version? See the 1.1
version of this tutorial.

1. Install .NET Core.

2. Create a new .NET Core project.
On macOS and Linux, open a terminal window. On Windows, open a command prompt.

dotnet new razor -o aspnetcoreapp

3. Run the app.

Use the following commands to run the app:

cd aspnetcoreapp
dotnet run

4. Browse to http://localhost:5000
5. Open Pages/About.cshtml and modify the page to display the message "Hello, world! The time on the server
is @DateTime.Now":

@page
@model AboutModel
@{
ViewData["Title"] = "About";
}
<h2>@ViewData["Title"]</h2>
<h3>@Model.Message</h3>

<p>Use this area to provide additional information.</p>

6. Browse to http://localhost:5000/About and verify the changes.

Next steps
For getting-started tutorials, see ASP.NET Core Tutorials
For an introduction to ASP.NET Core concepts and architecture, see ASP.NET Core Introduction and ASP.NET Core
Fundamentals.
An ASP.NET Core app can use the .NET Core or .NET Framework Base Class Library and runtime. For more
information, see Choosing between .NET Core and .NET Framework.
 Introduction to Razor Pages in ASP.NET Core
9/25/2017 15 min to read Edit Online

By Rick Anderson and Ryan Nowak

Razor Pages is a new feature of ASP.NET Core MVC that makes coding page-focused scenarios easier and more
productive.
If you're looking for a tutorial that uses the Model-View-Controller approach, see Getting started with ASP.NET Core
MVC.

ASP.NET Core 2.0 prerequisites

Install .NET Core 2.0.0 or later.
If you're using Visual Studio, install Visual Studio 2017 version 15.3 or later with the following workloads:
ASP.NET and web development
.NET Core cross-platform development

Creating a Razor Pages project

Visual Studio
Visual Studio for Mac
Visual Studio Code
.NET Core CLI
See Getting started with Razor Pages for detailed instructions on how to create a Razor Pages project using Visual
Studio.

Razor Pages
Razor Pages is enabled in Startup.cs:

public class Startup

{
public void ConfigureServices(IServiceCollection services)
{
// Includes support for Razor Pages and controllers.
services.AddMvc();
}

public void Configure(IApplicationBuilder app)

{
app.UseMvc();
}
}

Consider a basic page:

 @page

<h1>Hello, world!</h1>
<h2>The time on the server is @DateTime.Now</h2>

The preceding code looks a lot like a Razor view file. What makes it different is the @page directive. @page makes
the file into an MVC action - which means that it handles requests directly, without going through a controller.
@page must be the first Razor directive on a page. @page affects the behavior of other Razor constructs.

A similar page, using a PageModel class, is shown in the following two files. The Pages/Index2.cshtml file:

@page
@using RazorPages
@model IndexModel2

<h2>Separate page model</h2>

<p>
@Model.Message
</p>

The Pages/Index2.cshtml.cs "code-behind" file:

using Microsoft.AspNetCore.Mvc.RazorPages;
using System;

namespace RazorPages
{
public class IndexModel2 : PageModel
{
public string Message { get; private set; } = "PageModel in C#";

public void OnGet()

{
Message += $" Server time is { DateTime.Now }";
}
}
}

By convention, the PageModel class file has the same name as the Razor Page file with .cs appended. For example,
the previous Razor Page is Pages/Index2.cshtml. The file containing the PageModel class is named
Pages/Index2.cshtml.cs.
The associations of URL paths to pages are determined by the page's location in the file system. The following table
shows a Razor Page path and the matching URL:

FILE NAME AND PATH MATCHING URL

/Pages/Index.cshtml / or /Index

/Pages/Contact.cshtml /Contact

/Pages/Store/Contact.cshtml /Store/Contact

/Pages/Store/Index.cshtml /Store or /Store/Index

Notes:
 The runtime looks for Razor Pages files in the Pages folder by default.
Index is the default page when a URL doesn't include a page.

Writing a basic form

Razor Pages features are designed to make common patterns used with web browsers easy. Model binding, Tag
Helpers, and HTML helpers all just work with the properties defined in a Razor Page class. Consider a page that
implements a basic "contact us" form for the Contact model:
For the samples in this document, the DbContext is initialized in the Startup.cs file.

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using RazorPagesContacts.Data;

namespace RazorPagesContacts
{
public class Startup
{
public IHostingEnvironment HostingEnvironment { get; }

public void ConfigureServices(IServiceCollection services)

{
services.AddDbContext<AppDbContext>(options =>
options.UseInMemoryDatabase("name"));
services.AddMvc();
}

public void Configure(IApplicationBuilder app)

{
app.UseMvc();
}
}
}

The data model:

using System.ComponentModel.DataAnnotations;

namespace RazorPagesContacts.Data
{
public class Customer
{
public int Id { get; set; }

[Required, StringLength(100)]
public string Name { get; set; }
}
}

The Pages/Create.cshtml view file:

 @page
@model RazorPagesContacts.Pages.CreateModel
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

<html>
<body>
<p>
Enter your name.
</p>
<div asp-validation-summary="All"></div>
<form method="POST">
<div>Name: <input asp-for="Customer.Name" /></div>
<input type="submit" />
</form>
</body>
</html>

The Pages/Create.cshtml.cs code-behind file for the view:

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using RazorPagesContacts.Data;

namespace RazorPagesContacts.Pages
{
public class CreateModel : PageModel
{
private readonly AppDbContext _db;

public CreateModel(AppDbContext db)

{
_db = db;
}

[BindProperty]
public Customer Customer { get; set; }

public async Task<IActionResult> OnPostAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_db.Customers.Add(Customer);
await _db.SaveChangesAsync();
return RedirectToPage("/Index");
}
}
}

By convention, the PageModel class is called <PageName>Model and is in the same namespace as the page.
Using a PageModel code-behind file supports unit testing, but requires you to write an explicit constructor and class.
Pages without PageModel code-behind files support runtime compilation, which can be an advantage in
development.
The page has an OnPostAsync handler method, which runs on POST requests (when a user posts the form). You can
add handler methods for any HTTP verb. The most common handlers are:
OnGet to initialize state needed for the page. OnGet sample.
OnPost to handle form submissions.
The Async naming suffix is optional but is often used by convention for asynchronous functions. The OnPostAsync
code in the preceding example looks similar to what you would normally write in a controller. The preceding code is
typical for Razor Pages. Most of the MVC primitives like model binding, validation, and action results are shared.
The previous OnPostAsync method:

public async Task<IActionResult> OnPostAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_db.Customers.Add(Customer);
await _db.SaveChangesAsync();
return RedirectToPage("/Index");
}

The basic flow of OnPostAsync :

Check for validation errors.
If there are no errors, save the data and redirect.
If there are errors, show the page again with validation messages. Client-side validation is identical to traditional
ASP.NET Core MVC applications. In many cases, validation errors would be detected on the client, and never
submitted to the server.
When the data is entered successfully, the OnPostAsync handler method calls the RedirectToPage helper method to
return an instance of RedirectToPageResult . RedirectToPage is a new action result, similar to RedirectToAction or
RedirectToRoute , but customized for pages. In the preceding sample, it redirects to the root Index page ( /Index ).
RedirectToPage is detailed in the URL generation for Pages section.

When the submitted form has validation errors (that are passed to the server), the OnPostAsync handler method
calls the Page helper method. Page returns an instance of PageResult . Returning Page is similar to how actions
in controllers return View . PageResult is the default return type for a handler method. A handler method that
returns void renders the page.
The Customer property uses [BindProperty] attribute to opt in to model binding.
 public class CreateModel : PageModel
{
private readonly AppDbContext _db;

public CreateModel(AppDbContext db)

{
_db = db;
}

[BindProperty]
public Customer Customer { get; set; }

public async Task<IActionResult> OnPostAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_db.Customers.Add(Customer);
await _db.SaveChangesAsync();
return RedirectToPage("/Index");
}
}

Razor Pages, by default, bind properties only with non-GET verbs. Binding to properties can reduce the amount of
code you have to write. Binding reduces code by using the same property to render form fields (
<input asp-for="Customer.Name" /> ) and accept the input.

The home page (Index.cshtml):

@page
@model RazorPagesContacts.Pages.IndexModel
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

<h1>Contacts</h1>
<form method="post">
<table class="table">
<thead>
<tr>
<th>ID</th>
<th>Name</th>
</tr>
</thead>
<tbody>
@foreach (var contact in Model.Customers)
{
<tr>
<td>@contact.Id</td>
<td>@contact.Name</td>
<td>
<a asp-page="./Edit" asp-route-id="@contact.Id">edit</a>
<button type="submit" asp-page-handler="delete"
asp-route-id="@contact.Id">delete</button>
</td>
</tr>
}
</tbody>
</table>

<a asp-page="./Create">Create</a>
</form>

The code behind Index.cshtml.cs file:

 using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using RazorPagesContacts.Data;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;

namespace RazorPagesContacts.Pages
{
public class IndexModel : PageModel
{
private readonly AppDbContext _db;

public IndexModel(AppDbContext db)

{
_db = db;
}

public IList<Customer> Customers { get; private set; }

public async Task OnGetAsync()

{
Customers = await _db.Customers.AsNoTracking().ToListAsync();
}

public async Task<IActionResult> OnPostDeleteAsync(int id)

{
var contact = await _db.Customers.FindAsync(id);

if (contact != null)
{
_db.Customers.Remove(contact);
await _db.SaveChangesAsync();
}

return RedirectToPage();
}
}
}

The Index.cshtml file contains the following markup to create an edit link for each contact:

<a asp-page="./Edit" asp-route-id="@contact.Id">edit</a>

The Anchor Tag Helper used the asp-route-{value} attribute to generate a link to the Edit page. The link contains
route data with the contact ID. For example, http://localhost:5000/Edit/1 .
The Pages/Edit.cshtml file:
 @page "{id:int}"
@model RazorPagesContacts.Pages.EditModel
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

@{
ViewData["Title"] = "Edit Customer";
}

<h1>Edit Customer - @Model.Customer.Id</h1>

<form method="post">
<div asp-validation-summary="All"></div>
<input asp-for="Customer.Id" type="hidden" />
<div>
<label asp-for="Customer.Name"></label>
<div>
<input asp-for="Customer.Name" />
<span asp-validation-for="Customer.Name" ></span>
</div>
</div>

<div>
<button type="submit">Save</button>
</div>
</form>

The first line contains the @page "{id:int}" directive. The routing constraint "{id:int}" tells the page to accept
requests to the page that contain int route data. If a request to the page doesn't contain route data that can be
converted to an int , the runtime returns an HTTP 404 (not found) error.
The Pages/Edit.cshtml.cs file:
 using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.EntityFrameworkCore;
using RazorPagesContacts.Data;

namespace RazorPagesContacts.Pages
{
public class EditModel : PageModel
{
private readonly AppDbContext _db;

public EditModel(AppDbContext db)

{
_db = db;
}

[BindProperty]
public Customer Customer { get; set; }

public async Task<IActionResult> OnGetAsync(int id)

{
Customer = await _db.Customers.FindAsync(id);

if (Customer == null)
{
return RedirectToPage("/Index");
}

return Page();
}

public async Task<IActionResult> OnPostAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_db.Attach(Customer).State = EntityState.Modified;

try
{
await _db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw new Exception($"Customer {Customer.Id} not found!");
}

return RedirectToPage("/Index");
}
}
}

XSRF/CSRF and Razor Pages

You don't have to write any code for antiforgery validation. Antiforgery token generation and validation are
automatically included in Razor Pages.

Using Layouts, partials, templates, and Tag Helpers with Razor Pages
Pages work with all the features of the Razor view engine. Layouts, partials, templates, Tag Helpers,
_ViewStart.cshtml, _ViewImports.cshtml work in the same way they do for conventional Razor views.
Let's declutter this page by taking advantage of some of those features.
Add a layout page to Pages/_Layout.cshtml:

<!DOCTYPE html>
<html>
<head>
<title>Razor Pages Sample</title>
</head>
<body>
<a asp-page="/Index">Home</a>
@RenderBody()
<a asp-page="/Customers/Create">Create</a> <br />
</body>
</html>

The Layout:
Controls the layout of each page (unless the page opts out of layout).
Imports HTML structures such as JavaScript and stylesheets.
See layout page for more information.
The Layout property is set in Pages/_ViewStart.cshtml:

@{
Layout = "_Layout";
}

Note: The layout is in the Pages folder. Pages look for other views (layouts, templates, partials) hierarchically,
starting in the same folder as the current page. A layout in the Pages folder can be used from any Razor page under
the Pages folder.
We recommend you not put the layout file in the Views/Shared folder. Views/Shared is an MVC views pattern.
Razor Pages are meant to rely on folder hierarchy, not path conventions.
View search from a Razor Page includes the Pages folder. The layouts, templates, and partials you're using with
MVC controllers and conventional Razor views just work.
Add a Pages/_ViewImports.cshtml file:

@namespace RazorPagesContacts.Pages
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

@namespace is explained later in the tutorial. The @addTagHelper directive brings in the built-in Tag Helpers to all the
pages in the Pages folder.
When the @namespace directive is used explicitly on a page:
 @page
@namespace RazorPagesIntro.Pages.Customers

@model NameSpaceModel

<h2>Name space</h2>
<p>
@Model.Message
</p>

The directive sets the namespace for the page. The @model directive doesn't need to include the namespace.
When the @namespace directive is contained in _ViewImports.cshtml, the specified namespace supplies the prefix for
the generated namespace in the Page that imports the @namespace directive. The rest of the generated namespace
(the suffix portion) is the dot-separated relative path between the folder containing _ViewImports.cshtml and the
folder containing the page.
For example, the code behind file Pages/Customers/Edit.cshtml.cs explicitly sets the namespace:

namespace RazorPagesContacts.Pages
{
public class EditModel : PageModel
{
private readonly AppDbContext _db;

public EditModel(AppDbContext db)

{
_db = db;
}

// Code removed for brevity.

The Pages/_ViewImports.cshtml file sets the following namespace:

@namespace RazorPagesContacts.Pages
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

The generated namespace for the Pages/Customers/Edit.cshtml Razor Page is the same as the code behind file. The
@namespace directive was designed so the C# classes added to a project and pages-generated code just work
without having to add an @using directive for the code behind file.
Note: @namespace also works with conventional Razor views.
The original Pages/Create.cshtml view file:
 @page
@model RazorPagesContacts.Pages.CreateModel
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

<html>
<body>
<p>
Enter your name.
</p>
<div asp-validation-summary="All"></div>
<form method="POST">
<div>Name: <input asp-for="Customer.Name" /></div>
<input type="submit" />
</form>
</body>
</html>

The updated Pages/Create.cshtml view file:

@page
@model CreateModel

<html>
<body>
<p>
Enter your name.
</p>
<div asp-validation-summary="All"></div>
<form method="POST">
<div>Name: <input asp-for="Customer.Name" /></div>
<input type="submit" />
</form>
</body>
</html>

The Razor Pages starter project contains the Pages/_ValidationScriptsPartial.cshtml, which hooks up client-side
validation.

URL generation for Pages

The Create page, shown previously, uses RedirectToPage :

public async Task<IActionResult> OnPostAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_db.Customers.Add(Customer);
await _db.SaveChangesAsync();
return RedirectToPage("/Index");
}

The app has the following file/folder structure:

/Pages
Index.cshtml
/Customer
 Create.cshtml
Edit.cshtml
Index.cshtml
The Pages/Customers/Create.cshtml and Pages/Customers/Edit.cshtml pages redirect to Pages/Index.cshtml after
success. The string /Index is part of the URI to access the preceding page. The string /Index can be used to
generate URIs to the Pages/Index.cshtml page. For example:
Url.Page("/Index", ...)
<a asp-page="/Index">My Index Page</a>
RedirectToPage("/Index")

The page name is the path to the page from the root /Pages folder (including a leading / , for example /Index ).
The preceding URL generation samples are much more feature rich than just hardcoding a URL. URL generation
uses routing and can generate and encode parameters according to how the route is defined in the destination
path.
URL generation for pages supports relative names. The following table shows which Index page is selected with
different RedirectToPage parameters from Pages/Customers/Create.cshtml:

REDIRECTTOPAGE(X) PAGE

RedirectToPage("/Index") Pages/Index

RedirectToPage("./Index"); Pages/Customers/Index

RedirectToPage("../Index") Pages/Index

RedirectToPage("Index") Pages/Customers/Index

RedirectToPage("Index") , RedirectToPage("./Index") , and RedirectToPage("../Index") are relative names. The

RedirectToPage parameter is combined with the path of the current page to compute the name of the destination
page.
Relative name linking is useful when building sites with a complex structure. If you use relative names to link
between pages in a folder, you can rename that folder. All the links still work (because they didn't include the folder
name).

TempData
ASP.NET Core exposes the TempData property on a controller. This property stores data until it is read. The Keep
and Peek methods can be used to examine the data without deletion. TempData is useful for redirection, when data
is needed for more than a single request.
The [TempData] attribute is new in ASP.NET Core 2.0 and is supported on controllers and pages.
The following code sets the value of Message using TempData :
 public class CreateDotModel : PageModel
{
private readonly AppDbContext _db;

public CreateDotModel(AppDbContext db)

{
_db = db;
}

[TempData]
public string Message { get; set; }

[BindProperty]
public Customer Customer { get; set; }

public async Task<IActionResult> OnPostAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_db.Customers.Add(Customer);
await _db.SaveChangesAsync();
Message = $"Customer {Customer.Name} added";
return RedirectToPage("./Index");
}
}

The following markup in the Pages/Customers/Index.cshtml file displays the value of Message using TempData .

<h3>Msg: @Model.Message</h3>

The Pages/Customers/Index.cshtml.cs code-behind file applies the [TempData] attribute to the Message property.

[TempData]
public string Message { get; set; }

See TempData for more information.

Multiple handlers per page

The following page generates markup for two page handlers using the asp-page-handler Tag Helper:

@page
@model CreateFATHModel

<html>
<body>
<p>
Enter your name.
</p>
<div asp-validation-summary="All"></div>
<form method="POST">
<div>Name: <input asp-for="Customer.Name" /></div>
<input type="submit" asp-page-handler="JoinList" value="Join" />
<input type="submit" asp-page-handler="JoinListUC" value="JOIN UC" />
</form>
</body>
</html>
The form in the preceding example has two submit buttons, each using the FormActionTagHelper to submit to a
different URL. The asp-page-handler attribute is a companion to asp-page . asp-page-handler generates URLs that
submit to each of the handler methods defined by a page. asp-page is not specified because the sample is linking
to the current page.
The code-behind file:

using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using RazorPagesContacts.Data;

namespace RazorPagesContacts.Pages.Customers
{
public class CreateFATHModel : PageModel
{
private readonly AppDbContext _db;

public CreateFATHModel(AppDbContext db)

{
_db = db;
}

[BindProperty]
public Customer Customer { get; set; }

public async Task<IActionResult> OnPostJoinListAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_db.Customers.Add(Customer);
await _db.SaveChangesAsync();
return RedirectToPage("/Index");
}

public async Task<IActionResult> OnPostJoinListUCAsync()

{
if (!ModelState.IsValid)
{
return Page();
}
Customer.Name = Customer.Name?.ToUpper();
return await OnPostJoinListAsync();
}
}
}

The preceding code uses named handler methods. Named handler methods are created by taking the text in the
name after On<HTTP Verb> and before Async (if present). In the preceding example, the page methods are
OnPostJoinListAsync and OnPostJoinListUCAsync. With OnPost and Async removed, the handler names are
JoinList and JoinListUC .

<input type="submit" asp-page-handler="JoinList" value="Join" />

<input type="submit" asp-page-handler="JoinListUC" value="JOIN UC" />

Using the preceding code, the URL path that submits to OnPostJoinListAsync is
http://localhost:5000/Customers/CreateFATH?handler=JoinList . The URL path that submits to OnPostJoinListUCAsync
is http://localhost:5000/Customers/CreateFATH?handler=JoinListUC .
Customizing Routing
If you don't like the query string ?handler=JoinList in the URL, you can change the route to put the handler name
in the path portion of the URL. You can customize the route by adding a route template enclosed in double quotes
after the @page directive.

@page "{handler?}"
@model CreateRouteModel

<html>
<body>
<p>
Enter your name.
</p>
<div asp-validation-summary="All"></div>
<form method="POST">
<div>Name: <input asp-for="Customer.Name" /></div>
<input type="submit" asp-page-handler="JoinList" value="Join" />
<input type="submit" asp-page-handler="JoinListUC" value="JOIN UC" />
</form>
</body>
</html>

The preceding route puts the handler name in the URL path instead of the query string. The ? following handler
means the route parameter is optional.
You can use @page to add additional segments and parameters to a page's route. Whatever's there is appended to
the default route of the page. Using an absolute or virtual path to change the page's route (like
"~/Some/Other/Path" ) is not supported.

Configuration and settings

To configure advanced options, use the extension method AddRazorPagesOptions on the MVC builder:

public void ConfigureServices(IServiceCollection services)

{
services.AddMvc()
.AddRazorPagesOptions(options =>
{
options.RootDirectory = "/MyPages";
options.Conventions.AuthorizeFolder("/MyPages/Admin");
});
}

Currently you can use the RazorPagesOptions to set the root directory for pages, or add application model
conventions for pages. We hope to enable more extensibility this way in the future.
To precompile views, see Razor view compilation .
Download or view sample code.
See Getting started with Razor Pages in ASP.NET Core, which builds on this introduction.
 Create a web API with ASP.NET Core and Visual
Studio for Windows
9/19/2017 8 min to read Edit Online

By Rick Anderson and Mike Wasson

In this tutorial, youll build a web API for managing a list of "to-do" items. You wont build a UI.
There are 3 versions of this tutorial:
Windows: Web API with Visual Studio for Windows (This tutorial)
macOS: Web API with Visual Studio for Mac
macOS, Linux, Windows: Web API with Visual Studio Code

Overview
Here is the API that youll create:

API DESCRIPTION REQUEST BODY RESPONSE BODY

GET /api/todo Get all to-do items None Array of to-do items

GET /api/todo/{id} Get an item by ID None To-do item

POST /api/todo Add a new item To-do item To-do item

PUT /api/todo/{id} Update an existing item To-do item None

DELETE /api/todo/{id} Delete an item None None

The following diagram shows the basic design of the app.

The client is whatever consumes the web API (mobile app, browser, etc). We arent writing a client in this
tutorial. We'll use Postman or curl to test the app.
 A model is an object that represents the data in your application. In this case, the only model is a to-do item.
Models are represented as C# classes, also know as Plain Old C# Object (POCOs).
A controller is an object that handles HTTP requests and creates the HTTP response. This app will have a
single controller.
To keep the tutorial simple, the app doesnt use a persistent database. The sample app stores to-do items in
an in-memory database.

Prerequisites
Install the following:
.NET Core 2.0.0 SDK or later.
Visual Studio 2017 version 15.3 or later with the ASP.NET and web development workload.
See this PDF for the ASP.NET Core 1.1 version.

Create the project

From Visual Studio, select File menu, > New > Project.
Select the ASP.NET Core Web Application (.NET Core) project template. Name the project TodoApi and select
OK.

In the New ASP.NET Core Web Application - TodoApi dialog, select the Web API template. Select OK. Do not
select Enable Docker Support.
Launch the app
In Visual Studio, press CTRL+F5 to launch the app. Visual Studio launches a browser and navigates to
http://localhost:port/api/values , where port is a randomly-chosen port number. Chrome, Edge, and Firefox
display the following:

["value1","value2"]

Add a model class

A model is an object that represents the data in your application. In this case, the only model is a to-do item.
Add a folder named "Models". In Solution Explorer, right-click the project. Select Add > New Folder. Name the
folder Models.
Note: The model classes go anywhere in your project, but the Models folder is used by convention.
Add a TodoItem class. Right-click the Models folder and select Add > Class. Name the class TodoItem and select
Add.
Replace the generated code with the following:

namespace TodoApi.Models
{
public class TodoItem
{
public long Id { get; set; }
public string Name { get; set; }
public bool IsComplete { get; set; }
}
}

The database generates the Id when a TodoItem is created.

Create the database context
The database context is the main class that coordinates Entity Framework functionality for a given data model.
This class is created by deriving from the Microsoft.EntityFrameworkCore.DbContext class.
Add a TodoContext class. Right-click the Models folder and select Add > Class. Name the class TodoContext and
select Add.
Replace the generated code with the following:

using Microsoft.EntityFrameworkCore;

namespace TodoApi.Models
{
public class TodoContext : DbContext
{
public TodoContext(DbContextOptions<TodoContext> options)
: base(options)
{
}

public DbSet<TodoItem> TodoItems { get; set; }

}
}

Register the database context

In order to inject the database context into the controller, we need to register it with the dependency injection
container. Register the database context with the service container using the built-in support for dependency
injection. Replace the contents of the Startup.cs file with the following:

using Microsoft.AspNetCore.Builder;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using TodoApi.Models;

namespace TodoApi
{
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<TodoContext>(opt => opt.UseInMemoryDatabase("TodoList"));
services.AddMvc();
}

public void Configure(IApplicationBuilder app)

{
app.UseMvc();
}
}
}

The preceding code:

Removes the code we're not using.
Specifies an in-memory database is injected into the service container.
Add a controller
In Solution Explorer, right-click the Controllers folder. Select Add > New Item. In the Add New Item dialog,
select the Web API Controller Class template. Name the class TodoController .
Replace the generated code with the following:

using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using TodoApi.Models;
using System.Linq;

namespace TodoApi.Controllers
{
[Route("api/[controller]")]
public class TodoController : Controller
{
private readonly TodoContext _context;

public TodoController(TodoContext context)

{
_context = context;

if (_context.TodoItems.Count() == 0)
{
_context.TodoItems.Add(new TodoItem { Name = "Item1" });
_context.SaveChanges();
}
}
}
}

The preceding code:

Defines an empty controller class. In the next sections, we'll add methods to implement the API.
The constructor uses Dependency Injection to inject the database context ( TodoContext ) into the controller. The
database context is used in each of the CRUD methods in the controller.
The constructor adds an item to the in-memory database if one doesn't exist.

Getting to-do items

To get to-do items, add the following methods to the TodoController class.
 [HttpGet]
public IEnumerable<TodoItem> GetAll()
{
return _context.TodoItems.ToList();
}

[HttpGet("{id}", Name = "GetTodo")]

public IActionResult GetById(long id)
{
var item = _context.TodoItems.FirstOrDefault(t => t.Id == id);
if (item == null)
{
return NotFound();
}
return new ObjectResult(item);
}

These methods implement the two GET methods:

GET /api/todo
GET /api/todo/{id}

Here is an example HTTP response for the GetAll method:

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Server: Microsoft-IIS/10.0
Date: Thu, 18 Jun 2015 20:51:10 GMT
Content-Length: 82

[{"Key":"1", "Name":"Item1","IsComplete":false}]

Later in the tutorial I'll show how you can view the HTTP response using Postman or curl.
Routing and URL paths
The [HttpGet] attribute specifies an HTTP GET method. The URL path for each method is constructed as follows:
Take the template string in the controllers route attribute:

namespace TodoApi.Controllers
{
[Route("api/[controller]")]
public class TodoController : Controller
{
private readonly TodoContext _context;

Replace "[Controller]" with the name of the controller, which is the controller class name minus the "Controller"
suffix. For this sample, the controller class name is TodoController and the root name is "todo". ASP.NET Core
routing is not case sensitive.
If the [HttpGet] attribute has a route template (such as [HttpGet("/products")] , append that to the path. This
sample doesn't use a template. See Attribute routing with Http[Verb] attributes for more information.
In the GetById method:

[HttpGet("{id}", Name = "GetTodo")]

public IActionResult GetById(long id)

"{id}" is a placeholder variable for the ID of the todo item. When GetById is invoked, it assigns the value of "
{id}" in the URL to the method's id parameter.
Name = "GetTodo" creates a named route and allows you to link to this route in an HTTP Response. I'll explain it
with an example later. See Routing to Controller Actions for detailed information.
Return values
The GetAll method returns an IEnumerable . MVC automatically serializes the object to JSON and writes the
JSON into the body of the response message. The response code for this method is 200, assuming there are no
unhandled exceptions. (Unhandled exceptions are translated into 5xx errors.)
In contrast, the GetById method returns the more general IActionResult type, which represents a wide range of
return types. GetById has two different return types:
If no item matches the requested ID, the method returns a 404 error. This is done by returning NotFound .
Otherwise, the method returns 200 with a JSON response body. This is done by returning an ObjectResult

Launch the app

In Visual Studio, press CTRL+F5 to launch the app. Visual Studio launches a browser and navigates to
http://localhost:port/api/values , where port is a randomly chosen port number. If you're using Chrome, Edge or
Firefox, the data will be displayed. If you're using IE, IE will prompt to you open or save the values.json file.
Navigate to the Todo controller we just created http://localhost:port/api/todo .

Implement the other CRUD operations

We'll add Create , Update , and Delete methods to the controller. These are variations on a theme, so I'll just
show the code and highlight the main differences. Build the project after adding or changing code.
Create

[HttpPost]
public IActionResult Create([FromBody] TodoItem item)
{
if (item == null)
{
return BadRequest();
}

_context.TodoItems.Add(item);
_context.SaveChanges();

return CreatedAtRoute("GetTodo", new { id = item.Id }, item);

}

This is an HTTP POST method, indicated by the [HttpPost] attribute. The [FromBody] attribute tells MVC to get
the value of the to-do item from the body of the HTTP request.
The CreatedAtRoute method returns a 201 response, which is the standard response for an HTTP POST method
that creates a new resource on the server. CreatedAtRoute also adds a Location header to the response. The
Location header specifies the URI of the newly created to-do item. See 10.2.2 201 Created.
Use Postman to send a Create request
Set the HTTP method to POST
Select the Body radio button
Select the raw radio button
Set the type to JSON
In the key-value editor, enter a Todo item such as

{
"name":"walk dog",
"isComplete":true
}

Select Send
Select the Headers tab in the lower pane and copy the Location header:
You can use the Location header URI to access the resource you just created. Recall the GetById method created
the "GetTodo" named route:

[HttpGet("{id}", Name = "GetTodo")]

public IActionResult GetById(long id)

Update
 [HttpPut("{id}")]
public IActionResult Update(long id, [FromBody] TodoItem item)
{
if (item == null || item.Id != id)
{
return BadRequest();
}

var todo = _context.TodoItems.FirstOrDefault(t => t.Id == id);

if (todo == null)
{
return NotFound();
}

todo.IsComplete = item.IsComplete;
todo.Name = item.Name;

_context.TodoItems.Update(todo);
_context.SaveChanges();
return new NoContentResult();
}

Update is similar to Create , but uses HTTP PUT. The response is 204 (No Content). According to the HTTP spec, a
PUT request requires the client to send the entire updated entity, not just the deltas. To support partial updates,
use HTTP PATCH.

Delete
 [HttpDelete("{id}")]
public IActionResult Delete(long id)
{
var todo = _context.TodoItems.FirstOrDefault(t => t.Id == id);
if (todo == null)
{
return NotFound();
}

_context.TodoItems.Remove(todo);
_context.SaveChanges();
return new NoContentResult();
}

The response is 204 (No Content).

Next steps
ASP.NET Web API Help Pages using Swagger
Routing to Controller Actions
For information about deploying your API, see Publishing and Deployment.
View or download sample code. See how to download.
Postman
 ASP.NET Core tutorials
9/18/2017 1 min to read Edit Online

The following step-by-step guides for developing ASP.NET Core applications are available:

Building web applications

Razor Pages is the recommended approach to create a Web UI with ASP.NET Core 2.0.
Introduction to Razor Pages in ASP.NET Core
Create a Razor Pages web app with ASP.NET Core on Windows
Create a Razor Pages web app with ASP.NET Core on Mac
Create a Razor Pages web app with ASP.NET Core with VS Code
Create an ASP.NET Core MVC web app with Visual Studio on Windows
Create an ASP.NET Core MVC web app with Visual Studio on Mac
Create an ASP.NET Core MVC web app with Visual Studio Code on Mac or Linux
Getting started with ASP.NET Core and Entity Framework Core using Visual Studio
Building projects with Yeoman
Authoring Tag Helpers
Creating a simple view component
Developing ASP.NET Core applications using dotnet watch

Building web APIs

Create a Web API with ASP.NET Core and Visual Studio for Mac
Create a Web API with ASP.NET Core and Visual Studio for Windows
Create a Web API with ASP.NET Core and Visual Studio Code
ASP.NET Web API Help Pages using Swagger
Creating backend web services for native mobile applications

Working with data

Getting started with ASP.NET Core and Entity Framework Core using Visual Studio
ASP.NET Core with EF Core - new database
ASP.NET Core with EF Core - existing database

Authentication and authorization

Enabling authentication using Facebook, Google and other external providers
Account Confirmation and Password Recovery
Two-factor authentication with SMS

Client-side development
Using Gulp
Using Grunt
Manage client-side packages with Bower
 Building beautiful, responsive sites with Bootstrap

Testing
Unit Testing in .NET Core using dotnet test

Publishing and deployment

Deploy an ASP.NET Core web app to Azure using Visual Studio
Publishing to an Azure Web App with Continuous Deployment
Deploy an ASP.NET container to a remote Docker host
ASP.NET Core on Nano Server
ASP.NET Core and Azure Service Fabric

How to download a sample

1. Download the ASP.NET repository zip file.
2. Unzip the Docs-master.zip file.
3. Use the URL in the sample link to help you navigate to the sample directory.
 Create a Razor Pages web app with ASP.NET Core
9/26/2017 1 min to read Edit Online

This series explains the basics of building a Razor Pages web app with ASP.NET Core using Visual Studio. For the
Mac version, see this. For the Visual Studio Code version, see this.
1. Getting started with Razor Pages
2. Adding a model to a Razor Pages app
3. Scaffolded Razor Pages
4. Working with SQL Server LocalDB
5. Updating the pages
6. Adding search
7. Adding a new field
8. Adding validation
9. Uploading files
 Getting started with Razor Pages in ASP.NET Core
9/26/2017 2 min to read Edit Online

By Rick Anderson
This tutorial teaches the basics of building an ASP.NET Core Razor Pages web app. We recommend you complete
Introduction to Razor Pages before starting this tutorial. Razor Pages is the recommended way to build UI for web
applications in ASP.NET Core.

Prerequisites
Install the following:
.NET Core 2.0.0 SDK or later.
Visual Studio 2017 version 15.3 or later with the ASP.NET and web development workload.

Create a Razor web app

From the Visual Studio File menu, select New > Project.
Create a new ASP.NET Core Web Application. Name the project RazorPagesMovie. It's important to name the
project RazorPagesMovie so the namespaces will match when you copy/paste code.

Select ASP.NET Core 2.0 in the dropdown, and then select Web Application.
The Visual Studio template creates a starter project:

Press F5 to run the app in debug mode or Ctrl-F5 to run without attaching the debugger
 Visual Studio starts IIS Express and runs your app. The address bar shows localhost:port# and not something
like example.com . That's because localhost is the standard hostname for your local computer. Localhost only
serves web requests from the local computer. When Visual Studio creates a web project, a random port is used
for the web server. In the preceding image, the port number is 5000. When you run the app, you'll see a
different port number.
Launching the app with Ctrl+F5 (non-debug mode) allows you to make code changes, save the file, refresh the
browser, and see the code changes. Many developers prefer to use non-debug mode to quickly launch the app
and view changes.
The default template creates RazorPagesMovie, Home, About and Contact links and pages. Depending on the
size of your browser window, you might need to click the navigation icon to show the links.
Test the links. The RazorPagesMovie and Home links go to the Index page. The About and Contact links go to
the About and Contact pages, respectively.

Project files and folders

The following table lists the files and folders in the project. For this tutorial, the Startup.cs file is the most
important to understand. You don't need to review each link provided below. The links are provided as a reference
when you need more information on a file or folder in the project.

FILE OR FOLDER PURPOSE

wwwroot Contains static files. See Working with static files.

Pages Folder for Razor Pages.

appsettings.json Configuration

bower.json Client-side package management. See Bower.

Program.cs Hosts the ASP.NET Core app.

Startup.cs Configures services and the request pipeline. See Startup.

The Pages folder

The _Layout.cshtml file contains common HTML elements (scripts and stylesheets) and sets the layout for the
application. For example, when you click on RazorPagesMovie, Home, About or Contact, you see the same
elements. The common elements include the navigation menu on the top and the header on the bottom of the
window. See Layout for more information.
The _ViewStart.cshtml sets the Razor Pages Layout property to use the _Layout.cshtml file. See Layout for more
information.
The _ViewImports.cshtml file contains Razor directives that are imported into each Razor Page. See Importing
Shared Directives for more information.
The _ValidationScriptsPartial.cshtml file provides a reference to jQuery validation scripts. When we add Create
and Edit pages later in the tutorial, the _ValidationScriptsPartial.cshtml file will be used.
The About , Contact and Index pages are basic pages you can use to start an app. The Error page is used to
display error information.

N E X T: A D D IN G A
M ODEL
 Adding a model to a Razor Pages app
9/26/2017 3 min to read Edit Online

By Rick Anderson
In this section, you add classes for managing movies in a database. You use these classes with Entity Framework
Core (EF Core) to work with a database. EF Core is an object-relational mapping (ORM) framework that simplifies
the data access code that you have to write.
The model classes you create are known as POCO classes (from "plain-old CLR objects") because they don't have
any dependency on EF Core. They define the properties of the data that are stored in the database.
In this tutorial, you write the model classes first, and EF Core creates the database. An alternate approach not
covered here is to generate model classes from an existing database.
View or download sample.

Add a data model

In Solution Explorer, right-click the RazorPagesMovie project > Add > New Folder. Name the folder Models.
Right click the Models folder. Select Add > Class. Name the class Movie and add the following properties:
Add the following properties to the Movie class:

using System;

namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

The ID field is required by the database for the primary key.

Add a database context class
Add a DbContext derived class named MovieContext.cs to the Models folder.
 using Microsoft.EntityFrameworkCore;

namespace RazorPagesMovie.Models
{
public class MovieContext : DbContext
{
public MovieContext(DbContextOptions<MovieContext> options)
: base(options)
{
}

public DbSet<Movie> Movies { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder)

{
modelBuilder.Entity<Movie>().ToTable("Movie");
}
}
}

The preceding code creates a DbSet property for the entity set. In Entity Framework terminology, an entity set
typically corresponds to a database table, and an entity corresponds to a row in the table. The DbSet property
name is Movies . Since the database uses singular names, the sample overrides OnModelCreating to use the
singular form ( Movie ) for the table name.
Add a database connection string
Add a connection string to the appsettings.json file.

{
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Warning"
}
},
"ConnectionStrings": {
"MovieContext": "Server=(localdb)\\mssqllocaldb;Database=Movie-
1;Trusted_Connection=True;MultipleActiveResultSets=true"
}
}

Register the database context

Register the database context with the dependency injection container in the Startup.cs file.

public void ConfigureServices(IServiceCollection services)

{
// requires
// using RazorPagesMovie.Models;
// using Microsoft.EntityFrameworkCore;

services.AddDbContext<MovieContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("MovieContext")));
services.AddMvc();
}

Build the project to verify you don't have any errors.

Add scaffold tooling and perform initial migration

In this section, you use the Package Manager Console (PMC) to:
Add the Visual Studio web code generation package. This package is required to run the scaffolding engine.
Add an initial migration.
Update the database with the initial migration.
From the Tools menu, select NuGet Package Manager > Package Manager Console.

In the PMC, enter the following commands:

Install-Package Microsoft.VisualStudio.Web.CodeGeneration.Design -Version 2.0.0

Add-Migration Initial
Update-Database

The Install-Package command installs the tooling required to run the scaffolding engine.
The Add-Migration command generates code to create the initial database schema. The schema is based on the
model specified in the DbContext (In the Models/MovieContext.cs file). The Initial argument is used to name the
migrations. You can use any name, but by convention you choose a name that describes the migration. See
Introduction to migrations for more information.
The Update-Database command runs the Up method in the Migrations/<time-stamp>_InitialCreate.cs file, which
creates the database.
Scaffold the Movie model
Open a command window in the project directory (The directory that contains the Program.cs, Startup.cs, and
.csproj files).
Run the following command:

dotnet aspnet-codegenerator razorpage -m Movie -dc MovieContext -udl -outDir Pages\Movies --

referenceScriptLibraries

If you get the error:

 The process cannot access the file
'RazorPagesMovie/bin/Debug/netcoreapp2.0/RazorPagesMovie.dll'
because it is being used by another process.

Exit Visual Studio and run the command again.

The following table details the ASP.NET Core code generators` parameters:

PARAMETER DESCRIPTION

-m The name of the model.

-dc The data context.

-udl Use the default layout.

-outDir The relative output folder path to create the views.

--referenceScriptLibraries Adds _ValidationScriptsPartial to Edit and Create pages

Use the h switch to get help on the aspnet-codegenerator razorpage command:

dotnet aspnet-codegenerator razorpage -h

Test the app

Run the app and append /Movies to the URL in the browser ( http://localhost:port/movies ).
Test the Create link.
 Test the Edit, Details, and Delete links.
If you get the following error, verify you have run migrations and updated the database:

An unhandled exception occurred while processing the request.

SqliteException: SQLite Error 1: 'no such table: Movie'.
Microsoft.Data.Sqlite.SqliteException.ThrowExceptionForRC(int rc, sqlite3 db)

The next tutorial explains the files created by scaffolding.

P R E V IO U S : G E T T IN G N E X T: S C A F F O L D E D R A Z O R
STA RTE D PAGES
 Scaffolded Razor Pages in ASP.NET Core
9/26/2017 6 min to read Edit Online

By Rick Anderson
This tutorial examines the Razor Pages created by scaffolding in the previous tutorial.
View or download sample.

The Create, Delete, Details, and Edit pages.

Examine the Pages/Movies/Index.cshtml.cs code-behind file:

using Microsoft.AspNetCore.Mvc.RazorPages;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Threading.Tasks;
using RazorPagesMovie.Models;

namespace RazorPagesMovie.Pages.Movies
{
public class IndexModel : PageModel
{
private readonly RazorPagesMovie.Models.MovieContext _context;

public IndexModel(RazorPagesMovie.Models.MovieContext context)

{
_context = context;
}

public IList<Movie> Movies { get;set; }

public async Task OnGetAsync()

{
Movies = await _context.Movies.ToListAsync();
}
}
}

Razor Pages are derived from PageModel . By convention, the PageModel -derived class is called <PageName>Model .
The constructor uses dependency injection to add the MovieContext to the page. All the scaffolded pages follow
this pattern.
When a request is made for the page, the OnGetAsync method returns a list of movies to the Razor Page.
OnGetAsync or OnGet is called on a Razor Page to initialize the state for the page. In this case, OnGetAsync gets a
list of movies to display.
Examine the Pages/Movies/Index.cshtml Razor Page:
 @page
@model RazorPagesMovie.Pages.Movies.IndexModel

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-page="Create">Create New</a>
</p>
<table class="table">
<thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.Movies[0].Title)
</th>
<th>
@Html.DisplayNameFor(model => model.Movies[0].ReleaseDate)
</th>
<th>
@Html.DisplayNameFor(model => model.Movies[0].Genre)
</th>
<th>
@Html.DisplayNameFor(model => model.Movies[0].Price)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model.Movies) {
<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
<a asp-page="./Edit" asp-route-id="@item.ID">Edit</a> |
<a asp-page="./Details" asp-route-id="@item.ID">Details</a> |
<a asp-page="./Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>
}
</tbody>
</table>

Razor can transition from HTML into C# or into Razor-specific markup. When an @ symbol is followed by a Razor
reserved keyword, it transitions into Razor-specific markup, otherwise it transitions into C#.
The @page Razor directive makes the file into an MVC action which means that it can handle requests. @page
must be the first Razor directive on a page. @page is an example of transitioning into Razor-specific markup. See
Razor syntax for more information.
Examine the lambda expression used in the following HTML Helper:
 @Html.DisplayNameFor(model => model.Movies[0].Title))

The DisplayNameFor HTML Helper inspects the Title property referenced in the lambda expression to determine
the display name. The lambda expression is inspected rather than evaluated. That means there is no access
violation when model , model.Movies , or model.Movies[0] are null or empty. When the lambda expression is
evaluated (for example, with @Html.DisplayFor(modelItem => item.Title) ), the model's property values are
evaluated.
The @model directive

@page
@model RazorPagesMovie.Pages.Movies.IndexModel

The directive specifies the type of the model passed to the Razor Page. In the preceding example, the
@model
@model line makes the PageModel -derived class available to the Razor Page. The model is used in the
@Html.DisplayNameFor and @Html.DisplayName HTML Helpers on the page.

ViewData and layout

Consider the following code:

@page
@model RazorPagesMovie.Pages.Movies.IndexModel

@{
ViewData["Title"] = "Index";
}

The preceding highlighted code is an example of Razor transitioning into C#. The { and } characters enclose a
block of C# code.
The PageModel base class has a ViewData dictionary property that can be used to add data that you want to pass
to a View. You add objects into the ViewData dictionary using a key/value pattern. In the preceding sample, the
"Title" property is added to the ViewData dictionary. The "Title" property is used in the Pages/_Layout.cshtml file.
The following markup shows the first few lines of the Pages/_Layout.cshtml file.

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>@ViewData["Title"] - RazorPagesMovie</title>

@*Markup removed for brevity.*@

The line @*Markup removed for brevity.*@ is a Razor comment. Unlike HTML comments ( <!-- --> ), Razor
comments are not sent to the client.
Run the app and test the links in the project (Home, About, Contact, Create, Edit, and Delete). Each page sets
the title, which you can see in the browser tab. When you bookmark a page, the title is used for the bookmark.
Pages/Index.cshtml and Pages/Movies/Index.cshtml currently have the same title, but you can modify them to have
different values.
The Layout property is set in the Pages/_ViewStart.cshtml file:
 @{
Layout = "_Layout";
}

The preceding markup sets the layout file to Pages/_Layout.cshtml for all Razor files under the Pages folder. See
Layout for more information.
Update the layout
Change the <title> element in the Pages/_Layout.cshtml file to use a shorter string.

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>@ViewData["Title"] - Movie</title>

Find the following anchor element in the Pages/_Layout.cshtml file.

<a asp-page="/Index" class="navbar-brand">RazorPagesMovie</a>

Replace the preceding element with the following markup.

<a asp-page="/Movies/Index" class="navbar-brand">RpMovie</a>

The preceding anchor element is a Tag Helper. In this case, it's the Anchor Tag Helper. The
asp-page="/Movies/Index" Tag Helper attribute and value creates a link to the /Movies/Index Razor Page.

Save your changes, and test the app by clicking on the RpMovie link. See the _Layout.cshtml file in GitHub.
The Create code -behind page
Examine the Pages/Movies/Create.cshtml.cs code-behind file:
 // Unused usings removed.
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using RazorPagesMovie.Models;
using System.Threading.Tasks;

namespace RazorPagesMovie.Pages.Movies
{
public class CreateModel : PageModel
{
private readonly RazorPagesMovie.Models.MovieContext _context;

public CreateModel(RazorPagesMovie.Models.MovieContext context)

{
_context = context;
}

public IActionResult OnGet()

{
return Page();
}

[BindProperty]
public Movie Movie { get; set; }

public async Task<IActionResult> OnPostAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_context.Movies.Add(Movie);
await _context.SaveChangesAsync();

return RedirectToPage("./Index");
}
}
}

The OnGet method initializes any state needed for the page. The Create page doesn't have any state to initialize.
The Page method creates a PageResult object that renders the Create.cshtml page.
The Movie property uses the [BindProperty] attribute to opt-in to model binding. When the Create form posts
the form values, the ASP.NET Core runtime binds the posted values to the Movie model.
The OnPostAsync method is run when the page posts form data:

public async Task<IActionResult> OnPostAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_context.Movies.Add(Movie);
await _context.SaveChangesAsync();

return RedirectToPage("./Index");
}

If there are any model errors, the form is redisplayed, along with any form data posted. Most model errors can be
caught on the client-side before the form is posted. An example of a model error is posting a value for the date
field that cannot be converted to a date. We'll talk more about client-side validation and model validation later in
the tutorial.
If there are no model errors, the data is saved, and the browser is redirected to the Index page.
The Create Razor Page
Examine the Pages/Movies/Create.cshtml Razor Page file:

@page
@model RazorPagesMovie.Pages.Movies.CreateModel

@{
ViewData["Title"] = "Create";
}

<h2>Create</h2>

<h4>Movie</h4>
<hr />
<div class="row">
<div class="col-md-4">
<form method="post">
<div asp-validation-summary="ModelOnly" class="text-danger"></div>
<div class="form-group">
<label asp-for="Movie.Title" class="control-label"></label>
<input asp-for="Movie.Title" class="form-control" />
<span asp-validation-for="Movie.Title" class="text-danger"></span>
</div>
<div class="form-group">
<label asp-for="Movie.ReleaseDate" class="control-label"></label>
<input asp-for="Movie.ReleaseDate" class="form-control" />
<span asp-validation-for="Movie.ReleaseDate" class="text-danger"></span>
</div>
<div class="form-group">
<label asp-for="Movie.Genre" class="control-label"></label>
<input asp-for="Movie.Genre" class="form-control" />
<span asp-validation-for="Movie.Genre" class="text-danger"></span>
</div>
<div class="form-group">
<label asp-for="Movie.Price" class="control-label"></label>
<input asp-for="Movie.Price" class="form-control" />
<span asp-validation-for="Movie.Price" class="text-danger"></span>
</div>
<div class="form-group">
<input type="submit" value="Create" class="btn btn-default" />
</div>
</form>
</div>
</div>

<div>
<a asp-page="Index">Back to List</a>
</div>

@section Scripts {
@{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

Visual Studio displays the <form method="post"> tag in a distinctive font used for Tag Helpers. The
<form method="post"> element is a Form Tag Helper. The Form Tag Helper automatically includes an antiforgery
token.
The scaffolding engine creates Razor markup for each field in the model (except the ID) similar to the following:

<div asp-validation-summary="ModelOnly" class="text-danger"></div>

<div class="form-group">
<label asp-for="Movie.Title" class="control-label"></label>
<input asp-for="Movie.Title" class="form-control" />
<span asp-validation-for="Movie.Title" class="text-danger"></span>
</div>

The Validation Tag Helpers ( <div asp-validation-summary and <span asp-validation-for ) display validation errors.
Validation is covered in more detail later in this series.
The Label Tag Helper ( <label asp-for="Movie.Title" class="control-label"></label> ) generates the label caption
and for attribute for the Title property.
The Input Tag Helper ( <input asp-for="Movie.Title" class="form-control" /> ) uses the DataAnnotations attributes
and produces HTML attributes needed for jQuery Validation on the client-side.
The next tutorial explains SQL Server LocalDB and seeding the database.

P R E V IO U S : A D D IN G A N E X T: S Q L S E R V E R
M ODEL LOCA LDB
 Working with SQL Server LocalDB and ASP.NET Core
9/26/2017 3 min to read Edit Online

By Rick Anderson and Joe Audette

The MovieContext object handles the task of connecting to the database and mapping Movie objects to database
records. The database context is registered with the Dependency Injection container in the ConfigureServices
method in the Startup.cs file:

public void ConfigureServices(IServiceCollection services)

{
// requires
// using RazorPagesMovie.Models;
// using Microsoft.EntityFrameworkCore;

services.AddDbContext<MovieContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("MovieContext")));
services.AddMvc();
}

The ASP.NET Core Configuration system reads the ConnectionString . For local development, it gets the connection
string from the appsettings.json file:

"ConnectionStrings": {
"MovieContext": "Server=(localdb)\\mssqllocaldb;Database=Movie-
1;Trusted_Connection=True;MultipleActiveResultSets=true"
}

When you deploy the app to a test or production server, you can use an environment variable or another approach
to set the connection string to a real SQL Server. See Configuration for more information.

SQL Server Express LocalDB

LocalDB is a lightweight version of the SQL Server Express Database Engine that is targeted for program
development. LocalDB starts on demand and runs in user mode, so there is no complex configuration. By default,
LocalDB database creates "*.mdf" files in the C:/Users/<user> directory.
From the View menu, open SQL Server Object Explorer (SSOX).

Right click on the Movie table and select View Designer:

Note the key icon next to ID . By default, EF creates a property named ID for the primary key.
Right click on the Movie table and select View Data:
Seed the database
Create a new class named SeedData in the Models folder. Replace the generated code with the following:

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Linq;

namespace RazorPagesMovie.Models
{
public static class SeedData
{
public static void Initialize(IServiceProvider serviceProvider)
{
using (var context = new MovieContext(
serviceProvider.GetRequiredService<DbContextOptions<MovieContext>>()))
{
// Look for any movies.
if (context.Movies.Any())
{
return; // DB has been seeded
}

context.Movies.AddRange(
new Movie
{
Title = "When Harry Met Sally",
ReleaseDate = DateTime.Parse("1989-2-12"),
Genre = "Romantic Comedy",
Price = 7.99M
},

new Movie
{
Title = "Ghostbusters",
ReleaseDate = DateTime.Parse("1984-3-13"),
Genre = "Comedy",
Price = 8.99M
},

new Movie
{
Title = "Ghostbusters 2",
ReleaseDate = DateTime.Parse("1986-2-23"),
Genre = "Comedy",
Price = 9.99M
},

new Movie
{
Title = "Rio Bravo",
ReleaseDate = DateTime.Parse("1959-4-15"),
Genre = "Western",
Price = 3.99M
}
);
context.SaveChanges();
}
}
}
}

If there are any movies in the DB, the seed initializer returns and no movies are added.
 if (context.Movies.Any())
{
return; // DB has been seeded.
}

Add the seed initializer

Add the seed initializer to the end of the Main method in the Program.cs file:

// Unused usings removed.

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using RazorPagesMovie.Models;
using System;

namespace RazorPagesMovie
{
public class Program
{
public static void Main(string[] args)
{
var host = BuildWebHost(args);

using (var scope = host.Services.CreateScope())

{
var services = scope.ServiceProvider;

try
{
// Requires using RazorPagesMovie.Models;
SeedData.Initialize(services);
}
catch (Exception ex)
{
var logger = services.GetRequiredService<ILogger<Program>>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}

host.Run();
}

public static IWebHost BuildWebHost(string[] args) =>

WebHost.CreateDefaultBuilder(args)
.UseStartup<Startup>()
.Build();
}
}

Test the app

Delete all the records in the DB. You can do this with the delete links in the browser or from SSOX
Force the app to initialize (call the methods in the Startup class) so the seed method runs. To force
initialization, IIS Express must be stopped and restarted. You can do this with any of the following
approaches:
Right click the IIS Express system tray icon in the notification area and tap Exit or Stop Site:
 If you were running VS in non-debug mode, press F5 to run in debug mode.
If you were running VS in debug mode, stop the debugger and press F5.
The app shows the seeded data:

The next tutorial will clean up the presentation of the data.

P R E V IO U S : S C A F F O L D E D R A Z O R N E X T: U P D A T IN G T H E
PAGES PAGES
 Updating the generated pages
9/26/2017 4 min to read Edit Online

By Rick Anderson
We have a good start to the movie app, but the presentation is not ideal. We don't want to see the time (12:00:00
AM in the image below) and ReleaseDate should be Release Date (two words).

Update the generated code

Open the Models/Movie.cs file and add the highlighted lines shown in the following code:

using System;

namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

Right click on a red squiggly line > ** Quick Actions and Refactorings**.
Select using System.ComponentModel.DataAnnotations;

Visual studio adds using System.ComponentModel.DataAnnotations; .

We'll cover DataAnnotations in the next tutorial. The Display attribute specifies what to display for the name of a
field (in this case "Release Date" instead of "ReleaseDate"). The DataType attribute specifies the type of the data
(Date), so the time information stored in the field is not displayed.
Browse to Pages/Movies and hover over an Edit link to see the target URL.
The Edit, Details, and Delete links are generated by the Anchor Tag Helper in the Pages/Movies/Index.cshtml file.

@foreach (var item in Model.Movies) {

<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
<a asp-page="./Edit" asp-route-id="@item.ID">Edit</a> |
<a asp-page="./Details" asp-route-id="@item.ID">Details</a> |
<a asp-page="./Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>
}
</tbody>
</table>

Tag Helpers enable server-side code to participate in creating and rendering HTML elements in Razor files. In the
preceding code, the AnchorTagHelper dynamically generates the HTML href attribute value from the Razor Page
(the route is relative), the asp-page , and the route id ( asp-route-id ). See URL generation for Pages for more
information.
Use View Source from your favorite browser to examine the generated markup. A portion of the generated HTML
is shown below:
 <td>
<a href="/Movies/Edit?id=1">Edit</a> |
<a href="/Movies/Details?id=1">Details</a> |
<a href="/Movies/Delete?id=1">Delete</a>
</td>

The dynamically-generated links pass the movie ID with a query string (for example,
http://localhost:5000/Movies/Details?id=2 ).

Update the Edit, Details, and Delete Razor Pages to use the "{id:int}" route template. Change the page directive for
each of these pages to @page "{id:int}" . Run the app and then view source. The generated HTML adds the ID to
the path portion of the URL:

<td>
<a href="/Movies/Edit/1">Edit</a> |
<a href="/Movies/Details/1">Details</a> |
<a href="/Movies/Delete/1">Delete</a>
</td>

A request to the page with the "{id:int}" route template that does not include the integer will return an HTTP 404
(not found) error. For example, http://localhost:5000/Movies/Details will return a 404 error. To make the ID
optional, append ? to the route constraint:

@page "{id:int?}"

Update concurrency exception handling

Update the OnPostAsync method in the Pages/Movies/Edit.cshtml.cs file. The following highlighted code shows the
changes:

public async Task<IActionResult> OnPostAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_context.Attach(Movie).State = EntityState.Modified;

try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_context.Movies.Any(e => e.ID == Movie.ID))
{
return NotFound();
}
else
{
throw;
}
}

return RedirectToPage("./Index");
}

The previous code only detects concurrency exceptions when the first concurrent client deletes the movie, and the
second concurrent client posts changes to the movie.
To test the catch block:
Set a breakpoint on catch (DbUpdateConcurrencyException)
Edit a movie.
In another browser window, select the Delete link for the same movie, and then delete the movie.
In the previous browser window, post changes to the movie.
Production code would generally detect concurrency conflicts when two or more clients concurrently updated a
record. See Handling concurrency conflicts for more information.
Posting and binding review
Examine the Pages/Movies/Edit.cshtml.cs file:
 public class EditModel : PageModel
{
private readonly RazorPagesMovie.Models.MovieContext _context;

public EditModel(RazorPagesMovie.Models.MovieContext context)

{
_context = context;
}

[BindProperty]
public Movie Movie { get; set; }

public async Task<IActionResult> OnGetAsync(int? id)

{
if (id == null)
{
return NotFound();
}

Movie = await _context.Movies.SingleOrDefaultAsync(m => m.ID == id);

if (Movie == null)
{
return NotFound();
}
return Page();
}

public async Task<IActionResult> OnPostAsync()

{
if (!ModelState.IsValid)
{
return Page();
}

_context.Attach(Movie).State = EntityState.Modified;

try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_context.Movies.Any(e => e.ID == Movie.ID))
{
return NotFound();
}
else
{
throw;
}
}

return RedirectToPage("./Index");
}
}

When an HTTP GET request is made to the Movies/Edit page (for example, http://localhost:5000/Movies/Edit/2 ):
The OnGetAsync method fetches the movie from the database and returns the Page method.
The Page method renders the Pages/Movies/Edit.cshtml Razor Page. The Pages/Movies/Edit.cshtml file contains
the model directive ( @model RazorPagesMovie.Pages.Movies.EditModel ), which makes the the movie model
available on the page.
The Edit form is displayed with the values from the movie.
When the Movies/Edit page is posted:
The form values on the page are bound to the Movie property. The [BindProperty] attribute enables
Model binding.

[BindProperty]
public Movie Movie { get; set; }

If there are errors in the model state (for example, ReleaseDate cannot be converted to a date), the form is
posted again with the submitted values.
If there are no model errors, the movie is saved.
The HTTP GET methods in the Index, Create, and Delete Razor pages follow a similar pattern. The HTTP POST
OnPostAsync method in the Create Razor Page follows a similar pattern to the OnPostAsync method in the Edit
Razor Page.
Search is added in the next tutorial.

P R E V IO U S : W O R K IN G W IT H S Q L S E R V E R A D D IN G
LOCA LDB SE A RCH
 Adding search to an ASP.NET Core MVC app
9/26/2017 3 min to read Edit Online

By Rick Anderson
In this document, search capability is added to the Index page that enables searching movies by genre or name.
Update the Index page's OnGetAsync method with the following code:

public async Task OnGetAsync(string searchString)

{
var movies = from m in _context.Movies
select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

Movies = await movies.ToListAsync();

}

The first line of the OnGetAsync method creates a LINQ query to select the movies:

var movies = from m in _context.Movie

select m;

The query is only defined at this point, it has not been run against the database.
If the searchString parameter contains a string, the movies query is modified to filter on the search string:

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

The s => s.Title.Contains() code is a Lambda Expression. Lambdas are used in method-based LINQ queries as
arguments to standard query operator methods such as the Where method or Contains (used in the preceding
code). LINQ queries are not executed when they are defined or when they are modified by calling a method (such
as Where , Contains or OrderBy ). Rather, query execution is deferred. That means the evaluation of an expression
is delayed until its realized value is iterated over or the ToListAsync method is called. See Query Execution for
more information.
Note: The Contains method is run on the database, not in the C# code. The case sensitivity on the query depends
on the database and the collation. On SQL Server, Contains maps to SQL LIKE, which is case insensitive. In SQLite,
with the default collation, it's case sensitive.
Navigate to the Movies page and append a query string such as ?searchString=Ghost to the URL (for example,
http://localhost:5000/Movies?searchString=Ghost ). The filtered movies are displayed.
If the following route template is added to the Index page, the search string can be passed as a URL segment (for
example, http://localhost:5000/Movies/ghost ).

@page "{searchString?}"

The preceding route constraint allows searching the title as route data (a URL segment) instead of as a query string
value. The ? in "{searchString?}" means this is an optional route parameter.

However, you can't expect users to modify the URL to search for a movie. In this step, UI is added to filter movies. If
you added the route constraint "{searchString?}" , remove it.
Open the Pages/Movies/Index.cshtml file, and add the <form> markup highlighted in the following code:
 @page
@model RazorPagesMovie.Pages.Movies.IndexModel

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-page="Create">Create New</a>
</p>

<form>
<p>
Title: <input type="text" name="SearchString">
<input type="submit" value="Filter" />
</p>
</form>

<table class="table">
@*Markup removed for brevity.*@

The HTML <form> tag uses the Form Tag Helper. When the form is submitted, the filter string is sent to the
Pages/Movies/Index page. Save the changes and test the filter.

Search by genre
Add the the following highlighted properties to Pages/Movies/Index.cshtml.cs:
 public class IndexModel : PageModel
{
private readonly RazorPagesMovie.Models.MovieContext _context;

public IndexModel(RazorPagesMovie.Models.MovieContext context)

{
_context = context;
}

public List<Movie> Movies;

public SelectList Genres;
public string MovieGenre { get; set; }

The SelectList Genres contains the list of genres. This allows the user to select a genre from the list.
The MovieGenre property contains the specific genre the user selects (for example, "Western").
Update the OnGetAsync method with the following code:

// Requires using Microsoft.AspNetCore.Mvc.Rendering;

public async Task OnGetAsync(string movieGenre, string searchString)
{
// Use LINQ to get list of genres.
IQueryable<string> genreQuery = from m in _context.Movies
orderby m.Genre
select m.Genre;

var movies = from m in _context.Movies

select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

if (!String.IsNullOrEmpty(movieGenre))
{
movies = movies.Where(x => x.Genre == movieGenre);
}
Genres = new SelectList(await genreQuery.Distinct().ToListAsync());
Movies = await movies.ToListAsync();
}

The following code is a LINQ query that retrieves all the genres from the database.

// Use LINQ to get list of genres.

IQueryable<string> genreQuery = from m in _context.Movies
orderby m.Genre
select m.Genre;

The SelectList of genres is created by projecting the distinct genres.

Genres = new SelectList(await genreQuery.Distinct().ToListAsync());

Adding search by genre

Update Index.cshtml as follows:
 @page
@model RazorPagesMovie.Pages.Movies.IndexModel

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-page="Create">Create New</a>
</p>

<form>
<p>
<select asp-for="MovieGenre" asp-items="Model.Genres">
<option value="">All</option>
</select>

Title: <input type="text" name="SearchString">

<input type="submit" value="Filter" />
</p>
</form>

<table class="table">
<thead>

Test the app by searching by genre, by movie title, and by both.

P R E V IO U S : U P D A T IN G T H E N E X T: A D D IN G A N E W
PAGES F IE L D
 Adding a new field to a Razor Page
9/26/2017 4 min to read Edit Online

By Rick Anderson
In this section you'll use Entity Framework Code First Migrations to add a new field to the model and migrate that
change to the database.
When you use EF Code First to automatically create a database, Code First adds a table to the database to help
track whether the schema of the database is in sync with the model classes it was generated from. If they aren't in
sync, EF throws an exception. This makes it easier to find inconsistent database/code issues.

Adding a Rating Property to the Movie Model

Open the Models/Movie.cs file and add a Rating property:

public class Movie

{
public int ID { get; set; }
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
public string Rating { get; set; }
}

Build the app (Ctrl+Shift+B).

Edit Pages/Movies/Index.cshtml, and add a Rating field:

@page
@model RazorPagesMovie.Pages.Movies.IndexModel

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-page="Create">Create New</a>
</p>

<form>
<p>
<select asp-for="MovieGenre" asp-items="Model.Genres">
<option value="">All</option>
</select>

Title: <input type="text" name="SearchString">

<input type="submit" value="Filter" />
</p>
</form>

<table class="table">
<thead>
 <thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.Movies[0].Title)
</th>
<th>
@Html.DisplayNameFor(model => model.Movies[0].ReleaseDate)
</th>
<th>
@Html.DisplayNameFor(model => model.Movies[0].Genre)
</th>
<th>
@Html.DisplayNameFor(model => model.Movies[0].Price)
</th>
<th>
@Html.DisplayNameFor(model => model.Movies[0].Rating)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model.Movies) {
<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
@Html.DisplayFor(modelItem => item.Rating)
</td>
<td>
<a asp-page="./Edit" asp-route-id="@item.ID">Edit</a> |
<a asp-page="./Details" asp-route-id="@item.ID">Details</a> |
<a asp-page="./Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>
}
</tbody>
</table>

Add the Rating field to the Delete and Details pages.

Update Create.cshtml with a Rating field. You can copy/paste the previous <div> element and let intelliSense
help you update the fields. IntelliSense works with Tag Helpers.
The following code shows Create.cshtml with a Rating field:
 @page
@model RazorPagesMovie.Pages.Movies.CreateModel

@{
ViewData["Title"] = "Create";
}

<h2>Create</h2>

<h4>Movie</h4>
<hr />
<div class="row">
<div class="col-md-4">
<form method="post">
<div asp-validation-summary="ModelOnly" class="text-danger"></div>
<div class="form-group">
<label asp-for="Movie.Title" class="control-label"></label>
<input asp-for="Movie.Title" class="form-control" />
<span asp-validation-for="Movie.Title" class="text-danger"></span>
</div>
<div class="form-group">
<label asp-for="Movie.ReleaseDate" class="control-label"></label>
<input asp-for="Movie.ReleaseDate" class="form-control" />
<span asp-validation-for="Movie.ReleaseDate" class="text-danger"></span>
</div>
<div class="form-group">
<label asp-for="Movie.Genre" class="control-label"></label>
<input asp-for="Movie.Genre" class="form-control" />
<span asp-validation-for="Movie.Genre" class="text-danger"></span>
</div>
<div class="form-group">
<label asp-for="Movie.Price" class="control-label"></label>
<input asp-for="Movie.Price" class="form-control" />
<span asp-validation-for="Movie.Price" class="text-danger"></span>
</div>
<div class="form-group">
<label asp-for="Movie.Rating" class="control-label"></label>
<input asp-for="Movie.Rating" class="form-control" />
<span asp-validation-for="Movie.Rating" class="text-danger"></span>
</div>
<div class="form-group">
<input type="submit" value="Create" class="btn btn-default" />
</div>
</form>
</div>
</div>

<div>
<a asp-page="Index">Back to List</a>
</div>

@section Scripts {
@{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

Add the Rating field to the Edit Page.

The app won't work until the DB is updated to include the new field. If run now, the app throws a SqlException :

SqlException: Invalid column name 'Rating'.

This error is caused by the updated Movie model class being different than the schema of the Movie table of the
database. (There's no Rating column in the database table.)
There are a few approaches to resolving the error:
1. Have the Entity Framework automatically drop and re-create the database using the new model class
schema. This approach is convenient early in the development cycle; it allows you to quickly evolve the
model and database schema together. The downside is that you lose existing data in the database. You
don't want to use this approach on a production database! Dropping the DB on schema changes and using
an initializer to automatically seed the database with test data is often a productive way to develop an app.
2. Explicitly modify the schema of the existing database so that it matches the model classes. The advantage of
this approach is that you keep your data. You can make this change either manually or by creating a
database change script.
3. Use Code First Migrations to update the database schema.
For this tutorial, use Code First Migrations.
Update the SeedData class so that it provides a value for the new column. A sample change is shown below, but
you'll want to make this change for each new Movie block.

context.Movies.AddRange(
new Movie
{
Title = "When Harry Met Sally",
ReleaseDate = DateTime.Parse("1989-2-12"),
Genre = "Romantic Comedy",
Price = 7.99M,
Rating = "R"
},

See the completed SeedData.cs file.

Build the solution.
From the Tools menu, select NuGet Package Manager > Package Manager Console. In the PMC, enter the
following commands:

Add-Migration Rating
Update-Database

The Add-Migration command tells the framework to:

Compare the Movie model with the Movie DB schema.
Create code to migrate the DB schema to the new model.
The name "Rating" is arbitrary and is used to name the migration file. It's helpful to use a meaningful name for the
migration file.
If you delete all the records in the DB, the initializer will seed the DB and include the Rating field. You can do this
with the delete links in the browser or from Sql Server Object Explorer (SSOX). To delete the database from SSOX:
Select the database in SSOX.
Right click on the database, and select Delete.
Check Close existing connections.
Select OK.
In the PMC, update the database:
 Update-Database

Run the app and verify you can create/edit/display movies with a Rating field. If the database is not seeded, stop
IIS Express, and then run the app.

P R E V IO U S : A D D IN G N E X T: A D D IN G
SE A RCH V A L ID A T IO N
 Adding validation to a Razor Page
9/26/2017 7 min to read Edit Online

By Rick Anderson
In this section validation logic is added to the Movie model. The validation rules are enforced any time a user
creates or edits a movie.

Validation
A key tenet of software development is called DRY ("Don't Repeat Yourself"). Razor Pages encourages
development where functionality is specified once, and it's reflected throughout the app. DRY can help reduce the
amount of code in an app. DRY makes the code less error prone, and easier to test and maintain.
The validation support provided by Razor Pages and Entity Framework is a good example of the DRY principle.
Validation rules are declaratively specified in one place (in the model class), and the rules are enforced everywhere
in the app.
Adding validation rules to the movie model
Open the Movie.cs file. DataAnnotations provides a built-in set of validation attributes that are applied declaratively
to a class or property. DataAnnotations also contains formatting attributes like DataType that help with formatting
and don't provide validation.
Update the Movie class to take advantage of the Required , StringLength , RegularExpression , and Range
validation attributes.

public class Movie

{
public int ID { get; set; }

[StringLength(60, MinimumLength = 3)]

[Required]
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }

[Range(1, 100)]
[DataType(DataType.Currency)]
public decimal Price { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$")]
[Required]
[StringLength(30)]
public string Genre { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$")]
[StringLength(5)]
[Required]
public string Rating { get; set; }
}

Validation attributes specify behavior that is enforced on model properties. The Required and MinimumLength
attributes indicates that a property must have a value; but nothing prevents a user from entering white space to
satisfy the validation constraint. The RegularExpression attribute is used to limit what characters can be input. In
the preceding code, Genre and Rating must use only letters (white space, numbers and special characters are not
allowed). The Range attribute constrains a value to within a specified range. The StringLength attribute sets the
maximum length of a string, and optionally the minimum length. Value types (such as decimal , int , float ,
DateTime ) are inherently required and don't need the [Required] attribute.

Having validation rules automatically enforced by ASP.NET Core helps make an app more robust. Automatic
validation on models helps protect the app because you don't have to remember to apply them when new code is
added.
Validation Error UI in Razor Pages
Run the app and navigate to Pages/Movies.
Select the Create New link. Complete the form with some invalid values. When jQuery client-side validation
detects the error, it displays an error message.
 NOTE
You may not be able to enter decimal points or commas in the Price field. To support jQuery validation in non-English
locales that use a comma (",") for a decimal point, and non US-English date formats, you must take steps to globalize your
app. See Additional resources for more information. For now, just enter whole numbers like 10.

Notice how the form has automatically rendered a validation error message in each field containing an invalid
value. The errors are enforced both client-side (using JavaScript and jQuery) and server-side (when a user has
JavaScript disabled).
A significant benefit is that no code changes were necessary in the Create or Edit pages. Once DataAnnotations
were applied to the model, the validation UI was enabled. The Razor Pages created in this tutorial automatically
picked up the validation rules (using validation attributes on the properties of the Movie model class). Test
validation using the Edit page, the same validation is applied.
The form data is not posted to the server until there are no client-side validation errors. Verify form data is not
posted by one or more of the following approaches:
Put a break point in the OnPostAsync method. Submit the form (select Create or Save). The break point is
never hit.
Use the Fiddler tool.
Use the browser developer tools to monitor network traffic.
Server-side validation
When JavaScript is disabled in the browser, submitting the form with errors will post to the server.
Optional, test server-side validation:
Disable JavaScript in the browser. If you can't disable JavaScript in the browser, try another browser.
Set a break point in the OnPostAsync method of the Create or Edit page.
Submit a form with validation errors.
Verify the model state is invalid:

if (!ModelState.IsValid)
{
return Page();
}

The following code shows a portion of the Create.cshtml page that you scaffolded earlier in the tutorial. It's used
by the Create and Edit pages to display the initial form and to redisplay the form in the event of an error.

<form method="post">
<div asp-validation-summary="ModelOnly" class="text-danger"></div>
<div class="form-group">
<label asp-for="Movie.Title" class="control-label"></label>
<input asp-for="Movie.Title" class="form-control" />
<span asp-validation-for="Movie.Title" class="text-danger"></span>
</div>

The Input Tag Helper uses the DataAnnotations attributes and produces HTML attributes needed for jQuery
Validation on the client-side. The Validation Tag Helper displays validation errors. See Validation for more
information.
The Create and Edit pages have no validation rules in them. The validation rules and the error strings are specified
only in the Movie class. These validation rules are automatically applied to Razor Pages that edit the Movie
model.
When validation logic needs to change, it's done only in the model. Validation is applied consistently throughout
the application (validation logic is defined in one place). Validation in one place helps keep the code clean, and
makes it easier to maintain and update.

Using DataType Attributes

Examine the Movie class. The System.ComponentModel.DataAnnotations namespace provides formatting attributes in
addition to the built-in set of validation attributes. The DataType attribute is applied to the ReleaseDate and
Price properties.

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }

[Range(1, 100)]
[DataType(DataType.Currency)]
public decimal Price { get; set; }

The DataType attributes only provide hints for the view engine to format the data (and supplies attributes such as
<a> for URL's and <a href="mailto:EmailAddress.com"> for email). Use the RegularExpression attribute to validate
the format of the data. The DataType attribute is used to specify a data type that is more specific than the database
intrinsic type. DataType attributes are not validation attributes. In the sample application, only the date is
displayed, without time.
The DataType Enumeration provides for many data types, such as Date, Time, PhoneNumber, Currency,
EmailAddress, and more. The DataType attribute can also enable the application to automatically provide type-
specific features. For example, a mailto: link can be created for DataType.EmailAddress . A date selector can be
provided for DataType.Date in browsers that support HTML5. The DataType attributes emits HTML 5 data-
(pronounced data dash) attributes that HTML 5 browsers consume. The DataType attributes do not provide any
validation.
DataType.Date does not specify the format of the date that is displayed. By default, the data field is displayed
according to the default formats based on the server's CultureInfo .
The DisplayFormat attribute is used to explicitly specify the date format:

[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

public DateTime ReleaseDate { get; set; }

The ApplyFormatInEditMode setting specifies that the formatting should be applied when the value is displayed for
editing. You might not want that behavior for some fields. For example, in currency values, you probably do not
want the currency symbol in the edit UI.
The DisplayFormat attribute can be used by itself, but it's generally a good idea to use the DataType attribute. The
DataType attribute conveys the semantics of the data as opposed to how to render it on a screen, and provides the
following benefits that you don't get with DisplayFormat:
The browser can enable HTML5 features (for example to show a calendar control, the locale-appropriate
currency symbol, email links, etc.)
By default, the browser will render data using the correct format based on your locale.
The DataType attribute can enable the ASP.NET Core framework to choose the right field template to render
the data. The DisplayFormat if used by itself uses the string template.
Note: jQuery validation does not work with the Range attribute and DateTime . For example, the following code
will always display a client-side validation error, even when the date is in the specified range:

[Range(typeof(DateTime), "1/1/1966", "1/1/2020")]

It's generally not a good practice to compile hard dates in your models, so using the Range attribute and
DateTime is discouraged.

The following code shows combining attributes on one line:

public class Movie

{
public int ID { get; set; }

[StringLength(60, MinimumLength = 3)]

public string Title { get; set; }

[Display(Name = "Release Date"), DataType(DataType.Date)]

public DateTime ReleaseDate { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$"), Required, StringLength(30)]

public string Genre { get; set; }

[Range(1, 100), DataType(DataType.Currency)]

public decimal Price { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$"), StringLength(5)]
public string Rating { get; set; }
}

Additional resources
Working with Forms
Globalization and localization
Introduction to Tag Helpers
Authoring Tag Helpers

P R E V IO U S : A D D IN G A N E W N E X T: U P L O A D IN G
F IE L D F IL E S
 Create a Razor Pages web app with ASP.NET Core
and Visual Studio for Mac
9/20/2017 1 min to read Edit Online

This is a work in progress. We hope to have the series complete within two weeks.
This series explains the basics of building a Razor Pages web app with ASP.NET Core on Mac.
1. Getting started with Razor Pages on Mac
2. Adding a model to a Razor Pages app
Until the next section is complete, follow the Visual Studio for Windows version.
1. Scaffolded Razor Pages
2. Working with SQL Server LocalDB
3. Updating the pages
4. Adding search
5. Adding a new field
6. Adding validation
 Getting started with Razor Pages in ASP.NET Core
with Visual Studio for Mac
9/19/2017 2 min to read Edit Online

By Rick Anderson
This tutorial teaches the basics of building an ASP.NET Core Razor Pages web app. We recommend you complete
Introduction to Razor Pages before starting this tutorial. Razor Pages is the recommended way to build UI for web
applications in ASP.NET Core.

Prerequisites
Install the following:
.NET Core 2.0.0 SDK or later
Visual Studio for Mac

Create a Razor web app

From a terminal, run the following commands:

dotnet new razor -o RazorPagesMovie

cd RazorPagesMovie
dotnet run

The preceding commands use the .NET Core CLI to create and run a Razor Pages project. Open a browser to
http://localhost:5000 to view the application.
The default template creates RazorPagesMovie, Home, About and Contact links and pages. Depending on the
size of your browser window, you might need to click the navigation icon to show the links.

Test the links. The RazorPagesMovie and Home links go to the Index page. The About and Contact links go to
the About and Contact pages, respectively.

Project files and folders

The following table lists the files and folders in the project. For this tutorial, the Startup.cs file is the most important
to understand. You don't need to review each link provided below. The links are provided as a reference when you
need more information on a file or folder in the project.

FILE OR FOLDER PURPOSE

wwwroot Contains static files. See Working with static files.

Pages Folder for Razor Pages.

appsettings.json Configuration

bower.json Client-side package management. See Bower.

Program.cs Hosts the ASP.NET Core app.

Startup.cs Configures services and the request pipeline. See Startup.

The Pages folder

The _Layout.cshtml file contains common HTML elements (scripts and stylesheets) and sets the layout for the
application. For example, when you click on RazorPagesMovie, Home, About or Contact, you see the same
elements. The common elements include the navigation menu on the top and the header on the bottom of the
window. See Layout for more information.
The _ViewStart.cshtml sets the Razor Pages Layout property to use the _Layout.cshtml file. See Layout for more
information.
The _ViewImports.cshtml file contains Razor directives that are imported into each Razor Page. See Importing
Shared Directives for more information.
The _ValidationScriptsPartial.cshtml file provides a reference to jQuery validation scripts. When we add Create
and Edit pages later in the tutorial, the _ValidationScriptsPartial.cshtml file will be used.
The About , Contact and Index pages are basic pages you can use to start an app. The Error page is used to
display error information.

Open the project

Press Ctrl+C to shut down the application.
From Visual Studio, select File > Open, and then select the RazorPagesMovie.csproj file.
Launch the app
In Visual Studio, select Run > Start Without Debugging to launch the app. Visual Studio starts IIS Express,
launches a browser, and navigates to http://localhost:5000 .
In the next tutorial, we add a model to the project.

N E X T: A D D IN G A
M ODEL
 Adding a model to a Razor Pages app in ASP.NET
Core with Visual Studio for Mac
9/26/2017 4 min to read Edit Online

By Rick Anderson
In this section, you add classes for managing movies in a database. You use these classes with Entity Framework
Core (EF Core) to work with a database. EF Core is an object-relational mapping (ORM) framework that simplifies
the data access code that you have to write.
The model classes you create are known as POCO classes (from "plain-old CLR objects") because they don't have
any dependency on EF Core. They define the properties of the data that are stored in the database.
In this tutorial, you write the model classes first, and EF Core creates the database. An alternate approach not
covered here is to generate model classes from an existing database.
View or download sample.

Add a data model

In Solution Explorer, right-click the RazorPagesMovie project, and then select Add > New Folder. Name the
folder Models.
Right-click the Models folder, and then select Add > New File.
In the New File dialog:
Select General in the left pane.
Select Empty Class in the center pain.
Name the class Movie and select New.
Add the following properties to the Movie class:

using System;

namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

The ID field is required by the database for the primary key.

Add a database context class
Add a DbContext derived class named MovieContext.cs to the Models folder.
 using Microsoft.EntityFrameworkCore;

namespace RazorPagesMovie.Models
{
public class MovieContext : DbContext
{
public MovieContext(DbContextOptions<MovieContext> options)
: base(options)
{
}

public DbSet<Movie> Movies { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder)

{
modelBuilder.Entity<Movie>().ToTable("Movie");
}
}
}

The preceding code creates a DbSet property for the entity set. In Entity Framework terminology, an entity set
typically corresponds to a database table, and an entity corresponds to a row in the table. The DbSet property
name is Movies . Since the database uses singular names, the sample overrides OnModelCreating to use the
singular form ( Movie ) for the table name.
Add a database connection string
Add a connection string to the appsettings.json file.

{
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Warning"
}
},
"ConnectionStrings": {
"MovieContext": "Data Source=MvcMovie.db"
}
}

Register the database context

Register the database context with the dependency injection container in the Startup.cs file.

public void ConfigureServices(IServiceCollection services)

{
// requires
// using RazorPagesMovie.Models;
// using Microsoft.EntityFrameworkCore;

services.AddDbContext<MovieContext>(options =>
options.UseSqlite(Configuration.GetConnectionString("MovieContext")));
services.AddMvc();
}

Right click on a red squiggly line, for example MovieContext in the line
services.AddDbContext<MovieContext>(options => . Select Quick Fix > using RazorPagesMovie.Models;. Visual
studio adds the using statement.
Build the project to verify you don't have any errors.
Entity Framework Core NuGet packages for migrations
The EF tools for the command-line interface (CLI) are provided in Microsoft.EntityFrameworkCore.Tools.DotNet. To
install this package, add it to the DotNetCliToolReference collection in the .csproj file. Note: You have to install this
package by editing the .csproj file; you can't use the install-package command or the package manager GUI.
To edit a .csproj file:
Select File > Open, and then select the .csproj file.
Select Options.
Change Open with to Source Code Editor.

Add the Microsoft.EntityFrameworkCore.Tools.DotNet tool reference to the second <ItemGroup>:

<ItemGroup>
<DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.0" />
<DotNetCliToolReference Include="BundlerMinifier.Core" Version="2.5.357" />
<DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
</ItemGroup>
Add scaffold tooling and perform initial migration
From the command line, run the following .NET Core CLI commands:

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design

dotnet restore
dotnet ef migrations add InitialCreate
dotnet ef database update

The add package command installs the tooling required to run the scaffolding engine.
The ef migrations add InitialCreate command generates code to create the initial database schema. The schema
is based on the model specified in the DbContext (In the Models/MovieContext.cs file). The Initial argument is
used to name the migrations. You can use any name, but by convention you choose a name that describes the
migration. See Introduction to migrations for more information.
The ef database update command runs the Up method in the Migrations/<time-stamp>_InitialCreate.cs file,
which creates the database.
Scaffold the Movie model
Open a command window in the project directory (The directory that contains the Program.cs, Startup.cs, and
.csproj files).
Run the following command:

dotnet aspnet-codegenerator razorpage -m Movie -dc MovieContext -udl -outDir Pages/Movies --

referenceScriptLibraries

If you get the error:

The process cannot access the file

'RazorPagesMovie/bin/Debug/netcoreapp2.0/RazorPagesMovie.dll'
because it is being used by another process.

Exit Visual Studio and run the command again.

The following table details the ASP.NET Core code generators` parameters:

PARAMETER DESCRIPTION

-m The name of the model.

-dc The data context.

-udl Use the default layout.

-outDir The relative output folder path to create the views.

--referenceScriptLibraries Adds _ValidationScriptsPartial to Edit and Create pages

Use the h switch to get help on the aspnet-codegenerator razorpage command:

dotnet aspnet-codegenerator razorpage -h

Test the app
Run the app and append /Movies to the URL in the browser ( http://localhost:port/movies ).
Test the Create link.

Test the Edit, Details, and Delete links.

If you get the following error, verify you have run migrations and updated the database:

An unhandled exception occurred while processing the request.

SqliteException: SQLite Error 1: 'no such table: Movie'.
Microsoft.Data.Sqlite.SqliteException.ThrowExceptionForRC(int rc, sqlite3 db)

Add the Pages/Movies files to the project

In Visual Studio, Right-click the Pages folder and select Add > Add existing Folder.
Select the Movies folder.
In the Chosse files to include in the project dialog, select Include All.
The next tutorial explains the files created by scaffolding.

P R E V IO U S : G E T T IN G N E X T: S C A F F O L D E D R A Z O R
STA RTE D PAGES
 Create a Razor Pages web app with ASP.NET Core
and Visual Studio Code
9/20/2017 1 min to read Edit Online

This is a work in progress. We hope to have the series complete within two weeks.
This series explains the basics of building a Razor Pages web app with ASP.NET Core using Visual Studio Code.
1. Getting started with Razor Pages with VS Code
2. Adding a model to a Razor Pages app
Until the next section is complete, follow the Visual Studio for Windows version.
1. Scaffolded Razor Pages
2. Working with SQL Server LocalDB
3. Updating the pages
4. Adding search
5. Adding a new field
6. Adding validation
 Getting started with Razor Pages in ASP.NET Core
with Visual Studio Code
9/19/2017 2 min to read Edit Online

By Rick Anderson
This tutorial teaches the basics of building an ASP.NET Core Razor Pages web app. We recommend you complete
Introduction to Razor Pages before starting this tutorial. Razor Pages is the recommended way to build UI for web
applications in ASP.NET Core.

Prerequisites
Install the following:
.NET Core 2.0.0 SDK or later
Visual Studio Code
VS Code C# extension

Create a Razor web app

From a terminal, run the following commands:

dotnet new razor -o RazorPagesMovie

cd RazorPagesMovie
dotnet run

The preceding commands use the .NET Core CLI to create and run a Razor Pages project. Open a browser to
http://localhost:5000 to view the application.
The default template creates RazorPagesMovie, Home, About and Contact links and pages. Depending on the
size of your browser window, you might need to click the navigation icon to show the links.

Test the links. The RazorPagesMovie and Home links go to the Index page. The About and Contact links go to
the About and Contact pages, respectively.

Project files and folders

The following table lists the files and folders in the project. For this tutorial, the Startup.cs file is the most important
to understand. You don't need to review each link provided below. The links are provided as a reference when you
need more information on a file or folder in the project.

FILE OR FOLDER PURPOSE

wwwroot Contains static files. See Working with static files.

Pages Folder for Razor Pages.

appsettings.json Configuration

bower.json Client-side package management. See Bower.

Program.cs Hosts the ASP.NET Core app.

Startup.cs Configures services and the request pipeline. See Startup.

The Pages folder

The _Layout.cshtml file contains common HTML elements (scripts and stylesheets) and sets the layout for the
application. For example, when you click on RazorPagesMovie, Home, About or Contact, you see the same
elements. The common elements include the navigation menu on the top and the header on the bottom of the
window. See Layout for more information.
The _ViewStart.cshtml sets the Razor Pages Layout property to use the _Layout.cshtml file. See Layout for more
information.
The _ViewImports.cshtml file contains Razor directives that are imported into each Razor Page. See Importing
Shared Directives for more information.
The _ValidationScriptsPartial.cshtml file provides a reference to jQuery validation scripts. When we add Create
and Edit pages later in the tutorial, the _ValidationScriptsPartial.cshtml file will be used.
The About , Contact and Index pages are basic pages you can use to start an app. The Error page is used to
display error information.

Open the project

Press Ctrl+C to shut down the application.
From Visual Studio Code (VS Code), select File > Open Folder, and then select the RazorPagesMovie folder.
Select Yes to the Warn message "Required assets to build and debug are missing from 'RazorPagesMovie'. Add
them?"
Select Restore to the Info message "There are unresolved dependencies".
Launch the app
Press Ctrl+F5 to start the app without debugging. Alternatively, from the Debug menu, select Start Without
Debugging.
In the next tutorial, we add a model to the project.
N E X T: A D D IN G A
M ODEL
 Adding a model to a Razor Pages app in ASP.NET
Core with Visual Studio for Mac
9/26/2017 4 min to read Edit Online

By Rick Anderson
In this section, you add classes for managing movies in a database. You use these classes with Entity Framework
Core (EF Core) to work with a database. EF Core is an object-relational mapping (ORM) framework that simplifies
the data access code that you have to write.
The model classes you create are known as POCO classes (from "plain-old CLR objects") because they don't have
any dependency on EF Core. They define the properties of the data that are stored in the database.
In this tutorial, you write the model classes first, and EF Core creates the database. An alternate approach not
covered here is to generate model classes from an existing database.
View or download sample.

Add a data model

Add a folder named Models.
Add a class to the Models folder named Movie.cs.
Add the following code to the Models/Movie.cs file:
Add the following properties to the Movie class:

using System;

namespace RazorPagesMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

The ID field is required by the database for the primary key.

Add a database context class
Add a DbContext derived class named MovieContext.cs to the Models folder.
 using Microsoft.EntityFrameworkCore;

namespace RazorPagesMovie.Models
{
public class MovieContext : DbContext
{
public MovieContext(DbContextOptions<MovieContext> options)
: base(options)
{
}

public DbSet<Movie> Movies { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder)

{
modelBuilder.Entity<Movie>().ToTable("Movie");
}
}
}

The preceding code creates a DbSet property for the entity set. In Entity Framework terminology, an entity set
typically corresponds to a database table, and an entity corresponds to a row in the table. The DbSet property
name is Movies . Since the database uses singular names, the sample overrides OnModelCreating to use the
singular form ( Movie ) for the table name.
Add a database connection string
Add a connection string to the appsettings.json file.

{
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Warning"
}
},
"ConnectionStrings": {
"MovieContext": "Data Source=MvcMovie.db"
}
}

Register the database context

Register the database context with the dependency injection container in the Startup.cs file.

public void ConfigureServices(IServiceCollection services)

{
// requires
// using RazorPagesMovie.Models;
// using Microsoft.EntityFrameworkCore;

services.AddDbContext<MovieContext>(options =>
options.UseSqlite(Configuration.GetConnectionString("MovieContext")));
services.AddMvc();
}

Build the project to verify you don't have any errors.

Entity Framework Core NuGet packages for migrations
The EF tools for the command-line interface (CLI) are provided in Microsoft.EntityFrameworkCore.Tools.DotNet. To
install this package, add it to the DotNetCliToolReference collection in the .csproj file. Note: You have to install this
package by editing the .csproj file; you can't use the install-package command or the package manager GUI.
Edit the RazorPagesMovie.csproj file:
Select File > Open File, and then select the RazorPagesMovie.csproj file.
Add tool reference for Microsoft.EntityFrameworkCore.Tools.DotNet to the second <ItemGroup>:

<ItemGroup>
<DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.0" />
<DotNetCliToolReference Include="BundlerMinifier.Core" Version="2.5.357" />
<DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
</ItemGroup>

Add scaffold tooling and perform initial migration

From the command line, run the following .NET Core CLI commands:

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design

dotnet restore
dotnet ef migrations add InitialCreate
dotnet ef database update

The add package command installs the tooling required to run the scaffolding engine.
The ef migrations add InitialCreate command generates code to create the initial database schema. The schema
is based on the model specified in the DbContext (In the Models/MovieContext.cs file). The Initial argument is
used to name the migrations. You can use any name, but by convention you choose a name that describes the
migration. See Introduction to migrations for more information.
The ef database update command runs the Up method in the Migrations/<time-stamp>_InitialCreate.cs file,
which creates the database.
Scaffold the Movie model
Open a command window in the project directory (The directory that contains the Program.cs, Startup.cs, and
.csproj files).
Run the following command:
Note: Run the following command on Windows. For MacOS and Linux, see the next command

dotnet aspnet-codegenerator razorpage -m Movie -dc MovieContext -udl -outDir Pages\Movies --

referenceScriptLibraries

On MacOS and Linux, run the following command:

dotnet aspnet-codegenerator razorpage -m Movie -dc MovieContext -udl -outDir Pages/Movies --

referenceScriptLibraries

If you get the error:

The process cannot access the file

'RazorPagesMovie/bin/Debug/netcoreapp2.0/RazorPagesMovie.dll'
because it is being used by another process.

Exit Visual Studio and run the command again.

The following table details the ASP.NET Core code generators` parameters:

PARAMETER DESCRIPTION

-m The name of the model.

-dc The data context.

-udl Use the default layout.

-outDir The relative output folder path to create the views.

--referenceScriptLibraries Adds _ValidationScriptsPartial to Edit and Create pages

Use the h switch to get help on the aspnet-codegenerator razorpage command:

dotnet aspnet-codegenerator razorpage -h

Test the app

Run the app and append /Movies to the URL in the browser ( http://localhost:port/movies ).
Test the Create link.
 Test the Edit, Details, and Delete links.
If you get the following error, verify you have run migrations and updated the database:

An unhandled exception occurred while processing the request.

SqliteException: SQLite Error 1: 'no such table: Movie'.
Microsoft.Data.Sqlite.SqliteException.ThrowExceptionForRC(int rc, sqlite3 db)

The next tutorial explains the files created by scaffolding.

P R E V IO U S : G E T T IN G N E X T: S C A F F O L D E D R A Z O R
STA RTE D PAGES
 Create a web app with ASP.NET Core MVC using
Visual Studio on Windows
9/19/2017 1 min to read Edit Online

This series of tutorials teaches you the basics of building an ASP.NET Core MVC web app using Visual Studio. This
tutorial teaches ASP.NET Core MVC with controllers and views. Razor Pages is a new alternative in ASP.NET Core
2.0, a page-based programming model that makes building web UI easier and more productive. We recommend
you try the Razor Pages tutorial before the MVC version. For a Razor Pages version of this tutorial, see Razor
Pages.
1. Getting started
2. Adding a controller
3. Adding a view
4. Adding a model
5. Working with SQL Server LocalDB
6. Controller methods and views
7. Adding Search
8. Adding a New Field
9. Adding Validation
10. Examining the Details and Delete methods
 Getting started with ASP.NET Core MVC and Visual
Studio
9/22/2017 3 min to read Edit Online

By Rick Anderson
This tutorial will teach you the basics of building an ASP.NET Core MVC web app using Visual Studio 2017. This
tutorial teaches ASP.NET Core MVC with controllers and views. Razor Pages is a new alternative in ASP.NET Core
2.0, a page-based programming model that makes building web UI easier and more productive. We recommend
you try the Razor Pages tutorial before the MVC version. For a Razor Pages version of this tutorial, see Razor
Pages.
There are 3 versions of this tutorial:
macOS: Create an ASP.NET Core MVC app with Visual Studio for Mac
Windows: Create an ASP.NET Core MVC app with Visual Studio
macOS, Linux, and Windows: Create an ASP.NET Core MVC app with Visual Studio Code
For the Visual Studio 2015 version of this tutorial, see the VS 2015 version of ASP.NET Core documentation in
PDF format.

Install Visual Studio and .NET Core

ASP.NET Core 2.x
ASP.NET Core 1.x
Install the following:
.NET Core 2.0.0 SDK or later.
Visual Studio 2017 version 15.3 or later with the ASP.NET and web development workload.

Create a web app

From Visual Studio, select File > New > Project.
Complete the New Project dialog:
In the left pane, tap .NET Core
In the center pane, tap ASP.NET Core Web Application (.NET Core)
Name the project "MvcMovie" (It's important to name the project "MvcMovie" so when you copy code, the
namespace will match.)
Tap OK

ASP.NET Core 2.x

ASP.NET Core 1.x
Complete the New ASP.NET Core Web Application (.NET Core) - MvcMovie dialog:
In the version selector drop-down box select ASP.NET Core 2.-
Select Web Application(Model-View-Controller)
Tap OK.
Visual Studio used a default template for the MVC project you just created. You have a working app right now by
entering a project name and selecting a few options. This is a simple starter project, and it's a good place to start,
Tap F5 to run the app in debug mode or Ctrl-F5 in non-debug mode.

Visual Studio starts IIS Express and runs your app. Notice that the address bar shows localhost:port# and not
something like example.com . That's because localhost is the standard hostname for your local computer.
When Visual Studio creates a web project, a random port is used for the web server. In the image above, the
port number is 5000. When you run the app, you'll see a different port number.
 Launching the app with Ctrl+F5 (non-debug mode) allows you to make code changes, save the file, refresh
the browser, and see the code changes. Many developers prefer to use non-debug mode to quickly launch the
app and view changes.
You can launch the app in debug or non-debug mode from the Debug menu item:

You can debug the app by tapping the IIS Express button

The default template gives you working Home, About and Contact links. The browser image above doesn't
show these links. Depending on the size of your browser, you might need to click the navigation icon to show
them.

If you were running in debug mode, tap Shift-F5 to stop debugging.

In the next part of this tutorial, we'll learn about MVC and start writing some code.

NEXT
 Adding a controller to a ASP.NET Core MVC app
with Visual Studio
9/22/2017 5 min to read Edit Online

By Rick Anderson
The Model-View-Controller (MVC) architectural pattern separates an app into three main components: Model,
View, and Controller. The MVC pattern helps you create apps that are more testable and easier to update than
traditional monolithic apps. MVC-based apps contain:
Models: Classes that represent the data of the app. The model classes use validation logic to enforce
business rules for that data. Typically, model objects retrieve and store model state in a database. In this
tutorial, a Movie model retrieves movie data from a database, provides it to the view or updates it. Updated
data is written to a database.
Views: Views are the components that display the app's user interface (UI). Generally, this UI displays the
model data.
Controllers: Classes that handle browser requests. They retrieve model data and call view templates that
return a response. In an MVC app, the view only displays information; the controller handles and responds
to user input and interaction. For example, the controller handles route data and query-string values, and
passes these values to the model. The model might use these values to query the database. For example,
http://localhost:1234/Home/About has route data of Home (the controller) and About (the action method to
call on the home controller). http://localhost:1234/Movies/Edit/5 is a request to edit the movie with ID=5
using the movie controller. We'll talk about route data later in the tutorial.
The MVC pattern helps you create apps that separate the different aspects of the app (input logic, business logic,
and UI logic), while providing a loose coupling between these elements. The pattern specifies where each kind of
logic should be located in the app. The UI logic belongs in the view. Input logic belongs in the controller. Business
logic belongs in the model. This separation helps you manage complexity when you build an app, because it
enables you to work on one aspect of the implementation at a time without impacting the code of another. For
example, you can work on the view code without depending on the business logic code.
We cover these concepts in this tutorial series and show you how to use them to build a movie app. The MVC
project contains folders for the Controllers and Views. A Models folder will be added in a later step.
In Solution Explorer, right-click Controllers > Add > New Item
 Select MVC Controller Class
In the Add New Item dialog, enter HelloWorldController.

Replace the contents of Controllers/HelloWorldController.cs with the following:

 using Microsoft.AspNetCore.Mvc;
using System.Text.Encodings.Web;

namespace MvcMovie.Controllers
{
public class HelloWorldController : Controller
{
//
// GET: /HelloWorld/

public string Index()

{
return "This is my default action...";
}

//
// GET: /HelloWorld/Welcome/

public string Welcome()

{
return "This is the Welcome action method...";
}
}
}

Every public method in a controller is callable as an HTTP endpoint. In the sample above, both methods return a
string. Note the comments preceding each method.
An HTTP endpoint is a targetable URL in the web application, such as http://localhost:1234/HelloWorld , and
combines the protocol used: HTTP , the network location of the web server (including the TCP port):
localhost:1234 and the target URI HelloWorld .

The first comment states this is an HTTP GET method that is invoked by appending "/HelloWorld/" to the base URL.
The second comment specifies an HTTP GET method that is invoked by appending "/HelloWorld/Welcome/" to the
URL. Later on in the tutorial you'll use the scaffolding engine to generate HTTP POST methods.
Run the app in non-debug mode and append "HelloWorld" to the path in the address bar. The Index method
returns a string.

MVC invokes controller classes (and the action methods within them) depending on the incoming URL. The default
URL routing logic used by MVC uses a format like this to determine what code to invoke:
/[Controller]/[ActionName]/[Parameters]

You set the format for routing in the Startup.cs file.

 app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

When you run the app and don't supply any URL segments, it defaults to the "Home" controller and the "Index"
method specified in the template line highlighted above.
The first URL segment determines the controller class to run. So localhost:xxxx/HelloWorld maps to the
HelloWorldController class. The second part of the URL segment determines the action method on the class. So
localhost:xxxx/HelloWorld/Index would cause the Index method of the HelloWorldController class to run. Notice
that you only had to browse to localhost:xxxx/HelloWorld and the Index method was called by default. This is
because Index is the default method that will be called on a controller if a method name is not explicitly specified.
The third part of the URL segment ( id ) is for route data. You'll see route data later on in this tutorial.
Browse to http://localhost:xxxx/HelloWorld/Welcome . The Welcome method runs and returns the string "This is the
Welcome action method...". For this URL, the controller is HelloWorld and Welcome is the action method. You
haven't used the [Parameters] part of the URL yet.

Modify the code to pass some parameter information from the URL to the controller. For example,
/HelloWorld/Welcome?name=Rick&numtimes=4 . Change the Welcome method to include two parameters as shown in
the following code.

// GET: /HelloWorld/Welcome/
// Requires using System.Text.Encodings.Web;
public string Welcome(string name, int numTimes = 1)
{
return HtmlEncoder.Default.Encode($"Hello {name}, NumTimes is: {numTimes}");
}

The preceding code:

Uses the C# optional-parameter feature to indicate that the numTimes parameter defaults to 1 if no value is
passed for that parameter.
Uses HtmlEncoder.Default.Encode to protect the app from malicious input (namely JavaScript).
Uses Interpolated Strings.
Run your app and browse to:
http://localhost:xxxx/HelloWorld/Welcome?name=Rick&numtimes=4

(Replace xxxx with your port number.) You can try different values for name and numtimes in the URL. The MVC
model binding system automatically maps the named parameters from the query string in the address bar to
parameters in your method. See Model Binding for more information.

In the image above, the URL segment ( Parameters ) is not used, the name and numTimes parameters are passed as
query strings. The ? (question mark) in the above URL is a separator, and the query strings follow. The &
character separates query strings.
Replace the Welcome method with the following code:

public string Welcome(string name, int ID = 1)

{
return HtmlEncoder.Default.Encode($"Hello {name}, ID: {ID}");
}

Run the app and enter the following URL: http://localhost:xxx/HelloWorld/Welcome/3?name=Rick

This time the third URL segment matched the route parameter id . The Welcome method contains a parameter
id that matched the URL template in the MapRoute method. The trailing ? (in id? ) indicates the id parameter
is optional.

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

In these examples the controller has been doing the "VC" portion of MVC - that is, the view and controller work.
The controller is returning HTML directly. Generally you don't want controllers returning HTML directly, since that
becomes very cumbersome to code and maintain. Instead you typically use a separate Razor view template file to
help generate the HTML response. You do that in the next tutorial.
In Visual Studio, in non-debug mode (Ctrl+F5), you don't need to build the app after changing code. Just save the
file, refresh your browser and you can see the changes.

P R E V IO U S NEXT
 Adding a view to an ASP.NET Core MVC app
9/20/2017 8 min to read Edit Online

By Rick Anderson
In this section you modify the HelloWorldController class to use Razor view template files to cleanly encapsulate
the process of generating HTML responses to a client.
You create a view template file using Razor. Razor-based view templates have a .cshtml file extension. They provide
an elegant way to create HTML output using C#.
Currently the method returns a string with a message that is hard-coded in the controller class. In the
Index
HelloWorldController class, replace the Index method with the following code:

public IActionResult Index()

{
return View();
}

The preceding code returns a View object. It uses a view template to generate an HTML response to the browser.
Controller methods (also known as action methods) such as the Index method above, generally return an
IActionResult (or a class derived from ActionResult ), not primitive types like string.
Right click on the Views folder, and then Add > New Folder and name the folder HelloWorld.
Right click on the Views/HelloWorld folder, and then Add > New Item.
In the Add New Item - MvcMovie dialog
In the search box in the upper-right, enter view
Tap MVC View Page
In the Name box, change the name if necessary to Index.cshtml.
Tap Add
Replace the contents of the Views/HelloWorld/Index.cshtml Razor view file with the following:

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>Hello from our View Template!</p>

Navigate to http://localhost:xxxx/HelloWorld . The Index method in the HelloWorldController didn't do much; it

ran the statement return View(); , which specified that the method should use a view template file to render a
response to the browser. Because you didn't explicitly specify the name of the view template file, MVC defaulted to
using the Index.cshtml view file in the /Views/HelloWorld folder. The image below shows the string "Hello from our
View Template!" hard-coded in the view.

If your browser window is small (for example on a mobile device), you might need to toggle (tap) the Bootstrap
navigation button in the upper right to see the Home, About, and Contact links.
Changing views and layout pages
Tap the menu links (MvcMovie, Home, About). Each page shows the same menu layout. The menu layout is
implemented in the Views/Shared/_Layout.cshtml file. Open the Views/Shared/_Layout.cshtml file.
Layout templates allow you to specify the HTML container layout of your site in one place and then apply it across
multiple pages in your site. Find the @RenderBody() line. RenderBody is a placeholder where all the view-specific
pages you create show up, wrapped in the layout page. For example, if you select the About link, the
Views/Home/About.cshtml view is rendered inside the RenderBody method.

Change the title and menu link in the layout file

Change the contents of the title element. Change the anchor text in the layout template to "Movie App" and the
controller from Home to Movies as highlighted below:
Note: The ASP.NET Core 2.0 version is slightly different. It doesn't contain @inject ApplicationInsights and
@Html.Raw(JavaScriptSnippet.FullScript) .

@inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>@ViewData["Title"] - Movie App</title>

<environment names="Development">
<link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.css" />
<link rel="stylesheet" href="~/css/site.css" />
</environment>
<environment names="Staging,Production">
<link rel="stylesheet" href="https://ajax.aspnetcdn.com/ajax/bootstrap/3.3.7/css/bootstrap.min.css"
asp-fallback-href="~/lib/bootstrap/dist/css/bootstrap.min.css"
asp-fallback-test-class="sr-only" asp-fallback-test-property="position" asp-fallback-test-
value="absolute" />
<link rel="stylesheet" href="~/css/site.min.css" asp-append-version="true" />
</environment>
@Html.Raw(JavaScriptSnippet.FullScript)
</head>
<body>
<nav class="navbar navbar-inverse navbar-fixed-top">
<div class="container">
 <div class="container">
<div class="navbar-header">
<button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-
collapse">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a asp-area="" asp-controller="Movies" asp-action="Index" class="navbar-brand">MvcMovie</a>
</div>
<div class="navbar-collapse collapse">
<ul class="nav navbar-nav">
<li><a asp-area="" asp-controller="Home" asp-action="Index">Home</a></li>
<li><a asp-area="" asp-controller="Home" asp-action="About">About</a></li>
<li><a asp-area="" asp-controller="Home" asp-action="Contact">Contact</a></li>
</ul>
</div>
</div>
</nav>
<div class="container body-content">
@RenderBody()
<hr />
<footer>
<p>&copy; 2017 - MvcMovie</p>
</footer>
</div>

<environment names="Development">
<script src="~/lib/jquery/dist/jquery.js"></script>
<script src="~/lib/bootstrap/dist/js/bootstrap.js"></script>
<script src="~/js/site.js" asp-append-version="true"></script>
</environment>
<environment names="Staging,Production">
<script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-2.2.0.min.js"
asp-fallback-src="~/lib/jquery/dist/jquery.min.js"
asp-fallback-test="window.jQuery"
crossorigin="anonymous"
integrity="sha384-K+ctZQ+LL8q6tP7I94W+qzQsfRV2a+AfHIi9k8z8l9ggpc8X+Ytst4yBo/hH+8Fk">
</script>
<script src="https://ajax.aspnetcdn.com/ajax/bootstrap/3.3.7/bootstrap.min.js"
asp-fallback-src="~/lib/bootstrap/dist/js/bootstrap.min.js"
asp-fallback-test="window.jQuery && window.jQuery.fn && window.jQuery.fn.modal"
crossorigin="anonymous"
integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa">
</script>
<script src="~/js/site.min.js" asp-append-version="true"></script>
</environment>

@RenderSection("Scripts", required: false)

</body>
</html>

WARNING
We haven't implemented the Movies controller yet, so if you click on that link, you'll get a 404 (Not found) error.

Save your changes and tap the About link. Notice how the title on the browser tab now displays About - Movie
App instead of About - Mvc Movie. Tap the Contact link and notice that it also displays Movie App. We were
able to make the change once in the layout template and have all pages on the site reflect the new link text and
new title.
Examine the Views/_ViewStart.cshtml file:
 @{
Layout = "_Layout";
}

The Views/_ViewStart.cshtml file brings in the Views/Shared/_Layout.cshtml file to each view. You can use the
Layout property to set a different layout view, or set it to null so no layout file will be used.

Change the title of the Index view.

Open Views/HelloWorld/Index.cshtml. There are two places to make a change:
The text that appears in the title of the browser.
The secondary header ( <h2> element).
You'll make them slightly different so you can see which bit of code changes which part of the app.

@{
ViewData["Title"] = "Movie List";
}

<h2>My Movie List</h2>

<p>Hello from our View Template!</p>

ViewData["Title"] = "Movie List"; in the code above sets the Title property of the ViewData dictionary to
"Movie List". The Title property is used in the <title> HTML element in the layout page:

<title>@ViewData["Title"] - Movie App</title>

Save your change and navigate to http://localhost:xxxx/HelloWorld . Notice that the browser title, the primary
heading, and the secondary headings have changed. (If you don't see changes in the browser, you might be
viewing cached content. Press Ctrl+F5 in your browser to force the response from the server to be loaded.) The
browser title is created with ViewData["Title"] we set in the Index.cshtml view template and the additional "-
Movie App" added in the layout file.
Also notice how the content in the Index.cshtml view template was merged with the Views/Shared/_Layout.cshtml
view template and a single HTML response was sent to the browser. Layout templates make it really easy to make
changes that apply across all of the pages in your application. To learn more see Layout.

Our little bit of "data" (in this case the "Hello from our View Template!" message) is hard-coded, though. The MVC
application has a "V" (view) and you've got a "C" (controller), but no "M" (model) yet.

Passing Data from the Controller to the View

Controller actions are invoked in response to an incoming URL request. A controller class is where you write the
code that handles the incoming browser requests. The controller retrieves data from a data source and decides
what type of response to send back to the browser. View templates can be used from a controller to generate and
format an HTML response to the browser.
Controllers are responsible for providing the data required in order for a view template to render a response. A
best practice: View templates should not perform business logic or interact with a database directly. Rather, a view
template should work only with the data that's provided to it by the controller. Maintaining this "separation of
concerns" helps keep your code clean, testable, and maintainable.
Currently, the Welcome method in the HelloWorldController class takes a name and a ID parameter and then
outputs the values directly to the browser. Rather than have the controller render this response as a string, lets
change the controller to use a view template instead. The view template will generate a dynamic response, which
means that you need to pass appropriate bits of data from the controller to the view in order to generate the
response. You can do this by having the controller put the dynamic data (parameters) that the view template needs
in a ViewData dictionary that the view template can then access.
Return to the HelloWorldController.cs file and change the Welcome method to add a Message and NumTimes value
to the ViewData dictionary. The ViewData dictionary is a dynamic object, which means you can put whatever you
want in to it; the ViewData object has no defined properties until you put something inside it. The MVC model
binding system automatically maps the named parameters ( name and numTimes ) from the query string in the
address bar to parameters in your method. The complete HelloWorldController.cs file looks like this:

using Microsoft.AspNetCore.Mvc;
using System.Text.Encodings.Web;

namespace MvcMovie.Controllers
{
public class HelloWorldController : Controller
{
public IActionResult Index()
{
return View();
}

public IActionResult Welcome(string name, int numTimes = 1)

{
ViewData["Message"] = "Hello " + name;
ViewData["NumTimes"] = numTimes;

return View();
}
}
}

The ViewData dictionary object contains data that will be passed to the view.
Create a Welcome view template named Views/HelloWorld/Welcome.cshtml.
You'll create a loop in the Welcome.cshtml view template that displays "Hello" NumTimes . Replace the contents of
Views/HelloWorld/Welcome.cshtml with the following:
 @{
ViewData["Title"] = "Welcome";
}

<h2>Welcome</h2>

<ul>
@for (int i = 0; i < (int)ViewData["NumTimes"]; i++)
{
<li>@ViewData["Message"]</li>
}
</ul>

Save your changes and browse to the following URL:

http://localhost:xxxx/HelloWorld/Welcome?name=Rick&numtimes=4

Data is taken from the URL and passed to the controller using the MVC model binder . The controller packages the
data into a ViewData dictionary and passes that object to the view. The view then renders the data as HTML to the
browser.

In the sample above, we used the ViewData dictionary to pass data from the controller to a view. Later in the
tutorial, we will use a view model to pass data from a controller to a view. The view model approach to passing
data is generally much preferred over the ViewData dictionary approach. See ViewModel vs ViewData vs ViewBag
vs TempData vs Session in MVC for more information.
Well, that was a kind of an "M" for model, but not the database kind. Let's take what we've learned and create a
database of movies.

P R E V IO U S NEXT
 Adding a model to an ASP.NET Core MVC app
9/12/2017 9 min to read Edit Online

By Rick Anderson and Tom Dykstra

In this section, you'll add some classes for managing movies in a database. These classes will be the "Model" part
of the MVC app.
You use these classes with Entity Framework Core (EF Core) to work with a database. EF Core is an object-
relational mapping (ORM) framework that simplifies the data access code that you have to write. EF Core supports
many database engines.
The model classes you'll create are known as POCO classes (from "plain-old CLR objects") because they don't have
any dependency on EF Core. They just define the properties of the data that will be stored in the database.
In this tutorial you'll write the model classes first, and EF Core will create the database. An alternate approach not
covered here is to generate model classes from an already-existing database. For information about that approach,
see ASP.NET Core - Existing Database.

Add a data model class

Note: The ASP.NET Core 2.0 templates contain the Models folder.
In Solution Explorer, right click the MvcMovie project > Add > New Folder. Name the folder Models.
Right click the Models folder > Add > Class. Name the class Movie and add the following properties:

using System;

namespace MvcMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

The ID field is required by the database for the primary key.

Build the project to verify you don't have any errors. You now have a Model in your MVC app.

Scaffolding a controller
In Solution Explorer, right-click the Controllers folder > Add > Controller.
In the Add MVC Dependencies dialog, select Minimal Dependencies, and select Add.

Visual Studio adds the dependencies needed to scaffold a controller, but the controller itself is not created. The
next invoke of > Add > Controller creates the controller.
In Solution Explorer, right-click the Controllers folder > Add > Controller.
In the Add Scaffold dialog, tap MVC Controller with views, using Entity Framework > Add.

Complete the Add Controller dialog:

Model class: Movie (MvcMovie.Models)
Data context class: Select the + icon and add the default MvcMovie.Models.MvcMovieContext
 Views: Keep the default of each option checked
Controller name: Keep the default MoviesController
Tap Add

Visual Studio creates:

An Entity Framework Core database context class (Data/MvcMovieContext.cs)
A movies controller (Controllers/MoviesController.cs)
Razor view files for Create, Delete, Details, Edit and Index pages (Views/Movies/*.cshtml)
The automatic creation of the database context and CRUD (create, read, update, and delete) action methods and
views is known as scaffolding. You'll soon have a fully functional web application that lets you manage a movie
database.
If you run the app and click on the Mvc Movie link, you'll get an error similar to the following:

An unhandled exception occurred while processing the request.

SqlException: Cannot open database "MvcMovieContext-<GUID removed>" requested by the login. The login failed.
Login failed for user 'Rick'.

System.Data.SqlClient.SqlInternalConnectionTds..ctor(DbConnectionPoolIdentity identity, SqlConnectionString

You need to create the database, and you'll use the EF Core Migrations feature to do that. Migrations lets you
create a database that matches your data model and update the database schema when your data model changes.

Add EF tooling and perform initial migration

In this section you'll use the Package Manager Console (PMC) to:
Add the Entity Framework Core Tools package. This package is required to add migrations and update the
database.
Add an initial migration.
Update the database with the initial migration.
From the Tools menu, select NuGet Package Manager > Package Manager Console.

In the PMC, enter the following commands:

Install-Package Microsoft.EntityFrameworkCore.Tools
Add-Migration Initial
Update-Database

Note: If you receive an error with the Install-Package command, open NuGet Package Manager and search for
the Microsoft.EntityFrameworkCore.Tools package. This allows you to install the package or check if it is already
installed. Alternatively, see the CLI approach if you have problems with the PMC.
The Add-Migration command creates code to create the initial database schema. The schema is based on the
model specified in the DbContext (In the Data/MvcMovieContext.cs file). The Initial argument is used to name
the migrations. You can use any name, but by convention you choose a name that describes the migration. See
Introduction to migrations for more information.
The Update-Database command runs the Up method in the Migrations/<time-stamp>_InitialCreate.cs file, which
creates the database.
You can perform the preceeding steps using the command-line interface (CLI) rather than the PMC:
Add EF Core tooling to the .csproj file.
Run the following commands from the console (in the project directory):
 dotnet ef migrations add InitialCreate
dotnet ef database update

Test the app

Run the app and tap the Mvc Movie link.
Tap the Create New link and create a movie.

You may not be able to enter decimal points or commas in the Price field. To support jQuery validation for
non-English locales that use a comma (",") for a decimal point, and non US-English date formats, you must
take steps to globalize your app. See https://github.com/aspnet/Docs/issues/4076 and Additional resources
for more information. For now, just enter whole numbers like 10.
In some locales you need to specify the date format. See the highlighted code below.
 using System;
using System.ComponentModel.DataAnnotations;

namespace MvcMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

We'll talk about DataAnnotations later in the tutorial.

Tapping Create causes the form to be posted to the server, where the movie information is saved in a database.
The app redirects to the /Movies URL, where the newly created movie information is displayed.

Create a couple more movie entries. Try the Edit, Details, and Delete links, which are all functional.

public void ConfigureServices(IServiceCollection services)

{
// Add framework services.
services.AddMvc();

services.AddDbContext<MvcMovieContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("MvcMovieContext")));
}

The highlighted code above shows the movie database context being added to the Dependency Injection container.
The line following services.AddDbContext<MvcMovieContext>(options => is not shown (see your code). It specifies the
database to use and the connection string. => is a lambda operator.
Open the Controllers/MoviesController.cs file and examine the constructor:
 public class MoviesController : Controller
{
private readonly MvcMovieContext _context;

public MoviesController(MvcMovieContext context)

{
_context = context;
}

The constructor uses Dependency Injection to inject the database context ( MvcMovieContext ) into the controller.
The database context is used in each of the CRUD methods in the controller.

Strongly typed models and the @model keyword

Earlier in this tutorial, you saw how a controller can pass data or objects to a view using the ViewData dictionary.
The ViewData dictionary is a dynamic object that provides a convenient late-bound way to pass information to a
view.
MVC also provides the ability to pass strongly typed model objects to a view. This strongly typed approach enables
better compile-time checking of your code. The scaffolding mechanism used this approach (that is, passing a
strongly typed model) with the MoviesController class and views when it created the methods and views.
Examine the generated Details method in the Controllers/MoviesController.cs file:

// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie

.SingleOrDefaultAsync(m => m.ID == id);
if (movie == null)
{
return NotFound();
}

return View(movie);
}

The id parameter is generally passed as route data. For example http://localhost:5000/movies/details/1 sets:
The controller to the movies controller (the first URL segment).
The action to details (the second URL segment).
The id to 1 (the last URL segment).
You can also pass in the id with a query string as follows:
http://localhost:1234/movies/details?id=1

The id parameter is defined as a nullable type ( int? ) in case an ID value is not provided.
A lambda expression is passed in to SingleOrDefaultAsync to select movie entities that match the route data or
query string value.
 var movie = await _context.Movie
.SingleOrDefaultAsync(m => m.ID == id);

If a movie is found, an instance of the Movie model is passed to the Details view:

return View(movie);

Examine the contents of the Views/Movies/Details.cshtml file:

@model MvcMovie.Models.Movie

@{
ViewData["Title"] = "Details";
}

<h2>Details</h2>

<div>
<h4>Movie</h4>
<hr />
<dl class="dl-horizontal">
<dt>
@Html.DisplayNameFor(model => model.Title)
</dt>
<dd>
@Html.DisplayFor(model => model.Title)
</dd>
<dt>
@Html.DisplayNameFor(model => model.ReleaseDate)
</dt>
<dd>
@Html.DisplayFor(model => model.ReleaseDate)
</dd>
<dt>
@Html.DisplayNameFor(model => model.Genre)
</dt>
<dd>
@Html.DisplayFor(model => model.Genre)
</dd>
<dt>
@Html.DisplayNameFor(model => model.Price)
</dt>
<dd>
@Html.DisplayFor(model => model.Price)
</dd>
</dl>
</div>
<div>
<a asp-action="Edit" asp-route-id="@Model.ID">Edit</a> |
<a asp-action="Index">Back to List</a>
</div>

By including a @model statement at the top of the view file, you can specify the type of object that the view expects.
When you created the movie controller, Visual Studio automatically included the following @model statement at
the top of the Details.cshtml file:

@model MvcMovie.Models.Movie

This @model directive allows you to access the movie that the controller passed to the view by using a Model
object that's strongly typed. For example, in the Details.cshtml view, the code passes each movie field to the
DisplayNameFor and DisplayFor HTML Helpers with the strongly typed Model object. The Create and Edit
methods and views also pass a Movie model object.
Examine the Index.cshtml view and the Index method in the Movies controller. Notice how the code creates a
List object when it calls the View method. The code passes this Movies list from the Index action method to
the view:

// GET: Movies
public async Task<IActionResult> Index()
{
return View(await _context.Movie.ToListAsync());
}

When you created the movies controller, scaffolding automatically included the following @model statement at the
top of the Index.cshtml file:

@model IEnumerable<MvcMovie.Models.Movie>

The @modeldirective allows you to access the list of movies that the controller passed to the view by using a
Model object that's strongly typed. For example, in the Index.cshtml view, the code loops through the movies with
a foreach statement over the strongly typed Model object:
 @model IEnumerable<MvcMovie.Models.Movie>

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-action="Create">Create New</a>
</p>
<table class="table">
<thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.Title)
</th>
<th>
@Html.DisplayNameFor(model => model.ReleaseDate)
</th>
<th>
@Html.DisplayNameFor(model => model.Genre)
</th>
<th>
@Html.DisplayNameFor(model => model.Price)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model) {
<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
<a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
<a asp-action="Details" asp-route-id="@item.ID">Details</a> |
<a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>
}
</tbody>
</table>

Because the Model object is strongly typed (as an IEnumerable<Movie> object), each item in the loop is typed as
Movie . Among other benefits, this means that you get compile-time checking of the code:
Additional resources
Tag Helpers
Globalization and localization

P R E V IO U S A D D IN G A N E X T W O R K IN G W IT H
V IE W SQL
 Working with SQL Server LocalDB
9/22/2017 3 min to read Edit Online

By Rick Anderson
The MvcMovieContext object handles the task of connecting to the database and mapping Movie objects to
database records. The database context is registered with the Dependency Injection container in the
ConfigureServices method in the Startup.cs file:

public void ConfigureServices(IServiceCollection services)

{
// Add framework services.
services.AddMvc();

services.AddDbContext<MvcMovieContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("MvcMovieContext")));
}

The ASP.NET Core Configuration system reads the ConnectionString . For local development, it gets the connection
string from the appsettings.json file:

"ConnectionStrings": {
"MvcMovieContext": "Server=(localdb)\\mssqllocaldb;Database=MvcMovieContext-
2;Trusted_Connection=True;MultipleActiveResultSets=true"
}

When you deploy the app to a test or production server, you can use an environment variable or another approach
to set the connection string to a real SQL Server. See Configuration for more information.

SQL Server Express LocalDB

LocalDB is a lightweight version of the SQL Server Express Database Engine that is targeted for program
development. LocalDB starts on demand and runs in user mode, so there is no complex configuration. By default,
LocalDB database creates "*.mdf" files in the C:/Users/<user> directory.
From the View menu, open SQL Server Object Explorer (SSOX).
 Right click on the Movie table > View Designer

Note the key icon next to ID . By default, EF will make a property named ID the primary key.
Right click on the Movie table > View Data
Seed the database
Create a new class named SeedData in the Models folder. Replace the generated code with the following:
 using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Linq;

namespace MvcMovie.Models
{
public static class SeedData
{
public static void Initialize(IServiceProvider serviceProvider)
{
using (var context = new MvcMovieContext(
serviceProvider.GetRequiredService<DbContextOptions<MvcMovieContext>>()))
{
// Look for any movies.
if (context.Movie.Any())
{
return; // DB has been seeded
}

context.Movie.AddRange(
new Movie
{
Title = "When Harry Met Sally",
ReleaseDate = DateTime.Parse("1989-1-11"),
Genre = "Romantic Comedy",
Price = 7.99M
},

new Movie
{
Title = "Ghostbusters ",
ReleaseDate = DateTime.Parse("1984-3-13"),
Genre = "Comedy",
Price = 8.99M
},

new Movie
{
Title = "Ghostbusters 2",
ReleaseDate = DateTime.Parse("1986-2-23"),
Genre = "Comedy",
Price = 9.99M
},

new Movie
{
Title = "Rio Bravo",
ReleaseDate = DateTime.Parse("1959-4-15"),
Genre = "Western",
Price = 3.99M
}
);
context.SaveChanges();
}
}
}
}

If there are any movies in the DB, the seed initializer returns and no movies are added.
 if (context.Movie.Any())
{
return; // DB has been seeded.
}

Add the seed initializer

ASP.NET Core 2.x
ASP.NET Core 1.x
Add the seed initializer to the Main method in the Program.cs file:

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using MvcMovie.Models;
using System;

namespace MvcMovie
{
public class Program
{
public static void Main(string[] args)
{
var host = BuildWebHost(args);

using (var scope = host.Services.CreateScope())

{
var services = scope.ServiceProvider;

try
{
// Requires using RazorPagesMovie.Models;
SeedData.Initialize(services);
}
catch (Exception ex)
{
var logger = services.GetRequiredService<ILogger<Program>>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}

host.Run();
}

public static IWebHost BuildWebHost(string[] args) =>

WebHost.CreateDefaultBuilder(args)
.UseStartup<Startup>()
.Build();
}
}

Test the app

Delete all the records in the DB. You can do this with the delete links in the browser or from SSOX.
Force the app to initialize (call the methods in the Startup class) so the seed method runs. To force
initialization, IIS Express must be stopped and restarted. You can do this with any of the following
approaches:
Right click the IIS Express system tray icon in the notification area and tap Exit or Stop Site
 If you were running VS in non-debug mode, press F5 to run in debug mode
If you were running VS in debug mode, stop the debugger and press F5
The app shows the seeded data.

P R E V IO U S NEXT
 Controller methods and views
7/5/2017 9 min to read Edit Online

By Rick Anderson
We have a good start to the movie app, but the presentation is not ideal. We don't want to see the time (12:00:00
AM in the image below) and ReleaseDate should be two words.

Open the Models/Movie.cs file and add the highlighted lines shown below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace MvcMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

Right click on a red squiggly line > Quick Actions and Refactorings.
Tap using System.ComponentModel.DataAnnotations;

Visual studio adds using System.ComponentModel.DataAnnotations; .

Let's remove the using statements that are not needed. They show up by default in a light grey font. Right click
anywhere in the Movie.cs file > Remove and Sort Usings.
The updated code:

using System;
using System.ComponentModel.DataAnnotations;

namespace MvcMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

We'll cover DataAnnotations in the next tutorial. The Display attribute specifies what to display for the name of a
field (in this case "Release Date" instead of "ReleaseDate"). The DataType attribute specifies the type of the data
(Date), so the time information stored in the field is not displayed.
Browse to the Movies controller and hold the mouse pointer over an Edit link to see the target URL.
The Edit, Details, and Delete links are generated by the MVC Core Anchor Tag Helper in the
Views/Movies/Index.cshtml file.

<a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |

<a asp-action="Details" asp-route-id="@item.ID">Details</a> |
<a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>

Tag Helpers enable server-side code to participate in creating and rendering HTML elements in Razor files. In the
code above, the AnchorTagHelper dynamically generates the HTML href attribute value from the controller action
method and route id. You use View Source from your favorite browser or use the developer tools to examine the
generated markup. A portion of the generated HTML is shown below:

<td>
<a href="/Movies/Edit/4"> Edit </a> |
<a href="/Movies/Details/4"> Details </a> |
<a href="/Movies/Delete/4"> Delete </a>
</td>

Recall the format for routing set in the Startup.cs file:

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

ASP.NET Core translates http://localhost:1234/Movies/Edit/4 into a request to the Edit action method of the
Movies controller with the parameter Id of 4. (Controller methods are also known as action methods.)

Tag Helpers are one of the most popular new features in ASP.NET Core. See Additional resources for more
information.
Open the Movies controller and examine the two Edit action methods. The following code shows the
HTTP GET Edit method, which fetches the movie and populates the edit form generated by the Edit.cshtml Razor
file.

// GET: Movies/Edit/5
public async Task<IActionResult> Edit(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie.SingleOrDefaultAsync(m => m.ID == id);

if (movie == null)
{
return NotFound();
}
return View(movie);
}

The following code shows the HTTP POST Edit method, which processes the posted movie values:

// POST: Movies/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("ID,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (id != movie.ID)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.ID))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction("Index");
}
return View(movie);
}

The [Bind] attribute is one way to protect against over-posting. You should only include properties in the [Bind]
attribute that you want to change. See Protect your controller from over-posting for more information.
ViewModels provide an alternative approach to prevent over-posting.
Notice the second Edit action method is preceded by the [HttpPost] attribute.

// POST: Movies/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("ID,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (id != movie.ID)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.ID))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction("Index");
}
return View(movie);
}

The HttpPost attribute specifies that this Edit method can be invoked only for POST requests. You could apply
the [HttpGet] attribute to the first edit method, but that's not necessary because [HttpGet] is the default.

The ValidateAntiForgeryToken attribute is used to prevent forgery of a request and is paired up with an anti-
forgery token generated in the edit view file (Views/Movies/Edit.cshtml). The edit view file generates the anti-
forgery token with the Form Tag Helper.

<form asp-action="Edit">

The Form Tag Helper generates a hidden anti-forgery token that must match the [ValidateAntiForgeryToken]
generated anti-forgery token in the Edit method of the Movies controller. For more information, see Anti-
Request Forgery.
The method takes the movie ID parameter, looks up the movie using the Entity Framework
HttpGet Edit
SingleOrDefaultAsync method, and returns the selected movie to the Edit view. If a movie cannot be found,
NotFound (HTTP 404) is returned.
 // GET: Movies/Edit/5
public async Task<IActionResult> Edit(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie.SingleOrDefaultAsync(m => m.ID == id);

if (movie == null)
{
return NotFound();
}
return View(movie);
}

When the scaffolding system created the Edit view, it examined the Movie class and created code to render
<label> and <input> elements for each property of the class. The following example shows the Edit view that
was generated by the Visual Studio scaffolding system:
 @model MvcMovie.Models.Movie

@{
ViewData["Title"] = "Edit";
}

<h2>Edit</h2>

<form asp-action="Edit">
<div class="form-horizontal">
<h4>Movie</h4>
<hr />
<div asp-validation-summary="ModelOnly" class="text-danger"></div>
<input type="hidden" asp-for="ID" />
<div class="form-group">
<label asp-for="Title" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Title" class="form-control" />
<span asp-validation-for="Title" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<label asp-for="ReleaseDate" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="ReleaseDate" class="form-control" />
<span asp-validation-for="ReleaseDate" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<label asp-for="Genre" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Genre" class="form-control" />
<span asp-validation-for="Genre" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<label asp-for="Price" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Price" class="form-control" />
<span asp-validation-for="Price" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<div class="col-md-offset-2 col-md-10">
<input type="submit" value="Save" class="btn btn-default" />
</div>
</div>
</div>
</form>

<div>
<a asp-action="Index">Back to List</a>
</div>

@section Scripts {
@{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

Notice how the view template has a @model MvcMovie.Models.Movie statement at the top of the file.
@model MvcMovie.Models.Movie specifies that the view expects the model for the view template to be of type Movie .
The scaffolded code uses several Tag Helper methods to streamline the HTML markup. The - Label Tag Helper
displays the name of the field ("Title", "ReleaseDate", "Genre", or "Price"). The Input Tag Helper renders an HTML
<input> element. The Validation Tag Helper displays any validation messages associated with that property.
Run the application and navigate to the /Movies URL. Click an Edit link. In the browser, view the source for the
page. The generated HTML for the <form> element is shown below.

<form action="/Movies/Edit/7" method="post">

<div class="form-horizontal">
<h4>Movie</h4>
<hr />
<div class="text-danger" />
<input type="hidden" data-val="true" data-val-required="The ID field is required." id="ID" name="ID"
value="7" />
<div class="form-group">
<label class="control-label col-md-2" for="Genre" />
<div class="col-md-10">
<input class="form-control" type="text" id="Genre" name="Genre" value="Western" />
<span class="text-danger field-validation-valid" data-valmsg-for="Genre" data-valmsg-
replace="true"></span>
</div>
</div>
<div class="form-group">
<label class="control-label col-md-2" for="Price" />
<div class="col-md-10">
<input class="form-control" type="text" data-val="true" data-val-number="The field Price must
be a number." data-val-required="The Price field is required." id="Price" name="Price" value="3.99" />
<span class="text-danger field-validation-valid" data-valmsg-for="Price" data-valmsg-
replace="true"></span>
</div>
</div>
<!-- Markup removed for brevity -->
<div class="form-group">
<div class="col-md-offset-2 col-md-10">
<input type="submit" value="Save" class="btn btn-default" />
</div>
</div>
</div>
<input name="__RequestVerificationToken" type="hidden"
value="CfDJ8Inyxgp63fRFqUePGvuI5jGZsloJu1L7X9le1gy7NCIlSduCRx9jDQClrV9pOTTmqUyXnJBXhmrjcUVDJyDUMm7-
MF_9rK8aAZdRdlOri7FmKVkRe_2v5LIHGKFcTjPrWPYnc9AdSbomkiOSaTEg7RU" />
</form>

The <input> elements are in an HTML <form> element whose action attribute is set to post to the
/Movies/Edit/id URL. The form data will be posted to the server when the Save button is clicked. The last line
before the closing </form> element shows the hidden XSRF token generated by the Form Tag Helper.

Processing the POST Request

The following listing shows the [HttpPost] version of the Edit action method.
 // POST: Movies/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("ID,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (id != movie.ID)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.ID))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction("Index");
}
return View(movie);
}

The [ValidateAntiForgeryToken] attribute validates the hidden XSRF token generated by the anti-forgery token
generator in the Form Tag Helper
The model binding system takes the posted form values and creates a Movie object that's passed as the movie
parameter. The ModelState.IsValid method verifies that the data submitted in the form can be used to modify
(edit or update) a Movie object. If the data is valid it's saved. The updated (edited) movie data is saved to the
database by calling the SaveChangesAsync method of database context. After saving the data, the code redirects the
user to the Index action method of the MoviesController class, which displays the movie collection, including the
changes just made.
Before the form is posted to the server, client side validation checks any validation rules on the fields. If there are
any validation errors, an error message is displayed and the form is not posted. If JavaScript is disabled, you won't
have client side validation but the server will detect the posted values that are not valid, and the form values will be
redisplayed with error messages. Later in the tutorial we examine Model Validation in more detail. The Validation
Tag Helper in the Views/Movies/Edit.cshtml view template takes care of displaying appropriate error messages.
All the HttpGet methods in the movie controller follow a similar pattern. They get a movie object (or list of objects,
in the case of Index ), and pass the object (model) to the view. The Create method passes an empty movie object
to the Create view. All the methods that create, edit, delete, or otherwise modify data do so in the [HttpPost]
overload of the method. Modifying data in an HTTP GET method is a security risk. Modifying data in an HTTP GET
method also violates HTTP best practices and the architectural REST pattern, which specifies that GET requests
should not change the state of your application. In other words, performing a GET operation should be a safe
operation that has no side effects and doesn't modify your persisted data.

Additional resources
Globalization and localization
Introduction to Tag Helpers
Authoring Tag Helpers
Anti-Request Forgery
Protect your controller from over-posting
ViewModels
Form Tag Helper
Input Tag Helper
Label Tag Helper
Select Tag Helper
Validation Tag Helper

P R E V IO U S NEXT
 Adding Search to an ASP.NET Core MVC app
7/5/2017 7 min to read Edit Online

By Rick Anderson
In this section you add search capability to the Index action method that lets you search movies by genre or
name.
Update the Index method with the following code:

public async Task<IActionResult> Index(string searchString)

{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

return View(await movies.ToListAsync());

}

The first line of the Index action method creates a LINQ query to select the movies:

var movies = from m in _context.Movie

select m;

The query is only defined at this point, it has not been run against the database.
If the searchString parameter contains a string, the movies query is modified to filter on the value of the search
string:

if (!String.IsNullOrEmpty(id))
{
movies = movies.Where(s => s.Title.Contains(id));
}

The s => s.Title.Contains() code above is a Lambda Expression. Lambdas are used in method-based LINQ
queries as arguments to standard query operator methods such as the Where method or Contains (used in the
code above). LINQ queries are not executed when they are defined or when they are modified by calling a method
such as Where , Contains or OrderBy . Rather, query execution is deferred. That means that the evaluation of an
expression is delayed until its realized value is actually iterated over or the ToListAsync method is called. For more
information about deferred query execution, see Query Execution.
Note: The Contains method is run on the database, not in the c# code shown above. The case sensitivity on the
query depends on the database and the collation. On SQL Server, Contains maps to SQL LIKE, which is case
insensitive. In SQLlite, with the default collation, it's case sensitive.
Navigate to /Movies/Index . Append a query string such as ?searchString=Ghost to the URL. The filtered movies
are displayed.
If you change the signature of the Index method to have a parameter named id , the id parameter will match
the optional {id} placeholder for the default routes set in Startup.cs.

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

You can quickly rename the searchString parameter to id with the rename command. Right click on
searchString > Rename.
The rename targets are highlighted.

Change the parameter to id and all occurrences of searchString change to id .

The previous Index method:

 public async Task<IActionResult> Index(string searchString)
{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

return View(await movies.ToListAsync());

}

The updated Index method with id parameter:

public async Task<IActionResult> Index(string id)

{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(id))
{
movies = movies.Where(s => s.Title.Contains(id));
}

return View(await movies.ToListAsync());

}

You can now pass the search title as route data (a URL segment) instead of as a query string value.

However, you can't expect users to modify the URL every time they want to search for a movie. So now you'll add
UI to help them filter movies. If you changed the signature of the Index method to test how to pass the route-
bound ID parameter, change it back so that it takes a parameter named searchString :
 public async Task<IActionResult> Index(string searchString)
{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

return View(await movies.ToListAsync());

}

Open the Views/Movies/Index.cshtml file, and add the <form> markup highlighted below:

ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-action="Create">Create New</a>
</p>

<form asp-controller="Movies" asp-action="Index">

<p>
Title: <input type="text" name="SearchString">
<input type="submit" value="Filter" />
</p>
</form>

<table class="table">
<thead>

The HTML <form> tag uses the Form Tag Helper, so when you submit the form, the filter string is posted to the
Index action of the movies controller. Save your changes and then test the filter.
There's no [HttpPost] overload of the Index method as you might expect. You don't need it, because the method
isn't changing the state of the app, just filtering data.
You could add the following [HttpPost] Index method.

[HttpPost]
public string Index(string searchString, bool notUsed)
{
return "From [HttpPost]Index: filter on " + searchString;
}

The notUsed parameter is used to create an overload for the Index method. We'll talk about that later in the
tutorial.
If you add this method, the action invoker would match the [HttpPost] Index method, and the [HttpPost] Index
method would run as shown in the image below.

However, even if you add this [HttpPost] version of the Index method, there's a limitation in how this has all
been implemented. Imagine that you want to bookmark a particular search or you want to send a link to friends
that they can click in order to see the same filtered list of movies. Notice that the URL for the HTTP POST request is
the same as the URL for the GET request (localhost:xxxxx/Movies/Index) -- there's no search information in the
URL. The search string information is sent to the server as a form field value. You can verify that with the browser
Developer tools or the excellent Fiddler tool. The image below shows the Chrome browser Developer tools:
You can see the search parameter and XSRF token in the request body. Note, as mentioned in the previous tutorial,
the Form Tag Helper generates an XSRF anti-forgery token. We're not modifying data, so we don't need to validate
the token in the controller method.
Because the search parameter is in the request body and not the URL, you can't capture that search information to
bookmark or share with others. We'll fix this by specifying the request should be HTTP GET .
Notice how intelliSense helps us update the markup.
Notice the distinctive font in the <form> tag. That distinctive font indicates the tag is supported by Tag Helpers.

Now when you submit a search, the URL contains the search query string. Searching will also go to the
HttpGet Index action method, even if you have a HttpPost Index method.

The following markup shows the change to the form tag:

<form asp-controller="Movies" asp-action="Index" method="get">

Adding Search by genre

Add the following MovieGenreViewModel class to the Models folder:
 using Microsoft.AspNetCore.Mvc.Rendering;
using System.Collections.Generic;

namespace MvcMovie.Models
{
public class MovieGenreViewModel
{
public List<Movie> movies;
public SelectList genres;
public string movieGenre { get; set; }
}
}

The movie-genre view model will contain:

A list of movies.
A SelectList containing the list of genres. This will allow the user to select a genre from the list.
movieGenre , which contains the selected genre.

Replace the Index method in MoviesController.cs with the following code:

// Requires using Microsoft.AspNetCore.Mvc.Rendering;

public async Task<IActionResult> Index(string movieGenre, string searchString)
{
// Use LINQ to get list of genres.
IQueryable<string> genreQuery = from m in _context.Movie
orderby m.Genre
select m.Genre;

var movies = from m in _context.Movie

select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

if (!String.IsNullOrEmpty(movieGenre))
{
movies = movies.Where(x => x.Genre == movieGenre);
}

var movieGenreVM = new MovieGenreViewModel();

movieGenreVM.genres = new SelectList(await genreQuery.Distinct().ToListAsync());
movieGenreVM.movies = await movies.ToListAsync();

return View(movieGenreVM);
}

The following code is a LINQ query that retrieves all the genres from the database.

// Use LINQ to get list of genres.

IQueryable<string> genreQuery = from m in _context.Movie
orderby m.Genre
select m.Genre;

The SelectList of genres is created by projecting the distinct genres (we don't want our select list to have
duplicate genres).
 movieGenreVM.genres = new SelectList(await genreQuery.Distinct().ToListAsync())

Adding search by genre to the Index view

Update Index.cshtml as follows:
@model MvcMovie.Models.MovieGenreViewModel

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-action="Create">Create New</a>
</p>

<form asp-controller="Movies" asp-action="Index" method="get">

<p>
<select asp-for="movieGenre" asp-items="Model.genres">
<option value="">All</option>
</select>

Title: <input type="text" name="SearchString">

<input type="submit" value="Filter" />
</p>
</form>

<table class="table">
<thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.movies[0].Title)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].ReleaseDate)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Genre)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Price)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model.movies)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
<a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
<a asp-action="Details" asp-route-id="@item.ID">Details</a> |
<a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Examine the lambda expression used in the following HTML Helper:
@Html.DisplayNameFor(model => model.movies[0].Title)

In the preceding code, the DisplayNameFor HTML Helper inspects the Title property referenced in the lambda
expression to determine the display name. Since the lambda expression is inspected rather than evaluated, you
don't receive an access violation when model , model.movies , or model.movies[0] are null or empty. When the
lambda expression is evaluated (for example, @Html.DisplayFor(modelItem => item.Title) ), the model's property
values are evaluated.
Test the app by searching by genre, by movie title, and by both.

P R E V IO U S NEXT
 Adding a New Field
9/12/2017 3 min to read Edit Online

By Rick Anderson
In this section you'll use Entity Framework Code First Migrations to add a new field to the model and migrate that
change to the database.
When you use EF Code First to automatically create a database, Code First adds a table to the database to help
track whether the schema of the database is in sync with the model classes it was generated from. If they aren't in
sync, EF throws an exception. This makes it easier to find inconsistent database/code issues.

Adding a Rating Property to the Movie Model

Open the Models/Movie.cs file and add a Rating property:

public class Movie

{
public int ID { get; set; }
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
public string Rating { get; set; }
}

Build the app (Ctrl+Shift+B).

Because you've added a new field to the Movie class, you also need to update the binding white list so this new
property will be included. In MoviesController.cs, update the [Bind] attribute for both the Create and Edit
action methods to include the Rating property:

[Bind("ID,Title,ReleaseDate,Genre,Price,Rating")]

You also need to update the view templates in order to display, create and edit the new Rating property in the
browser view.
Edit the /Views/Movies/Index.cshtml file and add a Rating field:
 <table class="table">
<thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.movies[0].Title)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].ReleaseDate)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Genre)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Price)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Rating)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model.movies)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
@Html.DisplayFor(modelItem => item.Rating)
</td>
<td>

Update the /Views/Movies/Create.cshtml with a Rating field. You can copy/paste the previous "form group" and
let intelliSense help you update the fields. IntelliSense works with Tag Helpers. Note: In the RTM verison of Visual
Studio 2017 you need to install the Razor Language Services for Razor intelliSense. This will be fixed in the next
release.
The app won't work until we update the DB to include the new field. If you run it now, you'll get the following
SqlException :

SqlException: Invalid column name 'Rating'.

You're seeing this error because the updated Movie model class is different than the schema of the Movie table of
the existing database. (There's no Rating column in the database table.)
There are a few approaches to resolving the error:
1. Have the Entity Framework automatically drop and re-create the database based on the new model class
schema. This approach is very convenient early in the development cycle when you are doing active
development on a test database; it allows you to quickly evolve the model and database schema together.
The downside, though, is that you lose existing data in the database so you don't want to use this
approach on a production database! Using an initializer to automatically seed a database with test data is
often a productive way to develop an application.
2. Explicitly modify the schema of the existing database so that it matches the model classes. The advantage of
this approach is that you keep your data. You can make this change either manually or by creating a
database change script.
3. Use Code First Migrations to update the database schema.
For this tutorial, we'll use Code First Migrations.
Update the SeedData class so that it provides a value for the new column. A sample change is shown below, but
you'll want to make this change for each new Movie .

new Movie
{
Title = "When Harry Met Sally",
ReleaseDate = DateTime.Parse("1989-1-11"),
Genre = "Romantic Comedy",
Rating = "R",
Price = 7.99M
},

Build the solution.

From the Tools menu, select NuGet Package Manager > Package Manager Console.
In the PMC, enter the following commands:

Add-Migration Rating
Update-Database

The Add-Migration command tells the migration framework to examine the current Movie model with the current
Movie DB schema and create the necessary code to migrate the DB to the new model. The name "Rating" is
arbitrary and is used to name the migration file. It's helpful to use a meaningful name for the migration file.
If you delete all the records in the DB, the initialize will seed the DB and include the Rating field. You can do this
with the delete links in the browser or from SSOX.
Run the app and verify you can create/edit/display movies with a Rating field. You should also add the Rating
field to the Edit , Details , and Delete view templates.

P R E V IO U S NEXT
 Adding validation
9/22/2017 9 min to read Edit Online

By Rick Anderson
In this section you'll add validation logic to the Movie model, and you'll ensure that the validation rules are
enforced any time a user creates or edits a movie.

Keeping things DRY

One of the design tenets of MVC is DRY ("Don't Repeat Yourself"). ASP.NET MVC encourages you to specify
functionality or behavior only once, and then have it be reflected everywhere in an app. This reduces the amount
of code you need to write and makes the code you do write less error prone, easier to test, and easier to maintain.
The validation support provided by MVC and Entity Framework Core Code First is a good example of the DRY
principle in action. You can declaratively specify validation rules in one place (in the model class) and the rules are
enforced everywhere in the app.

Adding validation rules to the movie model

Open the Movie.cs file. DataAnnotations provides a built-in set of validation attributes that you apply declaratively
to any class or property. (It also contains formatting attributes like DataType that help with formatting and don't
provide any validation.)
Update the Movie class to take advantage of the built-in Required , StringLength , RegularExpression , and Range
validation attributes.

public class Movie

{
public int ID { get; set; }

[StringLength(60, MinimumLength = 3)]

[Required]
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }

[Range(1, 100)]
[DataType(DataType.Currency)]
public decimal Price { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$")]
[Required]
[StringLength(30)]
public string Genre { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$")]
[StringLength(5)]
[Required]
public string Rating { get; set; }
}

The validation attributes specify behavior that you want to enforce on the model properties they are applied to.
The Required and MinimumLength attributes indicates that a property must have a value; but nothing prevents a
user from entering white space to satisfy this validation. The RegularExpression attribute is used to limit what
characters can be input. In the code above, Genre and Rating must use only letters (white space, numbers and
special characters are not allowed). The Range attribute constrains a value to within a specified range. The
StringLength attribute lets you set the maximum length of a string property, and optionally its minimum length.
Value types (such as decimal , int , float , DateTime ) are inherently required and don't need the [Required]
attribute.
Having validation rules automatically enforced by ASP.NET helps make your app more robust. It also ensures that
you can't forget to validate something and inadvertently let bad data into the database.

Validation Error UI in MVC

Run the app and navigate to the Movies controller.
Tap the Create New link to add a new movie. Fill out the form with some invalid values. As soon as jQuery client
side validation detects the error, it displays an error message.
 NOTE
You may not be able to enter decimal commas in the Price field. To support jQuery validation for non-English locales that
use a comma (",") for a decimal point, and non US-English date formats, you must take steps to globalize your app. This
GitHub issue 4076 for instructions on adding decimal comma.

Notice how the form has automatically rendered an appropriate validation error message in each field containing
an invalid value. The errors are enforced both client-side (using JavaScript and jQuery) and server-side (in case a
user has JavaScript disabled).
A significant benefit is that you didn't need to change a single line of code in the MoviesController class or in the
Create.cshtml view in order to enable this validation UI. The controller and views you created earlier in this tutorial
automatically picked up the validation rules that you specified by using validation attributes on the properties of
the Movie model class. Test validation using the Edit action method, and the same validation is applied.
The form data is not sent to the server until there are no client side validation errors. You can verify this by putting
a break point in the HTTP Post method, by using the Fiddler tool , or the F12 Developer tools.

How validation works

You might wonder how the validation UI was generated without any updates to the code in the controller or views.
The following code shows the two Create methods.

// GET: Movies/Create
public IActionResult Create()
{
return View();
}

// POST: Movies/Create
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Create(
[Bind("ID,Title,ReleaseDate,Genre,Price, Rating")] Movie movie)
{
if (ModelState.IsValid)
{
_context.Add(movie);
await _context.SaveChangesAsync();
return RedirectToAction("Index");
}
return View(movie);
}

The first (HTTP GET) Create action method displays the initial Create form. The second ( [HttpPost] ) version
handles the form post. The second Create method (The [HttpPost] version) calls ModelState.IsValid to check
whether the movie has any validation errors. Calling this method evaluates any validation attributes that have
been applied to the object. If the object has validation errors, the Create method re-displays the form. If there are
no errors, the method saves the new movie in the database. In our movie example, the form is not posted to the
server when there are validation errors detected on the client side; the second Create method is never called
when there are client side validation errors. If you disable JavaScript in your browser, client validation is disabled
and you can test the HTTP POST Create method ModelState.IsValid detecting any validation errors.
You can set a break point in the [HttpPost] Create method and verify the method is never called, client side
validation will not submit the form data when validation errors are detected. If you disable JavaScript in your
browser, then submit the form with errors, the break point will be hit. You still get full validation without
JavaScript.
The following image shows how to disable JavaScript in the FireFox browser.

The following image shows how to disable JavaScript in the Chrome browser.

After you disable JavaScript, post invalid data and step through the debugger.
Below is portion of the Create.cshtml view template that you scaffolded earlier in the tutorial. It's used by the
action methods shown above both to display the initial form and to redisplay it in the event of an error.

<form asp-action="Create">
<div class="form-horizontal">
<h4>Movie</h4>
<hr />

<div asp-validation-summary="ModelOnly" class="text-danger"></div>

<div class="form-group">
<label asp-for="Title" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Title" class="form-control" />
<span asp-validation-for="Title" class="text-danger"></span>
</div>
</div>

@*Markup removed for brevity.*@

</div>
</form>

The Input Tag Helper uses the DataAnnotations attributes and produces HTML attributes needed for jQuery
Validation on the client side. The Validation Tag Helper displays validation errors. See Validation for more
information.
What's really nice about this approach is that neither the controller nor the Create view template knows anything
about the actual validation rules being enforced or about the specific error messages displayed. The validation
rules and the error strings are specified only in the Movie class. These same validation rules are automatically
applied to the Edit view and any other views templates you might create that edit your model.
When you need to change validation logic, you can do so in exactly one place by adding validation attributes to the
model (in this example, the Movie class). You won't have to worry about different parts of the application being
inconsistent with how the rules are enforced all validation logic will be defined in one place and used
everywhere. This keeps the code very clean, and makes it easy to maintain and evolve. And it means that you'll be
fully honoring the DRY principle.

Using DataType Attributes

Open the Movie.cs file and examine the Movie class. The System.ComponentModel.DataAnnotations namespace
provides formatting attributes in addition to the built-in set of validation attributes. We've already applied a
DataType enumeration value to the release date and to the price fields. The following code shows the ReleaseDate
and Price properties with the appropriate DataType attribute.
 [Display(Name = "Release Date")]
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }

[Range(1, 100)]
[DataType(DataType.Currency)]
public decimal Price { get; set; }

The DataType attributes only provide hints for the view engine to format the data (and supply attributes such as
<a> for URL's and <a href="mailto:EmailAddress.com"> for email. You can use the RegularExpression attribute to
validate the format of the data. The DataType attribute is used to specify a data type that is more specific than the
database intrinsic type, they are not validation attributes. In this case we only want to keep track of the date, not
the time. The DataType Enumeration provides for many data types, such as Date, Time, PhoneNumber, Currency,
EmailAddress and more. The DataType attribute can also enable the application to automatically provide type-
specific features. For example, a mailto: link can be created for DataType.EmailAddress , and a date selector can be
provided for DataType.Date in browsers that support HTML5. The DataType attributes emits HTML 5 data-
(pronounced data dash) attributes that HTML 5 browsers can understand. The DataType attributes do not provide
any validation.
DataType.Date does not specify the format of the date that is displayed. By default, the data field is displayed
according to the default formats based on the server's CultureInfo .
The DisplayFormat attribute is used to explicitly specify the date format:

[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

public DateTime ReleaseDate { get; set; }

The ApplyFormatInEditMode setting specifies that the formatting should also be applied when the value is displayed
in a text box for editing. (You might not want that for some fields for example, for currency values, you probably
do not want the currency symbol in the text box for editing.)
You can use the DisplayFormat attribute by itself, but it's generally a good idea to use the DataType attribute. The
DataType attribute conveys the semantics of the data as opposed to how to render it on a screen, and provides the
following benefits that you don't get with DisplayFormat:
The browser can enable HTML5 features (for example to show a calendar control, the locale-appropriate
currency symbol, email links, etc.)
By default, the browser will render data using the correct format based on your locale.
The DataType attribute can enable MVC to choose the right field template to render the data (the
DisplayFormat if used by itself uses the string template).

NOTE
jQuery validation does not work with the Range attribute and DateTime . For example, the following code will always
display a client side validation error, even when the date is in the specified range:

[Range(typeof(DateTime), "1/1/1966", "1/1/2020")]

You will need to disable jQuery date validation to use the Range attribute with DateTime . It's generally not a good
practice to compile hard dates in your models, so using the Range attribute and DateTime is discouraged.
The following code shows combining attributes on one line:
 public class Movie
{
public int ID { get; set; }

[StringLength(60, MinimumLength = 3)]

public string Title { get; set; }

[Display(Name = "Release Date"), DataType(DataType.Date)]

public DateTime ReleaseDate { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$"), Required, StringLength(30)]

public string Genre { get; set; }

[Range(1, 100), DataType(DataType.Currency)]

public decimal Price { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$"), StringLength(5)]
public string Rating { get; set; }
}

In the next part of the series, we'll review the application and make some improvements to the automatically
generated Details and Delete methods.

Additional resources
Working with Forms
Globalization and localization
Introduction to Tag Helpers
Authoring Tag Helpers

P R E V IO U S NEXT
 Examining the Details and Delete methods
7/5/2017 3 min to read Edit Online

By Rick Anderson
Open the Movie controller and examine the Details method:

// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie

.SingleOrDefaultAsync(m => m.ID == id);
if (movie == null)
{
return NotFound();
}

return View(movie);
}

The MVC scaffolding engine that created this action method adds a comment showing an HTTP request that
invokes the method. In this case it's a GET request with three URL segments, the Movies controller, the Details
method and an id value. Recall these segments are defined in Startup.cs.

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

EF makes it easy to search for data using the SingleOrDefaultAsync method. An important security feature built into
the method is that the code verifies that the search method has found a movie before it tries to do anything with it.
For example, a hacker could introduce errors into the site by changing the URL created by the links from
http://localhost:xxxx/Movies/Details/1 to something like http://localhost:xxxx/Movies/Details/12345 (or some
other value that doesn't represent an actual movie). If you did not check for a null movie, the app would throw an
exception.
Examine the Delete and DeleteConfirmed methods.
 // GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie

.SingleOrDefaultAsync(m => m.ID == id);
if (movie == null)
{
return NotFound();
}

return View(movie);
}

// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var movie = await _context.Movie.SingleOrDefaultAsync(m => m.ID == id);
_context.Movie.Remove(movie);
await _context.SaveChangesAsync();
return RedirectToAction("Index");
}

Note that the HTTP GET Delete method doesn't delete the specified movie, it returns a view of the movie where you
can submit (HttpPost) the deletion. Performing a delete operation in response to a GET request (or for that matter,
performing an edit operation, create operation, or any other operation that changes data) opens up a security hole.
The [HttpPost] method that deletes the data is named DeleteConfirmed to give the HTTP POST method a unique
signature or name. The two method signatures are shown below:

// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{

// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{

The common language runtime (CLR) requires overloaded methods to have a unique parameter signature (same
method name but different list of parameters). However, here you need two Delete methods -- one for GET and
one for POST -- that both have the same parameter signature. (They both need to accept a single integer as a
parameter.)
There are two approaches to this problem, one is to give the methods different names. That's what the scaffolding
mechanism did in the preceding example. However, this introduces a small problem: ASP.NET maps segments of a
URL to action methods by name, and if you rename a method, routing normally wouldn't be able to find that
method. The solution is what you see in the example, which is to add the ActionName("Delete") attribute to the
DeleteConfirmed method. That attribute performs mapping for the routing system so that a URL that includes
/Delete/ for a POST request will find the DeleteConfirmed method.
Another common work around for methods that have identical names and signatures is to artificially change the
signature of the POST method to include an extra (unused) parameter. That's what we did in a previous post when
we added the notUsed parameter. You could do the same thing here for the [HttpPost] Delete method:

// POST: Movies/Delete/6
[ValidateAntiForgeryToken]
public async Task<IActionResult> Delete(int id, bool notUsed)

Thanks for completing this introduction to ASP.NET Core MVC. We appreciate any comments you leave. Getting
started with MVC and EF Core is an excellent follow up to this tutorial.

P R E V IO U S
 Create a web app with ASP.NET Core MVC using
Visual Studio for Mac
9/22/2017 1 min to read Edit Online

This series of tutorials teaches you the basics of building an ASP.NET Core MVC web app using Visual Studio for
Mac.
This tutorial teaches ASP.NET Core MVC with controllers and views. Razor Pages is a new alternative in ASP.NET
Core 2.0, a page-based programming model that makes building web UI easier and more productive. We
recommend you try the Razor Pages tutorial before the MVC version. For a Razor Pages version of this tutorial, see
Razor Pages.
1. Getting started
2. Adding a controller
3. Adding a view
4. Adding a model
5. SQLite
6. Controller methods and views
7. Adding Search
8. Adding a New Field
9. Adding Validation
10. Examining the Details and Delete methods
 Getting started with ASP.NET Core MVC and Visual
Studio for Mac
9/12/2017 1 min to read Edit Online

By Rick Anderson
This tutorial teaches you the basics of building an ASP.NET Core MVC web app using Visual Studio for Mac. This
tutorial teaches ASP.NET Core MVC with controllers and views. Razor Pages is a new alternative in ASP.NET Core
2.0, a page-based programming model that makes building web UI easier and more productive. We recommend
you try the Razor Pages tutorial before the MVC version. For a Razor Pages version of this tutorial, see Razor
Pages.
There are 3 versions of this tutorial:
macOS: Build an ASP.NET Core MVC app with Visual Studio for Mac
Windows: Build an ASP.NET Core MVC app with Visual Studio
Linux, macOS, and Windows: Build an ASP.NET Core MVC app with Visual Studio Code

Prerequisites
This tutorial requires the .NET Core 2.0.0 SDK or later. See the pdf for the ASP.NET Core 1.1 version.
Install the following:
.NET Core 2.0.0 SDK or later
Visual Studio for Mac

Create a web app

From Visual Studio, select File > New Solution.
Select .NET Core App > ASP.NET Core > Web App > Next.

Name the project MvcMovie, and then select Create.

Launch the app
In Visual Studio, select Run > Start Without Debugging to launch the app. Visual Studio starts IIS Express,
launches a browser, and navigates to http://localhost:port , where port is a randomly chosen port number.

The address bar shows localhost:port# and not something like example.com . That's because localhost is the
 standard hostname for your local computer. When Visual Studio creates a web project, a random port is used
for the web server. When you run the app, you'll see a different port number.
You can launch the app in debug or non-debug mode from the Run menu.
The default template gives you Home, About and Contact links. The browser image above doesn't show these
links. Depending on the size of your browser, you might need to click the navigation icon to show them.

In the next part of this tutorial, you learn about MVC and start writing some code.

NEXT
 Adding a controller to an ASP.NET Core MVC app
with Visual Studio for Mac
9/22/2017 5 min to read Edit Online

By Rick Anderson
The Model-View-Controller (MVC) architectural pattern separates an app into three main components: Model,
View, and Controller. The MVC pattern helps you create apps that are more testable and easier to update than
traditional monolithic apps. MVC-based apps contain:
Models: Classes that represent the data of the app. The model classes use validation logic to enforce
business rules for that data. Typically, model objects retrieve and store model state in a database. In this
tutorial, a Movie model retrieves movie data from a database, provides it to the view or updates it. Updated
data is written to a database.
Views: Views are the components that display the app's user interface (UI). Generally, this UI displays the
model data.
Controllers: Classes that handle browser requests. They retrieve model data and call view templates that
return a response. In an MVC app, the view only displays information; the controller handles and responds
to user input and interaction. For example, the controller handles route data and query-string values, and
passes these values to the model. The model might use these values to query the database. For example,
http://localhost:1234/Home/About has route data of Home (the controller) and About (the action method to
call on the home controller). http://localhost:1234/Movies/Edit/5 is a request to edit the movie with ID=5
using the movie controller. We'll talk about route data later in the tutorial.
The MVC pattern helps you create apps that separate the different aspects of the app (input logic, business logic,
and UI logic), while providing a loose coupling between these elements. The pattern specifies where each kind of
logic should be located in the app. The UI logic belongs in the view. Input logic belongs in the controller. Business
logic belongs in the model. This separation helps you manage complexity when you build an app, because it
enables you to work on one aspect of the implementation at a time without impacting the code of another. For
example, you can work on the view code without depending on the business logic code.
We cover these concepts in this tutorial series and show you how to use them to build a movie app. The MVC
project contains folders for the Controllers and Views. A Models folder will be added in a later step.

Add a controller
In Solution Explorer, right-click Controllers > Add > New File.
Select ASP.NET Core and MVC Controller Class.
Name the controller HelloWorldController.

Replace the contents of Controllers/HelloWorldController.cs with the following:

 using Microsoft.AspNetCore.Mvc;
using System.Text.Encodings.Web;

namespace MvcMovie.Controllers
{
public class HelloWorldController : Controller
{
//
// GET: /HelloWorld/

public string Index()

{
return "This is my default action...";
}

//
// GET: /HelloWorld/Welcome/

public string Welcome()

{
return "This is the Welcome action method...";
}
}
}

Every public method in a controller is callable as an HTTP endpoint. In the sample above, both methods return a
string. Note the comments preceding each method.
An HTTP endpoint is a targetable URL in the web application, such as http://localhost:1234/HelloWorld , and
combines the protocol used: HTTP , the network location of the web server (including the TCP port):
localhost:1234 and the target URI HelloWorld .

The first comment states this is an HTTP GET method that is invoked by appending "/HelloWorld/" to the base URL.
The second comment specifies an HTTP GET method that is invoked by appending "/HelloWorld/Welcome/" to the
URL. Later on in the tutorial you'll use the scaffolding engine to generate HTTP POST methods.
Run the app in non-debug mode and append "HelloWorld" to the path in the address bar. The Index method
returns a string.

MVC invokes controller classes (and the action methods within them) depending on the incoming URL. The default
URL routing logic used by MVC uses a format like this to determine what code to invoke:
/[Controller]/[ActionName]/[Parameters]

You set the format for routing in the Startup.cs file.

 app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

When you run the app and don't supply any URL segments, it defaults to the "Home" controller and the "Index"
method specified in the template line highlighted above.
The first URL segment determines the controller class to run. So localhost:xxxx/HelloWorld maps to the
HelloWorldController class. The second part of the URL segment determines the action method on the class. So
localhost:xxxx/HelloWorld/Index would cause the Index method of the HelloWorldController class to run. Notice
that you only had to browse to localhost:xxxx/HelloWorld and the Index method was called by default. This is
because Index is the default method that will be called on a controller if a method name is not explicitly specified.
The third part of the URL segment ( id ) is for route data. You'll see route data later on in this tutorial.
Browse to http://localhost:xxxx/HelloWorld/Welcome . The Welcome method runs and returns the string "This is the
Welcome action method...". For this URL, the controller is HelloWorld and Welcome is the action method. You
haven't used the [Parameters] part of the URL yet.

Modify the code to pass some parameter information from the URL to the controller. For example,
/HelloWorld/Welcome?name=Rick&numtimes=4 . Change the Welcome method to include two parameters as shown in
the following code.

// GET: /HelloWorld/Welcome/
// Requires using System.Text.Encodings.Web;
public string Welcome(string name, int numTimes = 1)
{
return HtmlEncoder.Default.Encode($"Hello {name}, NumTimes is: {numTimes}");
}

The preceding code:

Uses the C# optional-parameter feature to indicate that the numTimes parameter defaults to 1 if no value is
passed for that parameter.
Uses HtmlEncoder.Default.Encode to protect the app from malicious input (namely JavaScript).
Uses Interpolated Strings.
Run your app and browse to:
http://localhost:xxxx/HelloWorld/Welcome?name=Rick&numtimes=4

(Replace xxxx with your port number.) You can try different values for name and numtimes in the URL. The MVC
model binding system automatically maps the named parameters from the query string in the address bar to
parameters in your method. See Model Binding for more information.

In the image above, the URL segment ( Parameters ) is not used, the name and numTimes parameters are passed as
query strings. The ? (question mark) in the above URL is a separator, and the query strings follow. The &
character separates query strings.
Replace the Welcome method with the following code:

public string Welcome(string name, int ID = 1)

{
return HtmlEncoder.Default.Encode($"Hello {name}, ID: {ID}");
}

Run the app and enter the following URL: http://localhost:xxx/HelloWorld/Welcome/3?name=Rick

This time the third URL segment matched the route parameter id . The Welcome method contains a parameter
id that matched the URL template in the MapRoute method. The trailing ? (in id? ) indicates the id parameter
is optional.

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

In these examples the controller has been doing the "VC" portion of MVC - that is, the view and controller work.
The controller is returning HTML directly. Generally you don't want controllers returning HTML directly, since that
becomes very cumbersome to code and maintain. Instead you typically use a separate Razor view template file to
help generate the HTML response. You do that in the next tutorial.

P R E V IO U S NEXT
 Adding a view to an ASP.NET Core MVC app
9/20/2017 8 min to read Edit Online

By Rick Anderson
In this section you modify the HelloWorldController class to use Razor view template files to cleanly encapsulate
the process of generating HTML responses to a client.
You create a view template file using Razor. Razor-based view templates have a .cshtml file extension. They provide
an elegant way to create HTML output using C#.
Currently the method returns a string with a message that is hard-coded in the controller class. In the
Index
HelloWorldController class, replace the Index method with the following code:

public IActionResult Index()

{
return View();
}

The preceding code returns a View object. It uses a view template to generate an HTML response to the browser.
Controller methods (also known as action methods) such as the Index method above, generally return an
IActionResult (or a class derived from ActionResult ), not primitive types like string.

Add a view
Right click on the Views folder, and then Add > New Folder and name the folder HelloWorld.
Right click on the Views/HelloWorld folder, and then Add > New File.
In the New File dialog:
Select Web in the left pane.
Select Empty HTML file in the center pane.
Type Index.cshtml in the Name box.
Select New.

Replace the contents of the Views/HelloWorld/Index.cshtml Razor view file with the following:
 @{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>Hello from our View Template!</p>

Navigate to http://localhost:xxxx/HelloWorld . The Index method in the HelloWorldController didn't do much; it

ran the statement return View(); , which specified that the method should use a view template file to render a
response to the browser. Because you didn't explicitly specify the name of the view template file, MVC defaulted to
using the Index.cshtml view file in the /Views/HelloWorld folder. The image below shows the string "Hello from our
View Template!" hard-coded in the view.

If your browser window is small (for example on a mobile device), you might need to toggle (tap) the Bootstrap
navigation button in the upper right to see the Home, About, and Contact links.

Changing views and layout pages

Tap the menu links (MvcMovie, Home, About). Each page shows the same menu layout. The menu layout is
implemented in the Views/Shared/_Layout.cshtml file. Open the Views/Shared/_Layout.cshtml file.
Layout templates allow you to specify the HTML container layout of your site in one place and then apply it across
multiple pages in your site. Find the @RenderBody() line. RenderBody is a placeholder where all the view-specific
pages you create show up, wrapped in the layout page. For example, if you select the About link, the
Views/Home/About.cshtml view is rendered inside the RenderBody method.

Change the title and menu link in the layout file

Change the contents of the title element. Change the anchor text in the layout template to "Movie App" and the
controller from Home to Movies as highlighted below:
Note: The ASP.NET Core 2.0 version is slightly different. It doesn't contain @inject ApplicationInsights and
@Html.Raw(JavaScriptSnippet.FullScript) .

@inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>@ViewData["Title"] - Movie App</title>

<environment names="Development">
<link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.css" />
<link rel="stylesheet" href="~/css/site.css" />
</environment>
<environment names="Staging,Production">
<link rel="stylesheet" href="https://ajax.aspnetcdn.com/ajax/bootstrap/3.3.7/css/bootstrap.min.css"
asp-fallback-href="~/lib/bootstrap/dist/css/bootstrap.min.css"
asp-fallback-test-class="sr-only" asp-fallback-test-property="position" asp-fallback-test-
value="absolute" />
<link rel="stylesheet" href="~/css/site.min.css" asp-append-version="true" />
</environment>
@Html.Raw(JavaScriptSnippet.FullScript)
</head>
<body>
<nav class="navbar navbar-inverse navbar-fixed-top">
<div class="container">
<div class="navbar-header">
<button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-
collapse">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a asp-area="" asp-controller="Movies" asp-action="Index" class="navbar-brand">MvcMovie</a>
</div>
<div class="navbar-collapse collapse">
<ul class="nav navbar-nav">
<li><a asp-area="" asp-controller="Home" asp-action="Index">Home</a></li>
<li><a asp-area="" asp-controller="Home" asp-action="About">About</a></li>
<li><a asp-area="" asp-controller="Home" asp-action="Contact">Contact</a></li>
</ul>
</div>
</div>
</nav>
<div class="container body-content">
@RenderBody()
<hr />
<footer>
<p>&copy; 2017 - MvcMovie</p>
</footer>
</div>

<environment names="Development">
<script src="~/lib/jquery/dist/jquery.js"></script>
<script src="~/lib/bootstrap/dist/js/bootstrap.js"></script>
 <script src="~/lib/bootstrap/dist/js/bootstrap.js"></script>
<script src="~/js/site.js" asp-append-version="true"></script>
</environment>
<environment names="Staging,Production">
<script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-2.2.0.min.js"
asp-fallback-src="~/lib/jquery/dist/jquery.min.js"
asp-fallback-test="window.jQuery"
crossorigin="anonymous"
integrity="sha384-K+ctZQ+LL8q6tP7I94W+qzQsfRV2a+AfHIi9k8z8l9ggpc8X+Ytst4yBo/hH+8Fk">
</script>
<script src="https://ajax.aspnetcdn.com/ajax/bootstrap/3.3.7/bootstrap.min.js"
asp-fallback-src="~/lib/bootstrap/dist/js/bootstrap.min.js"
asp-fallback-test="window.jQuery && window.jQuery.fn && window.jQuery.fn.modal"
crossorigin="anonymous"
integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa">
</script>
<script src="~/js/site.min.js" asp-append-version="true"></script>
</environment>

@RenderSection("Scripts", required: false)

</body>
</html>

WARNING
We haven't implemented the Movies controller yet, so if you click on that link, you'll get a 404 (Not found) error.

Save your changes and tap the About link. Notice how the title on the browser tab now displays About - Movie
App instead of About - Mvc Movie. Tap the Contact link and notice that it also displays Movie App. We were
able to make the change once in the layout template and have all pages on the site reflect the new link text and
new title.
Examine the Views/_ViewStart.cshtml file:

@{
Layout = "_Layout";
}

The Views/_ViewStart.cshtml file brings in the Views/Shared/_Layout.cshtml file to each view. You can use the
Layout property to set a different layout view, or set it to null so no layout file will be used.

Change the title of the Index view.

Open Views/HelloWorld/Index.cshtml. There are two places to make a change:
The text that appears in the title of the browser.
The secondary header ( <h2> element).

You'll make them slightly different so you can see which bit of code changes which part of the app.

@{
ViewData["Title"] = "Movie List";
}

<h2>My Movie List</h2>

<p>Hello from our View Template!</p>

ViewData["Title"] = "Movie List"; in the code above sets the Title property of the ViewData dictionary to
"Movie List". The Title property is used in the <title> HTML element in the layout page:

<title>@ViewData["Title"] - Movie App</title>

Save your change and navigate to http://localhost:xxxx/HelloWorld . Notice that the browser title, the primary
heading, and the secondary headings have changed. (If you don't see changes in the browser, you might be
viewing cached content. Press Ctrl+F5 in your browser to force the response from the server to be loaded.) The
browser title is created with ViewData["Title"] we set in the Index.cshtml view template and the additional "-
Movie App" added in the layout file.
Also notice how the content in the Index.cshtml view template was merged with the Views/Shared/_Layout.cshtml
view template and a single HTML response was sent to the browser. Layout templates make it really easy to make
changes that apply across all of the pages in your application. To learn more see Layout.

Our little bit of "data" (in this case the "Hello from our View Template!" message) is hard-coded, though. The MVC
application has a "V" (view) and you've got a "C" (controller), but no "M" (model) yet.

Passing Data from the Controller to the View

Controller actions are invoked in response to an incoming URL request. A controller class is where you write the
code that handles the incoming browser requests. The controller retrieves data from a data source and decides
what type of response to send back to the browser. View templates can be used from a controller to generate and
format an HTML response to the browser.
Controllers are responsible for providing the data required in order for a view template to render a response. A
best practice: View templates should not perform business logic or interact with a database directly. Rather, a view
template should work only with the data that's provided to it by the controller. Maintaining this "separation of
concerns" helps keep your code clean, testable, and maintainable.
Currently, the Welcome method in the HelloWorldController class takes a name and a ID parameter and then
outputs the values directly to the browser. Rather than have the controller render this response as a string, lets
change the controller to use a view template instead. The view template will generate a dynamic response, which
means that you need to pass appropriate bits of data from the controller to the view in order to generate the
response. You can do this by having the controller put the dynamic data (parameters) that the view template needs
in a ViewData dictionary that the view template can then access.
Return to the HelloWorldController.cs file and change the Welcome method to add a Message and NumTimes value
to the ViewData dictionary. The ViewData dictionary is a dynamic object, which means you can put whatever you
want in to it; the ViewData object has no defined properties until you put something inside it. The MVC model
binding system automatically maps the named parameters ( name and numTimes ) from the query string in the
address bar to parameters in your method. The complete HelloWorldController.cs file looks like this:

using Microsoft.AspNetCore.Mvc;
using System.Text.Encodings.Web;

namespace MvcMovie.Controllers
{
public class HelloWorldController : Controller
{
public IActionResult Index()
{
return View();
}

public IActionResult Welcome(string name, int numTimes = 1)

{
ViewData["Message"] = "Hello " + name;
ViewData["NumTimes"] = numTimes;

return View();
}
}
}

The ViewData dictionary object contains data that will be passed to the view.
Create a Welcome view template named Views/HelloWorld/Welcome.cshtml.
You'll create a loop in the Welcome.cshtml view template that displays "Hello" NumTimes . Replace the contents of
Views/HelloWorld/Welcome.cshtml with the following:

@{
ViewData["Title"] = "Welcome";
}

<h2>Welcome</h2>

<ul>
@for (int i = 0; i < (int)ViewData["NumTimes"]; i++)
{
<li>@ViewData["Message"]</li>
}
</ul>

Save your changes and browse to the following URL:

http://localhost:xxxx/HelloWorld/Welcome?name=Rick&numtimes=4

Data is taken from the URL and passed to the controller using the MVC model binder . The controller packages the
data into a ViewData dictionary and passes that object to the view. The view then renders the data as HTML to the
browser.
In the sample above, we used the ViewData dictionary to pass data from the controller to a view. Later in the
tutorial, we will use a view model to pass data from a controller to a view. The view model approach to passing
data is generally much preferred over the ViewData dictionary approach. See ViewModel vs ViewData vs ViewBag
vs TempData vs Session in MVC for more information.
Well, that was a kind of an "M" for model, but not the database kind. Let's take what we've learned and create a
database of movies.

P R E V IO U S NEXT
 Adding a model to an ASP.NET Core MVC app
9/22/2017 5 min to read Edit Online

By Rick Anderson and Tom Dykstra

In this section, you'll add some classes for managing movies in a database. These classes will be the "Model" part
of the MVC app.
You use these classes with Entity Framework Core (EF Core) to work with a database. EF Core is an object-
relational mapping (ORM) framework that simplifies the data access code that you have to write. EF Core supports
many database engines.
The model classes you'll create are known as POCO classes (from "plain-old CLR objects") because they don't have
any dependency on EF Core. They just define the properties of the data that will be stored in the database.
In this tutorial you'll write the model classes first, and EF Core will create the database. An alternate approach not
covered here is to generate model classes from an already-existing database. For information about that approach,
see ASP.NET Core - Existing Database.

Add a data model class

Right-click the Models folder, and then select Add > New File.
In the New File dialog:
Select General in the left pane.
Select Empty Class in the center pain.
Name the class Movie and select New.
Add the following properties to the Movie class:

using System;

namespace MvcMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

The ID field is required by the database for the primary key.

Build the project to verify you don't have any errors. You now have a Model in your MVC app.

Prepare the project for scaffolding

Right click on the project file, and then select Tools > Edit File.
Add the following highlighted NuGet packages to the MvcMovie.csproj file:

<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.0" />
<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.0.0" />
</ItemGroup>
<ItemGroup>
<DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
<DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.0"
/>
</ItemGroup>
</Project>

Save the file.

Create a Models/MvcMovieContext.cs file and add the following MvcMovieContext class:

using Microsoft.EntityFrameworkCore;

namespace MvcMovie.Models
{
public class MvcMovieContext : DbContext
{
public MvcMovieContext (DbContextOptions<MvcMovieContext> options)
: base(options)
{
}

public DbSet<MvcMovie.Models.Movie> Movie { get; set; }

}
}
 Open the Startup.cs file and add two usings:

using Microsoft.EntityFrameworkCore;
using MvcMovie.Models;

namespace MvcMovie
{
public class Startup
{

Add the database context to the Startup.cs file:

public void ConfigureServices(IServiceCollection services)

{
// Add framework services.
services.AddMvc();

services.AddDbContext<MvcMovieContext>(options =>
options.UseSqlite("Data Source=MvcMovie.db"));

This tells Entity Framework which model classes are included in the data model. You're defining one entity
set of Movie objects, which will be represented in the database as a Movie table.
Build the project to verify there are no errors.

Scaffold the MovieController

Open a terminal window in the project folder and run the following commands:

dotnet restore
dotnet aspnet-codegenerator controller -name MoviesController -m Movie -dc MvcMovieContext --
relativeFolderPath Controllers --useDefaultLayout --referenceScriptLibraries

If you get the error No executable found matching command "dotnet-aspnet-codegenerator", verify :
You are in the project directory. The project directory has the Program.cs, Startup.cs and .csproj files.
Your dotnet version is 1.1 or higher. Run dotnet to get the version.
You have added the <DotNetCliToolReference> elment to the MvcMovie.csproj file.

The scaffolding engine creates the following:

A movies controller (Controllers/MoviesController.cs)
Razor view files for Create, Delete, Details, Edit and Index pages (Views/Movies/\.cshtml*)
The automatic creation of CRUD (create, read, update, and delete) action methods and views is known as
scaffolding. You'll soon have a fully functional web application that lets you manage a movie database.
Add the files to Visual Studio
Add the MovieController.cs file to the Visual Studio project:
Right-click on the Controllers folder and select Add > Add Files.
Select the MovieController.cs file.
Add the Movies folder and views:
Right-click on the Views folder and select Add > Add Existing Folder.
 Navigate to the Views folder, select Views\Movies, and then select Open.
In the Select files to add from Movies dialog, select Include All, and then OK.

Perform initial migration

From the command line, run the following .NET Core CLI commands:

dotnet ef migrations add InitialCreate

dotnet ef database update

The dotnet ef migrations add InitialCreate command generates code to create the initial database schema. The
schema is based on the model specified in the DbContext (In the Models/MovieContext.cs file). The Initial
argument is used to name the migrations. You can use any name, but by convention you choose a name that
describes the migration. See Introduction to migrations for more information.
The dotnet ef database update command runs the Up method in the Migrations/<time-stamp>_InitialCreate.cs
file, which creates the database.

Test the app

Run the app and tap the Mvc Movie link.
Tap the Create New link and create a movie.
 You may not be able to enter decimal points or commas in the Price field. To support jQuery validation for
non-English locales that use a comma (",") for a decimal point, and non US-English date formats, you must
take steps to globalize your app. See https://github.com/aspnet/Docs/issues/4076 and Additional resources
for more information. For now, just enter whole numbers like 10.
In some locales you need to specify the date format. See the highlighted code below.

using System;
using System.ComponentModel.DataAnnotations;

namespace MvcMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

We'll talk about DataAnnotations later in the tutorial.

Tapping Create causes the form to be posted to the server, where the movie information is saved in a database.
The app redirects to the /Movies URL, where the newly created movie information is displayed.

Create a couple more movie entries. Try the Edit, Details, and Delete links, which are all functional.
You now have a database and pages to display, edit, update and delete data. In the next tutorial, we'll work with the
database.

Additional resources
Tag Helpers
Globalization and localization
P R E V IO U S A D D IN G A N E X T W O R K IN G W IT H
V IE W SQL
 Working with SQLite in an ASP.NET Core MVC
project
9/22/2017 2 min to read Edit Online

By Rick Anderson
The MvcMovieContext object handles the task of connecting to the database and mapping Movie objects to
database records. The database context is registered with the Dependency Injection container in the
ConfigureServices method in the Startup.cs file:

public void ConfigureServices(IServiceCollection services)

{
// Add framework services.
services.AddMvc();

services.AddDbContext<MvcMovieContext>(options =>
options.UseSqlite("Data Source=MvcMovie.db"));

SQLite
The SQLite website states:

SQLite is a self-contained, high-reliability, embedded, full-featured, public-domain, SQL database engine.

SQLite is the most used database engine in the world.

There are many third party tools you can download to manage and view a SQLite database. The image below is
from DB Browser for SQLite. If you have a favorite SQLite tool, leave a comment on what you like about it.
Seed the database
Create a new class named SeedData in the Models folder. Replace the generated code with the following:
 using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Linq;

namespace MvcMovie.Models
{
public static class SeedData
{
public static void Initialize(IServiceProvider serviceProvider)
{
using (var context = new MvcMovieContext(
serviceProvider.GetRequiredService<DbContextOptions<MvcMovieContext>>()))
{
// Look for any movies.
if (context.Movie.Any())
{
return; // DB has been seeded
}

context.Movie.AddRange(
new Movie
{
Title = "When Harry Met Sally",
ReleaseDate = DateTime.Parse("1989-1-11"),
Genre = "Romantic Comedy",
Price = 7.99M
},

new Movie
{
Title = "Ghostbusters ",
ReleaseDate = DateTime.Parse("1984-3-13"),
Genre = "Comedy",
Price = 8.99M
},

new Movie
{
Title = "Ghostbusters 2",
ReleaseDate = DateTime.Parse("1986-2-23"),
Genre = "Comedy",
Price = 9.99M
},

new Movie
{
Title = "Rio Bravo",
ReleaseDate = DateTime.Parse("1959-4-15"),
Genre = "Western",
Price = 3.99M
}
);
context.SaveChanges();
}
}
}
}

If there are any movies in the DB, the seed initializer returns.
 if (context.Movie.Any())
{
return; // DB has been seeded.
}

Add the seed initializer

Add the seed initializer to the Main method in the Program.cs file:

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using MvcMovie.Models;
using System;

namespace MvcMovie
{
public class Program
{
public static void Main(string[] args)
{
var host = BuildWebHost(args);

using (var scope = host.Services.CreateScope())

{
var services = scope.ServiceProvider;

try
{
// Requires using RazorPagesMovie.Models;
SeedData.Initialize(services);
}
catch (Exception ex)
{
var logger = services.GetRequiredService<ILogger<Program>>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}

host.Run();
}

public static IWebHost BuildWebHost(string[] args) =>

WebHost.CreateDefaultBuilder(args)
.UseStartup<Startup>()
.Build();
}
}

Test the app

Delete all the records in the DB (So the seed method will run). Stop and start the app to seed the database.
The app shows the seeded data.
P R E V IO U S - A D D A N E X T - C ON TROL L E R M E THOD S A N D
M ODEL V IE W S
 Controller methods and views in an ASP.NET Core
MVC app
6/24/2017 8 min to read Edit Online

By Rick Anderson
We have a good start to the movie app, but the presentation is not ideal. We don't want to see the time (12:00:00
AM in the following image) and ReleaseDate should be two words.

Open the Models/Movie.cs file and add the highlighted lines shown below:

using System;
using System.ComponentModel.DataAnnotations;

namespace MvcMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

Build and run the app.

We'll cover DataAnnotations in the next tutorial. The Display attribute specifies what to display for the name of a
field (in this case "Release Date" instead of "ReleaseDate"). The DataType attribute specifies the type of the data
(Date), so the time information stored in the field is not displayed.
Browse to the Movies controller and hold the mouse pointer over an Edit link to see the target URL.

The Edit, Details, and Delete links are generated by the MVC Core Anchor Tag Helper in the
Views/Movies/Index.cshtml file.

<a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |

<a asp-action="Details" asp-route-id="@item.ID">Details</a> |
<a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>

Tag Helpers enable server-side code to participate in creating and rendering HTML elements in Razor files. In the
code above, the AnchorTagHelper dynamically generates the HTML href attribute value from the controller action
method and route id. You use View Source from your favorite browser or use the developer tools to examine the
generated markup. A portion of the generated HTML is shown below:

<td>
<a href="/Movies/Edit/4"> Edit </a> |
<a href="/Movies/Details/4"> Details </a> |
<a href="/Movies/Delete/4"> Delete </a>
</td>

Recall the format for routing set in the Startup.cs file:

 app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

ASP.NET Core translates http://localhost:1234/Movies/Edit/4 into a request to the Edit action method of the
Movies controller with the parameter Id of 4. (Controller methods are also known as action methods.)

Tag Helpers are one of the most popular new features in ASP.NET Core. See Additional resources for more
information.
Open the Movies controller and examine the two Edit action methods. The following code shows the
HTTP GET Edit method, which fetches the movie and populates the edit form generated by the Edit.cshtml Razor
file.

// GET: Movies/Edit/5
public async Task<IActionResult> Edit(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie.SingleOrDefaultAsync(m => m.ID == id);

if (movie == null)
{
return NotFound();
}
return View(movie);
}

The following code shows the HTTP POST Edit method, which processes the posted movie values:
 // POST: Movies/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("ID,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (id != movie.ID)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.ID))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction("Index");
}
return View(movie);
}

The [Bind] attribute is one way to protect against over-posting. You should only include properties in the [Bind]
attribute that you want to change. See Protect your controller from over-posting for more information.
ViewModels provide an alternative approach to prevent over-posting.
Notice the second Edit action method is preceded by the [HttpPost] attribute.
 // POST: Movies/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("ID,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (id != movie.ID)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.ID))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction("Index");
}
return View(movie);
}

The HttpPost attribute specifies that this Edit method can be invoked only for POST requests. You could apply
the [HttpGet] attribute to the first edit method, but that's not necessary because [HttpGet] is the default.

The ValidateAntiForgeryToken attribute is used to prevent forgery of a request and is paired up with an anti-
forgery token generated in the edit view file (Views/Movies/Edit.cshtml). The edit view file generates the anti-
forgery token with the Form Tag Helper.

<form asp-action="Edit">

The Form Tag Helper generates a hidden anti-forgery token that must match the [ValidateAntiForgeryToken]
generated anti-forgery token in the Edit method of the Movies controller. For more information, see Anti-
Request Forgery.
The method takes the movie ID parameter, looks up the movie using the Entity Framework
HttpGet Edit
SingleOrDefaultAsync method, and returns the selected movie to the Edit view. If a movie cannot be found,
NotFound (HTTP 404) is returned.
 // GET: Movies/Edit/5
public async Task<IActionResult> Edit(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie.SingleOrDefaultAsync(m => m.ID == id);

if (movie == null)
{
return NotFound();
}
return View(movie);
}

When the scaffolding system created the Edit view, it examined the Movie class and created code to render
<label> and <input> elements for each property of the class. The following example shows the Edit view that
was generated by the Visual Studio scaffolding system:
 @model MvcMovie.Models.Movie

@{
ViewData["Title"] = "Edit";
}

<h2>Edit</h2>

<form asp-action="Edit">
<div class="form-horizontal">
<h4>Movie</h4>
<hr />
<div asp-validation-summary="ModelOnly" class="text-danger"></div>
<input type="hidden" asp-for="ID" />
<div class="form-group">
<label asp-for="Title" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Title" class="form-control" />
<span asp-validation-for="Title" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<label asp-for="ReleaseDate" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="ReleaseDate" class="form-control" />
<span asp-validation-for="ReleaseDate" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<label asp-for="Genre" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Genre" class="form-control" />
<span asp-validation-for="Genre" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<label asp-for="Price" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Price" class="form-control" />
<span asp-validation-for="Price" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<div class="col-md-offset-2 col-md-10">
<input type="submit" value="Save" class="btn btn-default" />
</div>
</div>
</div>
</form>

<div>
<a asp-action="Index">Back to List</a>
</div>

@section Scripts {
@{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

Notice how the view template has a @model MvcMovie.Models.Movie statement at the top of the file.
@model MvcMovie.Models.Movie specifies that the view expects the model for the view template to be of type Movie .
The scaffolded code uses several Tag Helper methods to streamline the HTML markup. The - Label Tag Helper
displays the name of the field ("Title", "ReleaseDate", "Genre", or "Price"). The Input Tag Helper renders an HTML
<input> element. The Validation Tag Helper displays any validation messages associated with that property.
Run the application and navigate to the /Movies URL. Click an Edit link. In the browser, view the source for the
page. The generated HTML for the <form> element is shown below.

<form action="/Movies/Edit/7" method="post">

<div class="form-horizontal">
<h4>Movie</h4>
<hr />
<div class="text-danger" />
<input type="hidden" data-val="true" data-val-required="The ID field is required." id="ID" name="ID"
value="7" />
<div class="form-group">
<label class="control-label col-md-2" for="Genre" />
<div class="col-md-10">
<input class="form-control" type="text" id="Genre" name="Genre" value="Western" />
<span class="text-danger field-validation-valid" data-valmsg-for="Genre" data-valmsg-
replace="true"></span>
</div>
</div>
<div class="form-group">
<label class="control-label col-md-2" for="Price" />
<div class="col-md-10">
<input class="form-control" type="text" data-val="true" data-val-number="The field Price must
be a number." data-val-required="The Price field is required." id="Price" name="Price" value="3.99" />
<span class="text-danger field-validation-valid" data-valmsg-for="Price" data-valmsg-
replace="true"></span>
</div>
</div>
<!-- Markup removed for brevity -->
<div class="form-group">
<div class="col-md-offset-2 col-md-10">
<input type="submit" value="Save" class="btn btn-default" />
</div>
</div>
</div>
<input name="__RequestVerificationToken" type="hidden"
value="CfDJ8Inyxgp63fRFqUePGvuI5jGZsloJu1L7X9le1gy7NCIlSduCRx9jDQClrV9pOTTmqUyXnJBXhmrjcUVDJyDUMm7-
MF_9rK8aAZdRdlOri7FmKVkRe_2v5LIHGKFcTjPrWPYnc9AdSbomkiOSaTEg7RU" />
</form>

The <input> elements are in an HTML <form> element whose action attribute is set to post to the
/Movies/Edit/id URL. The form data will be posted to the server when the Save button is clicked. The last line
before the closing </form> element shows the hidden XSRF token generated by the Form Tag Helper.

Processing the POST Request

The following listing shows the [HttpPost] version of the Edit action method.
 // POST: Movies/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("ID,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (id != movie.ID)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.ID))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction("Index");
}
return View(movie);
}

The [ValidateAntiForgeryToken] attribute validates the hidden XSRF token generated by the anti-forgery token
generator in the Form Tag Helper
The model binding system takes the posted form values and creates a Movie object that's passed as the movie
parameter. The ModelState.IsValid method verifies that the data submitted in the form can be used to modify
(edit or update) a Movie object. If the data is valid it's saved. The updated (edited) movie data is saved to the
database by calling the SaveChangesAsync method of database context. After saving the data, the code redirects the
user to the Index action method of the MoviesController class, which displays the movie collection, including the
changes just made.
Before the form is posted to the server, client side validation checks any validation rules on the fields. If there are
any validation errors, an error message is displayed and the form is not posted. If JavaScript is disabled, you won't
have client side validation but the server will detect the posted values that are not valid, and the form values will be
redisplayed with error messages. Later in the tutorial we examine Model Validation in more detail. The Validation
Tag Helper in the Views/Movies/Edit.cshtml view template takes care of displaying appropriate error messages.
All the HttpGet methods in the movie controller follow a similar pattern. They get a movie object (or list of objects,
in the case of Index ), and pass the object (model) to the view. The Create method passes an empty movie object
to the Create view. All the methods that create, edit, delete, or otherwise modify data do so in the [HttpPost]
overload of the method. Modifying data in an HTTP GET method is a security risk. Modifying data in an HTTP GET
method also violates HTTP best practices and the architectural REST pattern, which specifies that GET requests
should not change the state of your application. In other words, performing a GET operation should be a safe
operation that has no side effects and doesn't modify your persisted data.

Additional resources
Globalization and localization
Introduction to Tag Helpers
Authoring Tag Helpers
Anti-Request Forgery
Protect your controller from over-posting
ViewModels
Form Tag Helper
Input Tag Helper
Label Tag Helper
Select Tag Helper
Validation Tag Helper

P R E V IO U S - W O R K IN G W IT H NE X T - ADD
S Q L IT E SE A RCH
 Adding Search to an ASP.NET Core MVC app
6/23/2017 7 min to read Edit Online

By Rick Anderson
In this section you add search capability to the Index action method that lets you search movies by genre or
name.
Update the Index method with the following code:

public async Task<IActionResult> Index(string searchString)

{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

return View(await movies.ToListAsync());

}

The first line of the Index action method creates a LINQ query to select the movies:

var movies = from m in _context.Movie

select m;

The query is only defined at this point, it has not been run against the database.
If the searchString parameter contains a string, the movies query is modified to filter on the value of the search
string:

if (!String.IsNullOrEmpty(id))
{
movies = movies.Where(s => s.Title.Contains(id));
}

The s => s.Title.Contains() code above is a Lambda Expression. Lambdas are used in method-based LINQ
queries as arguments to standard query operator methods such as the Where method or Contains (used in the
code above). LINQ queries are not executed when they are defined or when they are modified by calling a method
such as Where , Contains or OrderBy . Rather, query execution is deferred. That means that the evaluation of an
expression is delayed until its realized value is actually iterated over or the ToListAsync method is called. For more
information about deferred query execution, see Query Execution.
Note: The Contains method is run on the database, not in the c# code shown above. The case sensitivity on the
query depends on the database and the collation. On SQL Server, Contains maps to SQL LIKE, which is case
insensitive. In SQLlite, with the default collation, it's case sensitive.
Navigate to /Movies/Index . Append a query string such as ?searchString=Ghost to the URL. The filtered movies
are displayed.
If you change the signature of the Index method to have a parameter named id , the id parameter will match
the optional {id} placeholder for the default routes set in Startup.cs.

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

Note: SQLlite is case sensitive, so you'll need to search for "Ghost" and not "ghost".
The previous Index method:

public async Task<IActionResult> Index(string searchString)

{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

return View(await movies.ToListAsync());

}

The updated Index method with id parameter:

public async Task<IActionResult> Index(string id)

{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(id))
{
movies = movies.Where(s => s.Title.Contains(id));
}

return View(await movies.ToListAsync());

}
You can now pass the search title as route data (a URL segment) instead of as a query string value.

However, you can't expect users to modify the URL every time they want to search for a movie. So now you'll add
UI to help them filter movies. If you changed the signature of the Index method to test how to pass the route-
bound ID parameter, change it back so that it takes a parameter named searchString :

public async Task<IActionResult> Index(string searchString)

{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

return View(await movies.ToListAsync());

}

Open the Views/Movies/Index.cshtml file, and add the <form> markup highlighted below:

ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-action="Create">Create New</a>
</p>

<form asp-controller="Movies" asp-action="Index">

<p>
Title: <input type="text" name="SearchString">
<input type="submit" value="Filter" />
</p>
</form>

<table class="table">
<thead>
The HTML <form> tag uses the Form Tag Helper, so when you submit the form, the filter string is posted to the
Index action of the movies controller. Save your changes and then test the filter.

There's no [HttpPost] overload of the Index method as you might expect. You don't need it, because the method
isn't changing the state of the app, just filtering data.
You could add the following [HttpPost] Index method.

[HttpPost]
public string Index(string searchString, bool notUsed)
{
return "From [HttpPost]Index: filter on " + searchString;
}

The notUsed parameter is used to create an overload for the Index method. We'll talk about that later in the
tutorial.
If you add this method, the action invoker would match the [HttpPost] Index method, and the [HttpPost] Index
method would run as shown in the image below.

However, even if you add this [HttpPost] version of the Index method, there's a limitation in how this has all
been implemented. Imagine that you want to bookmark a particular search or you want to send a link to friends
that they can click in order to see the same filtered list of movies. Notice that the URL for the HTTP POST request is
the same as the URL for the GET request (localhost:xxxxx/Movies/Index) -- there's no search information in the
URL. The search string information is sent to the server as a form field value. You can verify that with the browser
Developer tools or the excellent Fiddler tool. The image below shows the Chrome browser Developer tools:

You can see the search parameter and XSRF token in the request body. Note, as mentioned in the previous tutorial,
the Form Tag Helper generates an XSRF anti-forgery token. We're not modifying data, so we don't need to validate
the token in the controller method.
Because the search parameter is in the request body and not the URL, you can't capture that search information to
bookmark or share with others. We'll fix this by specifying the request should be HTTP GET .
Change the <form> tag in the Views\movie\Index.cshtml Razor view to specify method="get" :
 <form asp-controller="Movies" asp-action="Index" method="get">

Now when you submit a search, the URL contains the search query string. Searching will also go to the
HttpGet Index action method, even if you have a HttpPost Index method.

The following markup shows the change to the form tag:

<form asp-controller="Movies" asp-action="Index" method="get">

Adding Search by genre

Add the following MovieGenreViewModel class to the Models folder:

using Microsoft.AspNetCore.Mvc.Rendering;
using System.Collections.Generic;

namespace MvcMovie.Models
{
public class MovieGenreViewModel
{
public List<Movie> movies;
public SelectList genres;
public string movieGenre { get; set; }
}
}

The movie-genre view model will contain:

A list of movies.
A SelectList containing the list of genres. This will allow the user to select a genre from the list.
movieGenre , which contains the selected genre.

Replace the Index method in MoviesController.cs with the following code:

 // Requires using Microsoft.AspNetCore.Mvc.Rendering;
public async Task<IActionResult> Index(string movieGenre, string searchString)
{
// Use LINQ to get list of genres.
IQueryable<string> genreQuery = from m in _context.Movie
orderby m.Genre
select m.Genre;

var movies = from m in _context.Movie

select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

if (!String.IsNullOrEmpty(movieGenre))
{
movies = movies.Where(x => x.Genre == movieGenre);
}

var movieGenreVM = new MovieGenreViewModel();

movieGenreVM.genres = new SelectList(await genreQuery.Distinct().ToListAsync());
movieGenreVM.movies = await movies.ToListAsync();

return View(movieGenreVM);
}

The following code is a LINQ query that retrieves all the genres from the database.

// Use LINQ to get list of genres.

IQueryable<string> genreQuery = from m in _context.Movie
orderby m.Genre
select m.Genre;

The SelectList of genres is created by projecting the distinct genres (we don't want our select list to have
duplicate genres).

movieGenreVM.genres = new SelectList(await genreQuery.Distinct().ToListAsync())

Adding search by genre to the Index view

Update Index.cshtml as follows:
@model MvcMovie.Models.MovieGenreViewModel

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-action="Create">Create New</a>
</p>

<form asp-controller="Movies" asp-action="Index" method="get">

<p>
<select asp-for="movieGenre" asp-items="Model.genres">
<option value="">All</option>
</select>

Title: <input type="text" name="SearchString">

<input type="submit" value="Filter" />
</p>
</form>

<table class="table">
<thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.movies[0].Title)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].ReleaseDate)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Genre)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Price)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model.movies)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
<a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
<a asp-action="Details" asp-route-id="@item.ID">Details</a> |
<a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Examine the lambda expression used in the following HTML Helper:
@Html.DisplayNameFor(model => model.movies[0].Title)

In the preceding code, the DisplayNameFor HTML Helper inspects the Title property referenced in the lambda
expression to determine the display name. Since the lambda expression is inspected rather than evaluated, you
don't receive an access violation when model , model.movies , or model.movies[0] are null or empty. When the
lambda expression is evaluated (for example, @Html.DisplayFor(modelItem => item.Title) ), the model's property
values are evaluated.
Test the app by searching by genre, by movie title, and by both.

P R E V IO U S - C O N T R O L L E R M E T H O D S A N D NE X T - ADD A
V IE W S F IE L D
 Adding a new field
9/22/2017 3 min to read Edit Online

By Rick Anderson
This tutorial will add a new field to the Movies table. We'll drop the database and create a new one when we
change the schema (add a new field). This workflow works well early in development when we don't have any
production data to perserve.
Once your app is deployed and you have data that you need to perserve, you can't drop your DB when you need to
change the schema. Entity Framework Code First Migrations allows you to update your schema and migrate the
database without losing data. Migrations is a popular feature when using SQL Server, but SQLlite does not support
many migration schema operations, so only very simply migrations are possible. See SQLite Limitations for more
information.

Adding a Rating Property to the Movie Model

Open the Models/Movie.cs file and add a Rating property:

public class Movie

{
public int ID { get; set; }
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
public string Rating { get; set; }
}

Because you've added a new field to the Movie class, you also need to update the binding whitelist so this new
property will be included. In MoviesController.cs, update the [Bind] attribute for both the Create and Edit
action methods to include the Rating property:

[Bind("ID,Title,ReleaseDate,Genre,Price,Rating")]

You also need to update the view templates in order to display, create, and edit the new Rating property in the
browser view.
Edit the /Views/Movies/Index.cshtml file and add a Rating field:
 <table class="table">
<thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.movies[0].Title)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].ReleaseDate)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Genre)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Price)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Rating)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model.movies)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
@Html.DisplayFor(modelItem => item.Rating)
</td>
<td>

Update the /Views/Movies/Create.cshtml with a Rating field.

The app won't work until we update the DB to include the new field. If you run it now, you'll get the following
SqliteException :

SqliteException: SQLite Error 1: 'no such column: m.Rating'.

You're seeing this error because the updated Movie model class is different than the schema of the Movie table of
the existing database. (There's no Rating column in the database table.)
There are a few approaches to resolving the error:
1. Drop the database and have the Entity Framework automatically re-create the database based on the new
model class schema. With this approach, you lose existing data in the database so you can't do this with a
production database! Using an initializer to automatically seed a database with test data is often a
productive way to develop an app.
2. Manually modify the schema of the existing database so that it matches the model classes. The advantage of
this approach is that you keep your data. You can make this change either manually or by creating a
database change script.
3. Use Code First Migrations to update the database schema.
For this tutorial, we'll drop and re-create the database when the schema changes. Run the following command
from a terminal to drop the db:
dotnet ef database drop

Update the SeedData class so that it provides a value for the new column. A sample change is shown below, but
you'll want to make this change for each new Movie .

new Movie
{
Title = "When Harry Met Sally",
ReleaseDate = DateTime.Parse("1989-1-11"),
Genre = "Romantic Comedy",
Rating = "R",
Price = 7.99M
},

Add the Rating field to the Edit , Details , and Delete view.
Run the app and verify you can create/edit/display movies with a Rating field. templates.

P R E V IO U S - A D D NE X T - ADD
SE A RCH V A L ID A T IO N
 Adding validation
9/22/2017 9 min to read Edit Online

By Rick Anderson
In this section you'll add validation logic to the Movie model, and you'll ensure that the validation rules are
enforced any time a user creates or edits a movie.

Keeping things DRY

One of the design tenets of MVC is DRY ("Don't Repeat Yourself"). ASP.NET MVC encourages you to specify
functionality or behavior only once, and then have it be reflected everywhere in an app. This reduces the amount of
code you need to write and makes the code you do write less error prone, easier to test, and easier to maintain.
The validation support provided by MVC and Entity Framework Core Code First is a good example of the DRY
principle in action. You can declaratively specify validation rules in one place (in the model class) and the rules are
enforced everywhere in the app.

Adding validation rules to the movie model

Open the Movie.cs file. DataAnnotations provides a built-in set of validation attributes that you apply declaratively
to any class or property. (It also contains formatting attributes like DataType that help with formatting and don't
provide any validation.)
Update the Movie class to take advantage of the built-in Required , StringLength , RegularExpression , and Range
validation attributes.

public class Movie

{
public int ID { get; set; }

[StringLength(60, MinimumLength = 3)]

[Required]
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }

[Range(1, 100)]
[DataType(DataType.Currency)]
public decimal Price { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$")]
[Required]
[StringLength(30)]
public string Genre { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$")]
[StringLength(5)]
[Required]
public string Rating { get; set; }
}

The validation attributes specify behavior that you want to enforce on the model properties they are applied to. The
Required and MinimumLength attributes indicates that a property must have a value; but nothing prevents a user
from entering white space to satisfy this validation. The RegularExpression attribute is used to limit what
characters can be input. In the code above, Genre and Rating must use only letters (white space, numbers and
special characters are not allowed). The Range attribute constrains a value to within a specified range. The
StringLength attribute lets you set the maximum length of a string property, and optionally its minimum length.
Value types (such as decimal , int , float , DateTime ) are inherently required and don't need the [Required]
attribute.
Having validation rules automatically enforced by ASP.NET helps make your app more robust. It also ensures that
you can't forget to validate something and inadvertently let bad data into the database.

Validation Error UI in MVC

Run the app and navigate to the Movies controller.
Tap the Create New link to add a new movie. Fill out the form with some invalid values. As soon as jQuery client
side validation detects the error, it displays an error message.
 NOTE
You may not be able to enter decimal commas in the Price field. To support jQuery validation for non-English locales that
use a comma (",") for a decimal point, and non US-English date formats, you must take steps to globalize your app. This
GitHub issue 4076 for instructions on adding decimal comma.

Notice how the form has automatically rendered an appropriate validation error message in each field containing
an invalid value. The errors are enforced both client-side (using JavaScript and jQuery) and server-side (in case a
user has JavaScript disabled).
A significant benefit is that you didn't need to change a single line of code in the MoviesController class or in the
Create.cshtml view in order to enable this validation UI. The controller and views you created earlier in this tutorial
automatically picked up the validation rules that you specified by using validation attributes on the properties of
the Movie model class. Test validation using the Edit action method, and the same validation is applied.
The form data is not sent to the server until there are no client side validation errors. You can verify this by putting
a break point in the HTTP Post method, by using the Fiddler tool , or the F12 Developer tools.

How validation works

You might wonder how the validation UI was generated without any updates to the code in the controller or views.
The following code shows the two Create methods.

// GET: Movies/Create
public IActionResult Create()
{
return View();
}

// POST: Movies/Create
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Create(
[Bind("ID,Title,ReleaseDate,Genre,Price, Rating")] Movie movie)
{
if (ModelState.IsValid)
{
_context.Add(movie);
await _context.SaveChangesAsync();
return RedirectToAction("Index");
}
return View(movie);
}

The first (HTTP GET) Create action method displays the initial Create form. The second ( [HttpPost] ) version
handles the form post. The second Create method (The [HttpPost] version) calls ModelState.IsValid to check
whether the movie has any validation errors. Calling this method evaluates any validation attributes that have been
applied to the object. If the object has validation errors, the Create method re-displays the form. If there are no
errors, the method saves the new movie in the database. In our movie example, the form is not posted to the
server when there are validation errors detected on the client side; the second Create method is never called
when there are client side validation errors. If you disable JavaScript in your browser, client validation is disabled
and you can test the HTTP POST Create method ModelState.IsValid detecting any validation errors.
You can set a break point in the [HttpPost] Create method and verify the method is never called, client side
validation will not submit the form data when validation errors are detected. If you disable JavaScript in your
browser, then submit the form with errors, the break point will be hit. You still get full validation without
JavaScript.
The following image shows how to disable JavaScript in the FireFox browser.

The following image shows how to disable JavaScript in the Chrome browser.

After you disable JavaScript, post invalid data and step through the debugger.
Below is portion of the Create.cshtml view template that you scaffolded earlier in the tutorial. It's used by the action
methods shown above both to display the initial form and to redisplay it in the event of an error.

<form asp-action="Create">
<div class="form-horizontal">
<h4>Movie</h4>
<hr />

<div asp-validation-summary="ModelOnly" class="text-danger"></div>

<div class="form-group">
<label asp-for="Title" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Title" class="form-control" />
<span asp-validation-for="Title" class="text-danger"></span>
</div>
</div>

@*Markup removed for brevity.*@

</div>
</form>

The Input Tag Helper uses the DataAnnotations attributes and produces HTML attributes needed for jQuery
Validation on the client side. The Validation Tag Helper displays validation errors. See Validation for more
information.
What's really nice about this approach is that neither the controller nor the Create view template knows anything
about the actual validation rules being enforced or about the specific error messages displayed. The validation
rules and the error strings are specified only in the Movie class. These same validation rules are automatically
applied to the Edit view and any other views templates you might create that edit your model.
When you need to change validation logic, you can do so in exactly one place by adding validation attributes to the
model (in this example, the Movie class). You won't have to worry about different parts of the application being
inconsistent with how the rules are enforced all validation logic will be defined in one place and used
everywhere. This keeps the code very clean, and makes it easy to maintain and evolve. And it means that you'll be
fully honoring the DRY principle.

Using DataType Attributes

Open the Movie.cs file and examine the Movie class. The System.ComponentModel.DataAnnotations namespace
provides formatting attributes in addition to the built-in set of validation attributes. We've already applied a
DataType enumeration value to the release date and to the price fields. The following code shows the ReleaseDate
and Price properties with the appropriate DataType attribute.
 [Display(Name = "Release Date")]
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }

[Range(1, 100)]
[DataType(DataType.Currency)]
public decimal Price { get; set; }

The DataType attributes only provide hints for the view engine to format the data (and supply attributes such as
<a> for URL's and <a href="mailto:EmailAddress.com"> for email. You can use the RegularExpression attribute to
validate the format of the data. The DataType attribute is used to specify a data type that is more specific than the
database intrinsic type, they are not validation attributes. In this case we only want to keep track of the date, not the
time. The DataType Enumeration provides for many data types, such as Date, Time, PhoneNumber, Currency,
EmailAddress and more. The DataType attribute can also enable the application to automatically provide type-
specific features. For example, a mailto: link can be created for DataType.EmailAddress , and a date selector can be
provided for DataType.Date in browsers that support HTML5. The DataType attributes emits HTML 5 data-
(pronounced data dash) attributes that HTML 5 browsers can understand. The DataType attributes do not provide
any validation.
DataType.Date does not specify the format of the date that is displayed. By default, the data field is displayed
according to the default formats based on the server's CultureInfo .
The DisplayFormat attribute is used to explicitly specify the date format:

[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

public DateTime ReleaseDate { get; set; }

The ApplyFormatInEditMode setting specifies that the formatting should also be applied when the value is displayed
in a text box for editing. (You might not want that for some fields for example, for currency values, you probably
do not want the currency symbol in the text box for editing.)
You can use the DisplayFormat attribute by itself, but it's generally a good idea to use the DataType attribute. The
DataType attribute conveys the semantics of the data as opposed to how to render it on a screen, and provides the
following benefits that you don't get with DisplayFormat:
The browser can enable HTML5 features (for example to show a calendar control, the locale-appropriate
currency symbol, email links, etc.)
By default, the browser will render data using the correct format based on your locale.
The DataType attribute can enable MVC to choose the right field template to render the data (the
DisplayFormat if used by itself uses the string template).

NOTE
jQuery validation does not work with the Range attribute and DateTime . For example, the following code will always
display a client side validation error, even when the date is in the specified range:

[Range(typeof(DateTime), "1/1/1966", "1/1/2020")]

You will need to disable jQuery date validation to use the Range attribute with DateTime . It's generally not a good
practice to compile hard dates in your models, so using the Range attribute and DateTime is discouraged.
The following code shows combining attributes on one line:
 public class Movie
{
public int ID { get; set; }

[StringLength(60, MinimumLength = 3)]

public string Title { get; set; }

[Display(Name = "Release Date"), DataType(DataType.Date)]

public DateTime ReleaseDate { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$"), Required, StringLength(30)]

public string Genre { get; set; }

[Range(1, 100), DataType(DataType.Currency)]

public decimal Price { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$"), StringLength(5)]
public string Rating { get; set; }
}

In the next part of the series, we'll review the application and make some improvements to the automatically
generated Details and Delete methods.

Additional resources
Working with Forms
Globalization and localization
Introduction to Tag Helpers
Authoring Tag Helpers

P R E V IO U S - A D D A N E X T - E X A M IN E T H E D E T A IL S A N D D E L E T E
F IE L D M E THOD S
 Examining the Details and Delete methods
7/5/2017 3 min to read Edit Online

By Rick Anderson
Open the Movie controller and examine the Details method:

// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie

.SingleOrDefaultAsync(m => m.ID == id);
if (movie == null)
{
return NotFound();
}

return View(movie);
}

The MVC scaffolding engine that created this action method adds a comment showing an HTTP request that
invokes the method. In this case it's a GET request with three URL segments, the Movies controller, the Details
method and an id value. Recall these segments are defined in Startup.cs.

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

EF makes it easy to search for data using the SingleOrDefaultAsync method. An important security feature built into
the method is that the code verifies that the search method has found a movie before it tries to do anything with it.
For example, a hacker could introduce errors into the site by changing the URL created by the links from
http://localhost:xxxx/Movies/Details/1 to something like http://localhost:xxxx/Movies/Details/12345 (or some
other value that doesn't represent an actual movie). If you did not check for a null movie, the app would throw an
exception.
Examine the Delete and DeleteConfirmed methods.
 // GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie

.SingleOrDefaultAsync(m => m.ID == id);
if (movie == null)
{
return NotFound();
}

return View(movie);
}

// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var movie = await _context.Movie.SingleOrDefaultAsync(m => m.ID == id);
_context.Movie.Remove(movie);
await _context.SaveChangesAsync();
return RedirectToAction("Index");
}

Note that the HTTP GET Delete method doesn't delete the specified movie, it returns a view of the movie where you
can submit (HttpPost) the deletion. Performing a delete operation in response to a GET request (or for that matter,
performing an edit operation, create operation, or any other operation that changes data) opens up a security hole.
The [HttpPost] method that deletes the data is named DeleteConfirmed to give the HTTP POST method a unique
signature or name. The two method signatures are shown below:

// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{

// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{

The common language runtime (CLR) requires overloaded methods to have a unique parameter signature (same
method name but different list of parameters). However, here you need two Delete methods -- one for GET and
one for POST -- that both have the same parameter signature. (They both need to accept a single integer as a
parameter.)
There are two approaches to this problem, one is to give the methods different names. That's what the scaffolding
mechanism did in the preceding example. However, this introduces a small problem: ASP.NET maps segments of a
URL to action methods by name, and if you rename a method, routing normally wouldn't be able to find that
method. The solution is what you see in the example, which is to add the ActionName("Delete") attribute to the
DeleteConfirmed method. That attribute performs mapping for the routing system so that a URL that includes
/Delete/ for a POST request will find the DeleteConfirmed method.
Another common work around for methods that have identical names and signatures is to artificially change the
signature of the POST method to include an extra (unused) parameter. That's what we did in a previous post when
we added the notUsed parameter. You could do the same thing here for the [HttpPost] Delete method:

// POST: Movies/Delete/6
[ValidateAntiForgeryToken]
public async Task<IActionResult> Delete(int id, bool notUsed)

Thanks for completing this introduction to ASP.NET Core MVC. We appreciate any comments you leave. Getting
started with MVC and EF Core is an excellent follow up to this tutorial.

P R E V IO U S
 Create an ASP.NET Core MVC app with Visual Studio
Code
9/22/2017 1 min to read Edit Online

This series of tutorials teaches you the basics of building an ASP.NET Core MVC web app using Visual Studio.
This tutorial teaches ASP.NET Core MVC with controllers and views. Razor Pages is a new alternative in ASP.NET
Core 2.0, a page-based programming model that makes building web UI easier and more productive. We
recommend you try the Razor Pages tutorial before the MVC version. For a Razor Pages version of this tutorial, see
Razor Pages.
1. Getting started
2. Adding a controller
3. Adding a view
4. Adding a model
5. Working with SQLite
6. Controller methods and views
7. Adding Search
8. Adding a New Field
9. Adding Validation
10. Examining the Details and Delete methods
 Getting started with ASP.NET Core MVC on Mac,
Linux, or Windows
9/22/2017 1 min to read Edit Online

By Rick Anderson
This tutorial will teach you the basics of building an ASP.NET Core MVC web app using Visual Studio Code (VS
Code). The tutorial assumes familarity with VS Code. See Getting started with VS Code and Visual Studio Code
help for more information. This tutorial teaches ASP.NET Core MVC with controllers and views. Razor Pages is a
new alternative in ASP.NET Core 2.0, a page-based programming model that makes building web UI easier and
more productive. We recommend you try the Razor Pages tutorial before the MVC version. For a Razor Pages
version of this tutorial, see Razor Pages.
There are 3 versions of this tutorial:
macOS: Create an ASP.NET Core MVC app with Visual Studio for Mac
Windows: Create an ASP.NET Core MVC app with Visual Studio
macOS, Linux, and Windows: Create an ASP.NET Core MVC app with Visual Studio Code

Install VS Code and .NET Core

This tutorial requires the .NET Core 2.0.0 SDK or later. See the pdf for the ASP.NET Core 1.1 version.
Install the following:
.NET Core 2.0.0 SDK or later.
Visual Studio Code
VS Code C# extension

Create a web app with dotnet

From a terminal, run the following commands:

mkdir MvcMovie
cd MvcMovie
dotnet new mvc

Open the MvcMovie folder in Visual Studio Code (VS Code) and select the Startup.cs file.
Select Yes to the Warn message "Required assets to build and debug are missing from 'MvcMovie'. Add
them?"
Select Restore to the Info message "There are unresolved dependencies".
Press Debug (F5) to build and run the program.

VS Code starts the Kestrel web server and runs your app. Notice that the address bar shows localhost:5000 and
not something like example.com . That's because localhost is the standard hostname for your local computer.
The default template gives you working Home, About and Contact links. The browser image above doesn't show
these links. Depending on the size of your browser, you might need to click the navigation icon to show them.
In the next part of this tutorial, we'll learn about MVC and start writing some code.

Visual Studio Code help

Getting started
Debugging
Integrated terminal
Keyboard shortcuts
Mac keyboard shortcuts
Linux keyboard shortcuts
Windows keyboard shortcuts

NE X T - ADD A
C ON TROL L E R
 Adding a controller to a ASP.NET Core MVC app
with Visual Studio Code
9/22/2017 5 min to read Edit Online

By Rick Anderson
The Model-View-Controller (MVC) architectural pattern separates an app into three main components: Model,
View, and Controller. The MVC pattern helps you create apps that are more testable and easier to update than
traditional monolithic apps. MVC-based apps contain:
Models: Classes that represent the data of the app. The model classes use validation logic to enforce
business rules for that data. Typically, model objects retrieve and store model state in a database. In this
tutorial, a Movie model retrieves movie data from a database, provides it to the view or updates it. Updated
data is written to a database.
Views: Views are the components that display the app's user interface (UI). Generally, this UI displays the
model data.
Controllers: Classes that handle browser requests. They retrieve model data and call view templates that
return a response. In an MVC app, the view only displays information; the controller handles and responds
to user input and interaction. For example, the controller handles route data and query-string values, and
passes these values to the model. The model might use these values to query the database. For example,
http://localhost:1234/Home/About has route data of Home (the controller) and About (the action method to
call on the home controller). http://localhost:1234/Movies/Edit/5 is a request to edit the movie with ID=5
using the movie controller. We'll talk about route data later in the tutorial.
The MVC pattern helps you create apps that separate the different aspects of the app (input logic, business logic,
and UI logic), while providing a loose coupling between these elements. The pattern specifies where each kind of
logic should be located in the app. The UI logic belongs in the view. Input logic belongs in the controller. Business
logic belongs in the model. This separation helps you manage complexity when you build an app, because it
enables you to work on one aspect of the implementation at a time without impacting the code of another. For
example, you can work on the view code without depending on the business logic code.
We cover these concepts in this tutorial series and show you how to use them to build a movie app. The MVC
project contains folders for the Controllers and Views. A Models folder will be added in a later step.
In VS Code, select the EXPLORER icon and then control-click (right-click) Controllers > New File
Replace the contents of Controllers/HelloWorldController.cs with the following:

using Microsoft.AspNetCore.Mvc;
using System.Text.Encodings.Web;

namespace MvcMovie.Controllers
{
public class HelloWorldController : Controller
{
//
// GET: /HelloWorld/

public string Index()

{
return "This is my default action...";
}

//
// GET: /HelloWorld/Welcome/

public string Welcome()

{
return "This is the Welcome action method...";
}
}
}

Every public method in a controller is callable as an HTTP endpoint. In the sample above, both methods return a
string. Note the comments preceding each method.
An HTTP endpoint is a targetable URL in the web application, such as http://localhost:1234/HelloWorld , and
combines the protocol used: HTTP , the network location of the web server (including the TCP port):
localhost:1234 and the target URI HelloWorld .

The first comment states this is an HTTP GET method that is invoked by appending "/HelloWorld/" to the base URL.
The second comment specifies an HTTP GET method that is invoked by appending "/HelloWorld/Welcome/" to the
URL. Later on in the tutorial you'll use the scaffolding engine to generate HTTP POST methods.
Run the app in non-debug mode and append "HelloWorld" to the path in the address bar. The Index method
returns a string.

MVC invokes controller classes (and the action methods within them) depending on the incoming URL. The default
URL routing logic used by MVC uses a format like this to determine what code to invoke:
/[Controller]/[ActionName]/[Parameters]

You set the format for routing in the Startup.cs file.

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

When you run the app and don't supply any URL segments, it defaults to the "Home" controller and the "Index"
method specified in the template line highlighted above.
The first URL segment determines the controller class to run. So localhost:xxxx/HelloWorld maps to the
HelloWorldController class. The second part of the URL segment determines the action method on the class. So
localhost:xxxx/HelloWorld/Index would cause the Index method of the HelloWorldController class to run. Notice
that you only had to browse to localhost:xxxx/HelloWorld and the Index method was called by default. This is
because Index is the default method that will be called on a controller if a method name is not explicitly specified.
The third part of the URL segment ( id ) is for route data. You'll see route data later on in this tutorial.
Browse to http://localhost:xxxx/HelloWorld/Welcome . The Welcome method runs and returns the string "This is the
Welcome action method...". For this URL, the controller is HelloWorld and Welcome is the action method. You
haven't used the [Parameters] part of the URL yet.
Modify the code to pass some parameter information from the URL to the controller. For example,
/HelloWorld/Welcome?name=Rick&numtimes=4 . Change the Welcome method to include two parameters as shown in
the following code.

// GET: /HelloWorld/Welcome/
// Requires using System.Text.Encodings.Web;
public string Welcome(string name, int numTimes = 1)
{
return HtmlEncoder.Default.Encode($"Hello {name}, NumTimes is: {numTimes}");
}

The preceding code:

Uses the C# optional-parameter feature to indicate that the numTimes parameter defaults to 1 if no value is
passed for that parameter.
Uses HtmlEncoder.Default.Encode to protect the app from malicious input (namely JavaScript).
Uses Interpolated Strings.
Run your app and browse to:
http://localhost:xxxx/HelloWorld/Welcome?name=Rick&numtimes=4

(Replace xxxx with your port number.) You can try different values for name and numtimes in the URL. The MVC
model binding system automatically maps the named parameters from the query string in the address bar to
parameters in your method. See Model Binding for more information.

In the image above, the URL segment ( Parameters ) is not used, the name and numTimes parameters are passed as
query strings. The ? (question mark) in the above URL is a separator, and the query strings follow. The &
character separates query strings.
Replace the Welcome method with the following code:

public string Welcome(string name, int ID = 1)

{
return HtmlEncoder.Default.Encode($"Hello {name}, ID: {ID}");
}

Run the app and enter the following URL: http://localhost:xxx/HelloWorld/Welcome/3?name=Rick

This time the third URL segment matched the route parameter id . The Welcome method contains a parameter
id that matched the URL template in the MapRoute method. The trailing ? (in id? ) indicates the id parameter
is optional.

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

In these examples the controller has been doing the "VC" portion of MVC - that is, the view and controller work.
The controller is returning HTML directly. Generally you don't want controllers returning HTML directly, since that
becomes very cumbersome to code and maintain. Instead you typically use a separate Razor view template file to
help generate the HTML response. You do that in the next tutorial.

P R E V IO U S - A D D A NE X T - ADD A
C ON TROL L E R V IE W
 Adding a view to an ASP.NET Core MVC app
9/22/2017 7 min to read Edit Online

By Rick Anderson
In this section you modify the HelloWorldController class to use Razor view template files to cleanly encapsulate
the process of generating HTML responses to a client.
You create a view template file using Razor. Razor-based view templates have a .cshtml file extension. They provide
an elegant way to create HTML output using C#.
Currently the method returns a string with a message that is hard-coded in the controller class. In the
Index
HelloWorldController class, replace the Index method with the following code:

public IActionResult Index()

{
return View();
}

The preceding code returns a View object. It uses a view template to generate an HTML response to the browser.
Controller methods (also known as action methods) such as the Index method above, generally return an
IActionResult (or a class derived from ActionResult ), not primitive types like string.
Add an Index view for the HelloWorldController .
Add a new folder named Views/HelloWorld.
Add a new file to the Views/HelloWorld folder name Index.cshtml.
Replace the contents of the Views/HelloWorld/Index.cshtml Razor view file with the following:

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>Hello from our View Template!</p>

Navigate to http://localhost:xxxx/HelloWorld . The Index method in the HelloWorldController didn't do much; it

ran the statement return View(); , which specified that the method should use a view template file to render a
response to the browser. Because you didn't explicitly specify the name of the view template file, MVC defaulted to
using the Index.cshtml view file in the /Views/HelloWorld folder. The image below shows the string "Hello from our
View Template!" hard-coded in the view.
If your browser window is small (for example on a mobile device), you might need to toggle (tap) the Bootstrap
navigation button in the upper right to see the Home, About, and Contact links.

Changing views and layout pages

Tap the menu links (MvcMovie, Home, About). Each page shows the same menu layout. The menu layout is
implemented in the Views/Shared/_Layout.cshtml file. Open the Views/Shared/_Layout.cshtml file.
Layout templates allow you to specify the HTML container layout of your site in one place and then apply it across
multiple pages in your site. Find the @RenderBody() line. RenderBody is a placeholder where all the view-specific
pages you create show up, wrapped in the layout page. For example, if you select the About link, the
Views/Home/About.cshtml view is rendered inside the RenderBody method.

Change the title and menu link in the layout file

Change the contents of the title element. Change the anchor text in the layout template to "Movie App" and the
controller from Home to Movies as highlighted below:
Note: The ASP.NET Core 2.0 version is slightly different. It doesn't contain @inject ApplicationInsights and
@Html.Raw(JavaScriptSnippet.FullScript) .

@inject Microsoft.ApplicationInsights.AspNetCore.JavaScriptSnippet JavaScriptSnippet

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>@ViewData["Title"] - Movie App</title>

<environment names="Development">
<link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.css" />
<link rel="stylesheet" href="~/css/site.css" />
</environment>
<environment names="Staging,Production">
<link rel="stylesheet" href="https://ajax.aspnetcdn.com/ajax/bootstrap/3.3.7/css/bootstrap.min.css"
asp-fallback-href="~/lib/bootstrap/dist/css/bootstrap.min.css"
asp-fallback-test-class="sr-only" asp-fallback-test-property="position" asp-fallback-test-
value="absolute" />
<link rel="stylesheet" href="~/css/site.min.css" asp-append-version="true" />
</environment>
@Html.Raw(JavaScriptSnippet.FullScript)
</head>
<body>
<nav class="navbar navbar-inverse navbar-fixed-top">
<div class="container">
<div class="navbar-header">
<button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-
collapse">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a asp-area="" asp-controller="Movies" asp-action="Index" class="navbar-brand">MvcMovie</a>
</div>
<div class="navbar-collapse collapse">
<ul class="nav navbar-nav">
<li><a asp-area="" asp-controller="Home" asp-action="Index">Home</a></li>
<li><a asp-area="" asp-controller="Home" asp-action="About">About</a></li>
<li><a asp-area="" asp-controller="Home" asp-action="Contact">Contact</a></li>
</ul>
</div>
</div>
</nav>
<div class="container body-content">
@RenderBody()
<hr />
<footer>
<p>&copy; 2017 - MvcMovie</p>
</footer>
</div>

<environment names="Development">
<script src="~/lib/jquery/dist/jquery.js"></script>
<script src="~/lib/bootstrap/dist/js/bootstrap.js"></script>
<script src="~/js/site.js" asp-append-version="true"></script>
</environment>
<environment names="Staging,Production">
<script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-2.2.0.min.js"
asp-fallback-src="~/lib/jquery/dist/jquery.min.js"
asp-fallback-test="window.jQuery"
crossorigin="anonymous"
integrity="sha384-K+ctZQ+LL8q6tP7I94W+qzQsfRV2a+AfHIi9k8z8l9ggpc8X+Ytst4yBo/hH+8Fk">
</script>
<script src="https://ajax.aspnetcdn.com/ajax/bootstrap/3.3.7/bootstrap.min.js"
asp-fallback-src="~/lib/bootstrap/dist/js/bootstrap.min.js"
asp-fallback-test="window.jQuery && window.jQuery.fn && window.jQuery.fn.modal"
crossorigin="anonymous"
integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa">
</script>
<script src="~/js/site.min.js" asp-append-version="true"></script>
</environment>
 @RenderSection("Scripts", required: false)
</body>
</html>

WARNING
We haven't implemented the Movies controller yet, so if you click on that link, you'll get a 404 (Not found) error.

Save your changes and tap the About link. Notice how the title on the browser tab now displays About - Movie
App instead of About - Mvc Movie. Tap the Contact link and notice that it also displays Movie App. We were
able to make the change once in the layout template and have all pages on the site reflect the new link text and
new title.
Examine the Views/_ViewStart.cshtml file:

@{
Layout = "_Layout";
}

The Views/_ViewStart.cshtml file brings in the Views/Shared/_Layout.cshtml file to each view. You can use the
Layout property to set a different layout view, or set it to null so no layout file will be used.

Change the title of the Index view.

Open Views/HelloWorld/Index.cshtml. There are two places to make a change:
The text that appears in the title of the browser.
The secondary header ( <h2> element).

You'll make them slightly different so you can see which bit of code changes which part of the app.

@{
ViewData["Title"] = "Movie List";
}

<h2>My Movie List</h2>

<p>Hello from our View Template!</p>

ViewData["Title"] = "Movie List"; in the code above sets the Title property of the ViewData dictionary to
"Movie List". The Title property is used in the <title> HTML element in the layout page:

<title>@ViewData["Title"] - Movie App</title>

Save your change and navigate to http://localhost:xxxx/HelloWorld . Notice that the browser title, the primary
heading, and the secondary headings have changed. (If you don't see changes in the browser, you might be
viewing cached content. Press Ctrl+F5 in your browser to force the response from the server to be loaded.) The
browser title is created with ViewData["Title"] we set in the Index.cshtml view template and the additional "-
Movie App" added in the layout file.
Also notice how the content in the Index.cshtml view template was merged with the Views/Shared/_Layout.cshtml
view template and a single HTML response was sent to the browser. Layout templates make it really easy to make
changes that apply across all of the pages in your application. To learn more see Layout.
Our little bit of "data" (in this case the "Hello from our View Template!" message) is hard-coded, though. The MVC
application has a "V" (view) and you've got a "C" (controller), but no "M" (model) yet.

Passing Data from the Controller to the View

Controller actions are invoked in response to an incoming URL request. A controller class is where you write the
code that handles the incoming browser requests. The controller retrieves data from a data source and decides
what type of response to send back to the browser. View templates can be used from a controller to generate and
format an HTML response to the browser.
Controllers are responsible for providing the data required in order for a view template to render a response. A
best practice: View templates should not perform business logic or interact with a database directly. Rather, a view
template should work only with the data that's provided to it by the controller. Maintaining this "separation of
concerns" helps keep your code clean, testable, and maintainable.
Currently, the Welcome method in the HelloWorldController class takes a name and a ID parameter and then
outputs the values directly to the browser. Rather than have the controller render this response as a string, lets
change the controller to use a view template instead. The view template will generate a dynamic response, which
means that you need to pass appropriate bits of data from the controller to the view in order to generate the
response. You can do this by having the controller put the dynamic data (parameters) that the view template needs
in a ViewData dictionary that the view template can then access.
Return to the HelloWorldController.cs file and change the Welcome method to add a Message and NumTimes value
to the ViewData dictionary. The ViewData dictionary is a dynamic object, which means you can put whatever you
want in to it; the ViewData object has no defined properties until you put something inside it. The MVC model
binding system automatically maps the named parameters ( name and numTimes ) from the query string in the
address bar to parameters in your method. The complete HelloWorldController.cs file looks like this:
 using Microsoft.AspNetCore.Mvc;
using System.Text.Encodings.Web;

namespace MvcMovie.Controllers
{
public class HelloWorldController : Controller
{
public IActionResult Index()
{
return View();
}

public IActionResult Welcome(string name, int numTimes = 1)

{
ViewData["Message"] = "Hello " + name;
ViewData["NumTimes"] = numTimes;

return View();
}
}
}

The ViewData dictionary object contains data that will be passed to the view.
Create a Welcome view template named Views/HelloWorld/Welcome.cshtml.
You'll create a loop in the Welcome.cshtml view template that displays "Hello" NumTimes . Replace the contents of
Views/HelloWorld/Welcome.cshtml with the following:

@{
ViewData["Title"] = "Welcome";
}

<h2>Welcome</h2>

<ul>
@for (int i = 0; i < (int)ViewData["NumTimes"]; i++)
{
<li>@ViewData["Message"]</li>
}
</ul>

Save your changes and browse to the following URL:

http://localhost:xxxx/HelloWorld/Welcome?name=Rick&numtimes=4

Data is taken from the URL and passed to the controller using the MVC model binder . The controller packages the
data into a ViewData dictionary and passes that object to the view. The view then renders the data as HTML to the
browser.
In the sample above, we used the ViewData dictionary to pass data from the controller to a view. Later in the
tutorial, we will use a view model to pass data from a controller to a view. The view model approach to passing
data is generally much preferred over the ViewData dictionary approach. See ViewModel vs ViewData vs ViewBag
vs TempData vs Session in MVC for more information.
Well, that was a kind of an "M" for model, but not the database kind. Let's take what we've learned and create a
database of movies.

P R E V IO U S - A D D A NE X T - ADD A
C ON TROL L E R M ODEL
 Adding a model to an ASP.NET Core MVC app
9/22/2017 4 min to read Edit Online

By Rick Anderson and Tom Dykstra

In this section, you'll add some classes for managing movies in a database. These classes will be the "Model" part
of the MVC app.
You use these classes with Entity Framework Core (EF Core) to work with a database. EF Core is an object-
relational mapping (ORM) framework that simplifies the data access code that you have to write. EF Core supports
many database engines.
The model classes you'll create are known as POCO classes (from "plain-old CLR objects") because they don't have
any dependency on EF Core. They just define the properties of the data that will be stored in the database.
In this tutorial you'll write the model classes first, and EF Core will create the database. An alternate approach not
covered here is to generate model classes from an already-existing database. For information about that approach,
see ASP.NET Core - Existing Database.

Add a data model class

Add a class to the Models folder named Movie.cs.
Add the following code to the Models/Movie.cs file:

using System;

namespace MvcMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

The ID field is required by the database for the primary key.

Build the app to verify you don't have any errors, and you've finally added a Model to your MVC app.

Prepare the project for scaffolding

Add the following highlighted NuGet packages to the MvcMovie.csproj file:
 <Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>netcoreapp2.0</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.0" />
<PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="2.0.0" />
</ItemGroup>
<ItemGroup>
<DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
<DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.0"
/>
</ItemGroup>
</Project>

Save the file and select Restore to the Info message "There are unresolved dependencies".
Create a Models/MvcMovieContext.cs file and add the following MvcMovieContext class:

using Microsoft.EntityFrameworkCore;

namespace MvcMovie.Models
{
public class MvcMovieContext : DbContext
{
public MvcMovieContext (DbContextOptions<MvcMovieContext> options)
: base(options)
{
}

public DbSet<MvcMovie.Models.Movie> Movie { get; set; }

}
}

Open the Startup.cs file and add two usings:

using Microsoft.EntityFrameworkCore;
using MvcMovie.Models;

namespace MvcMovie
{
public class Startup
{

Add the database context to the Startup.cs file:

public void ConfigureServices(IServiceCollection services)

{
// Add framework services.
services.AddMvc();

services.AddDbContext<MvcMovieContext>(options =>
options.UseSqlite("Data Source=MvcMovie.db"));

This tells Entity Framework which model classes are included in the data model. You're defining one entity
set of Movie objects, which will be represented in the database as a Movie table.
Build the project to verify there are no errors.
Scaffold the MovieController
Open a terminal window in the project folder and run the following commands:

dotnet restore
dotnet aspnet-codegenerator controller -name MoviesController -m Movie -dc MvcMovieContext --
relativeFolderPath Controllers --useDefaultLayout --referenceScriptLibraries

NOTE
If you get an error when the scaffolding command runs, see issue 444 in the scaffolding repository for a workaround.

The scaffolding engine creates the following:

A movies controller (Controllers/MoviesController.cs)
Razor view files for Create, Delete, Details, Edit and Index pages (Views/Movies/\.cshtml*)
The automatic creation of CRUD (create, read, update, and delete) action methods and views is known as
scaffolding. You'll soon have a fully functional web application that lets you manage a movie database.

Perform initial migration

From the command line, run the following .NET Core CLI commands:

dotnet ef migrations add InitialCreate

dotnet ef database update

The dotnet ef migrations add InitialCreate command generates code to create the initial database schema. The
schema is based on the model specified in the DbContext (In the Models/MovieContext.cs file). The Initial
argument is used to name the migrations. You can use any name, but by convention you choose a name that
describes the migration. See Introduction to migrations for more information.
The dotnet ef database update command runs the Up method in the Migrations/<time-stamp>_InitialCreate.cs
file, which creates the database.

Test the app

Run the app and tap the Mvc Movie link.
Tap the Create New link and create a movie.
 You may not be able to enter decimal points or commas in the Price field. To support jQuery validation for
non-English locales that use a comma (",") for a decimal point, and non US-English date formats, you must
take steps to globalize your app. See https://github.com/aspnet/Docs/issues/4076 and Additional resources
for more information. For now, just enter whole numbers like 10.
In some locales you need to specify the date format. See the highlighted code below.

using System;
using System.ComponentModel.DataAnnotations;

namespace MvcMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

We'll talk about DataAnnotations later in the tutorial.

Tapping Create causes the form to be posted to the server, where the movie information is saved in a database.
The app redirects to the /Movies URL, where the newly created movie information is displayed.

Create a couple more movie entries. Try the Edit, Details, and Delete links, which are all functional.
You now have a database and pages to display, edit, update and delete data. In the next tutorial, we'll work with the
database.
Additional resources
Tag Helpers
Globalization and localization

P R E V IO U S - A D D A N E X T - W O R K IN G W IT H
V IE W S Q L IT E
 Working with SQLite in an ASP.NET Core MVC
project
9/22/2017 2 min to read Edit Online

By Rick Anderson
The MvcMovieContext object handles the task of connecting to the database and mapping Movie objects to
database records. The database context is registered with the Dependency Injection container in the
ConfigureServices method in the Startup.cs file:

public void ConfigureServices(IServiceCollection services)

{
// Add framework services.
services.AddMvc();

services.AddDbContext<MvcMovieContext>(options =>
options.UseSqlite("Data Source=MvcMovie.db"));

SQLite
The SQLite website states:

SQLite is a self-contained, high-reliability, embedded, full-featured, public-domain, SQL database engine.

SQLite is the most used database engine in the world.

There are many third party tools you can download to manage and view a SQLite database. The image below is
from DB Browser for SQLite. If you have a favorite SQLite tool, leave a comment on what you like about it.
Seed the database
Create a new class named SeedData in the Models folder. Replace the generated code with the following:
 using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Linq;

namespace MvcMovie.Models
{
public static class SeedData
{
public static void Initialize(IServiceProvider serviceProvider)
{
using (var context = new MvcMovieContext(
serviceProvider.GetRequiredService<DbContextOptions<MvcMovieContext>>()))
{
// Look for any movies.
if (context.Movie.Any())
{
return; // DB has been seeded
}

context.Movie.AddRange(
new Movie
{
Title = "When Harry Met Sally",
ReleaseDate = DateTime.Parse("1989-1-11"),
Genre = "Romantic Comedy",
Price = 7.99M
},

new Movie
{
Title = "Ghostbusters ",
ReleaseDate = DateTime.Parse("1984-3-13"),
Genre = "Comedy",
Price = 8.99M
},

new Movie
{
Title = "Ghostbusters 2",
ReleaseDate = DateTime.Parse("1986-2-23"),
Genre = "Comedy",
Price = 9.99M
},

new Movie
{
Title = "Rio Bravo",
ReleaseDate = DateTime.Parse("1959-4-15"),
Genre = "Western",
Price = 3.99M
}
);
context.SaveChanges();
}
}
}
}

If there are any movies in the DB, the seed initializer returns.
 if (context.Movie.Any())
{
return; // DB has been seeded.
}

Add the seed initializer

Add the seed initializer to the Main method in the Program.cs file:

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using MvcMovie.Models;
using System;

namespace MvcMovie
{
public class Program
{
public static void Main(string[] args)
{
var host = BuildWebHost(args);

using (var scope = host.Services.CreateScope())

{
var services = scope.ServiceProvider;

try
{
// Requires using RazorPagesMovie.Models;
SeedData.Initialize(services);
}
catch (Exception ex)
{
var logger = services.GetRequiredService<ILogger<Program>>();
logger.LogError(ex, "An error occurred seeding the DB.");
}
}

host.Run();
}

public static IWebHost BuildWebHost(string[] args) =>

WebHost.CreateDefaultBuilder(args)
.UseStartup<Startup>()
.Build();
}
}

Test the app

Delete all the records in the DB (So the seed method will run). Stop and start the app to seed the database.
The app shows the seeded data.
P R E V IO U S - A D D A N E X T - C ON TROL L E R M E THOD S A N D
M ODEL V IE W S
 Controller methods and views
9/20/2017 8 min to read Edit Online

By Rick Anderson
We have a good start to the movie app, but the presentation is not ideal. We don't want to see the time (12:00:00
AM in the image below) and ReleaseDate should be two words.

Open the Models/Movie.cs file and add the highlighted lines shown below:

using System;
using System.ComponentModel.DataAnnotations;

namespace MvcMovie.Models
{
public class Movie
{
public int ID { get; set; }
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
}
}

Build and run the app.

We'll cover DataAnnotations in the next tutorial. The Display attribute specifies what to display for the name of a
field (in this case "Release Date" instead of "ReleaseDate"). The DataType attribute specifies the type of the data
(Date), so the time information stored in the field is not displayed.
Browse to the Movies controller and hold the mouse pointer over an Edit link to see the target URL.

The Edit, Details, and Delete links are generated by the MVC Core Anchor Tag Helper in the
Views/Movies/Index.cshtml file.

<a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |

<a asp-action="Details" asp-route-id="@item.ID">Details</a> |
<a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>

Tag Helpers enable server-side code to participate in creating and rendering HTML elements in Razor files. In the
code above, the AnchorTagHelper dynamically generates the HTML href attribute value from the controller action
method and route id. You use View Source from your favorite browser or use the developer tools to examine the
generated markup. A portion of the generated HTML is shown below:

<td>
<a href="/Movies/Edit/4"> Edit </a> |
<a href="/Movies/Details/4"> Details </a> |
<a href="/Movies/Delete/4"> Delete </a>
</td>

Recall the format for routing set in the Startup.cs file:

 app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

ASP.NET Core translates http://localhost:1234/Movies/Edit/4 into a request to the Edit action method of the
Movies controller with the parameter Id of 4. (Controller methods are also known as action methods.)

Tag Helpers are one of the most popular new features in ASP.NET Core. See Additional resources for more
information.
Open the Movies controller and examine the two Edit action methods. The following code shows the
HTTP GET Edit method, which fetches the movie and populates the edit form generated by the Edit.cshtml Razor
file.

// GET: Movies/Edit/5
public async Task<IActionResult> Edit(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie.SingleOrDefaultAsync(m => m.ID == id);

if (movie == null)
{
return NotFound();
}
return View(movie);
}

The following code shows the HTTP POST Edit method, which processes the posted movie values:
 // POST: Movies/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("ID,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (id != movie.ID)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.ID))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction("Index");
}
return View(movie);
}

The [Bind] attribute is one way to protect against over-posting. You should only include properties in the [Bind]
attribute that you want to change. See Protect your controller from over-posting for more information.
ViewModels provide an alternative approach to prevent over-posting.
Notice the second Edit action method is preceded by the [HttpPost] attribute.
 // POST: Movies/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("ID,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (id != movie.ID)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.ID))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction("Index");
}
return View(movie);
}

The HttpPost attribute specifies that this Edit method can be invoked only for POST requests. You could apply
the [HttpGet] attribute to the first edit method, but that's not necessary because [HttpGet] is the default.

The ValidateAntiForgeryToken attribute is used to prevent forgery of a request and is paired up with an anti-
forgery token generated in the edit view file (Views/Movies/Edit.cshtml). The edit view file generates the anti-
forgery token with the Form Tag Helper.

<form asp-action="Edit">

The Form Tag Helper generates a hidden anti-forgery token that must match the [ValidateAntiForgeryToken]
generated anti-forgery token in the Edit method of the Movies controller. For more information, see Anti-
Request Forgery.
The method takes the movie ID parameter, looks up the movie using the Entity Framework
HttpGet Edit
SingleOrDefaultAsync method, and returns the selected movie to the Edit view. If a movie cannot be found,
NotFound (HTTP 404) is returned.
 // GET: Movies/Edit/5
public async Task<IActionResult> Edit(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie.SingleOrDefaultAsync(m => m.ID == id);

if (movie == null)
{
return NotFound();
}
return View(movie);
}

When the scaffolding system created the Edit view, it examined the Movie class and created code to render
<label> and <input> elements for each property of the class. The following example shows the Edit view that
was generated by the Visual Studio scaffolding system:
 @model MvcMovie.Models.Movie

@{
ViewData["Title"] = "Edit";
}

<h2>Edit</h2>

<form asp-action="Edit">
<div class="form-horizontal">
<h4>Movie</h4>
<hr />
<div asp-validation-summary="ModelOnly" class="text-danger"></div>
<input type="hidden" asp-for="ID" />
<div class="form-group">
<label asp-for="Title" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Title" class="form-control" />
<span asp-validation-for="Title" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<label asp-for="ReleaseDate" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="ReleaseDate" class="form-control" />
<span asp-validation-for="ReleaseDate" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<label asp-for="Genre" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Genre" class="form-control" />
<span asp-validation-for="Genre" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<label asp-for="Price" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Price" class="form-control" />
<span asp-validation-for="Price" class="text-danger"></span>
</div>
</div>
<div class="form-group">
<div class="col-md-offset-2 col-md-10">
<input type="submit" value="Save" class="btn btn-default" />
</div>
</div>
</div>
</form>

<div>
<a asp-action="Index">Back to List</a>
</div>

@section Scripts {
@{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

Notice how the view template has a @model MvcMovie.Models.Movie statement at the top of the file.
@model MvcMovie.Models.Movie specifies that the view expects the model for the view template to be of type Movie .
The scaffolded code uses several Tag Helper methods to streamline the HTML markup. The - Label Tag Helper
displays the name of the field ("Title", "ReleaseDate", "Genre", or "Price"). The Input Tag Helper renders an HTML
<input> element. The Validation Tag Helper displays any validation messages associated with that property.
Run the application and navigate to the /Movies URL. Click an Edit link. In the browser, view the source for the
page. The generated HTML for the <form> element is shown below.

<form action="/Movies/Edit/7" method="post">

<div class="form-horizontal">
<h4>Movie</h4>
<hr />
<div class="text-danger" />
<input type="hidden" data-val="true" data-val-required="The ID field is required." id="ID" name="ID"
value="7" />
<div class="form-group">
<label class="control-label col-md-2" for="Genre" />
<div class="col-md-10">
<input class="form-control" type="text" id="Genre" name="Genre" value="Western" />
<span class="text-danger field-validation-valid" data-valmsg-for="Genre" data-valmsg-
replace="true"></span>
</div>
</div>
<div class="form-group">
<label class="control-label col-md-2" for="Price" />
<div class="col-md-10">
<input class="form-control" type="text" data-val="true" data-val-number="The field Price must
be a number." data-val-required="The Price field is required." id="Price" name="Price" value="3.99" />
<span class="text-danger field-validation-valid" data-valmsg-for="Price" data-valmsg-
replace="true"></span>
</div>
</div>
<!-- Markup removed for brevity -->
<div class="form-group">
<div class="col-md-offset-2 col-md-10">
<input type="submit" value="Save" class="btn btn-default" />
</div>
</div>
</div>
<input name="__RequestVerificationToken" type="hidden"
value="CfDJ8Inyxgp63fRFqUePGvuI5jGZsloJu1L7X9le1gy7NCIlSduCRx9jDQClrV9pOTTmqUyXnJBXhmrjcUVDJyDUMm7-
MF_9rK8aAZdRdlOri7FmKVkRe_2v5LIHGKFcTjPrWPYnc9AdSbomkiOSaTEg7RU" />
</form>

The <input> elements are in an HTML <form> element whose action attribute is set to post to the
/Movies/Edit/id URL. The form data will be posted to the server when the Save button is clicked. The last line
before the closing </form> element shows the hidden XSRF token generated by the Form Tag Helper.

Processing the POST Request

The following listing shows the [HttpPost] version of the Edit action method.
 // POST: Movies/Edit/5
// To protect from overposting attacks, please enable the specific properties you want to bind to, for
// more details see http://go.microsoft.com/fwlink/?LinkId=317598.
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Edit(int id, [Bind("ID,Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (id != movie.ID)
{
return NotFound();
}

if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.ID))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction("Index");
}
return View(movie);
}

The [ValidateAntiForgeryToken] attribute validates the hidden XSRF token generated by the anti-forgery token
generator in the Form Tag Helper
The model binding system takes the posted form values and creates a Movie object that's passed as the movie
parameter. The ModelState.IsValid method verifies that the data submitted in the form can be used to modify
(edit or update) a Movie object. If the data is valid it's saved. The updated (edited) movie data is saved to the
database by calling the SaveChangesAsync method of database context. After saving the data, the code redirects the
user to the Index action method of the MoviesController class, which displays the movie collection, including the
changes just made.
Before the form is posted to the server, client side validation checks any validation rules on the fields. If there are
any validation errors, an error message is displayed and the form is not posted. If JavaScript is disabled, you won't
have client side validation but the server will detect the posted values that are not valid, and the form values will be
redisplayed with error messages. Later in the tutorial we examine Model Validation in more detail. The Validation
Tag Helper in the Views/Movies/Edit.cshtml view template takes care of displaying appropriate error messages.
All the HttpGet methods in the movie controller follow a similar pattern. They get a movie object (or list of objects,
in the case of Index ), and pass the object (model) to the view. The Create method passes an empty movie object
to the Create view. All the methods that create, edit, delete, or otherwise modify data do so in the [HttpPost]
overload of the method. Modifying data in an HTTP GET method is a security risk. Modifying data in an HTTP GET
method also violates HTTP best practices and the architectural REST pattern, which specifies that GET requests
should not change the state of your application. In other words, performing a GET operation should be a safe
operation that has no side effects and doesn't modify your persisted data.

Additional resources
Globalization and localization
Introduction to Tag Helpers
Authoring Tag Helpers
Anti-Request Forgery
Protect your controller from over-posting
ViewModels
Form Tag Helper
Input Tag Helper
Label Tag Helper
Select Tag Helper
Validation Tag Helper

P R E V IO U S - W O R K IN G W IT H NE X T - ADD
S Q L IT E SE A RCH
 Adding Search to an ASP.NET Core MVC app
7/5/2017 7 min to read Edit Online

By Rick Anderson
In this section you add search capability to the Index action method that lets you search movies by genre or
name.
Update the Index method with the following code:

public async Task<IActionResult> Index(string searchString)

{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

return View(await movies.ToListAsync());

}

The first line of the Index action method creates a LINQ query to select the movies:

var movies = from m in _context.Movie

select m;

The query is only defined at this point, it has not been run against the database.
If the searchString parameter contains a string, the movies query is modified to filter on the value of the search
string:

if (!String.IsNullOrEmpty(id))
{
movies = movies.Where(s => s.Title.Contains(id));
}

The s => s.Title.Contains() code above is a Lambda Expression. Lambdas are used in method-based LINQ
queries as arguments to standard query operator methods such as the Where method or Contains (used in the
code above). LINQ queries are not executed when they are defined or when they are modified by calling a method
such as Where , Contains or OrderBy . Rather, query execution is deferred. That means that the evaluation of an
expression is delayed until its realized value is actually iterated over or the ToListAsync method is called. For more
information about deferred query execution, see Query Execution.
Note: The Contains method is run on the database, not in the c# code shown above. The case sensitivity on the
query depends on the database and the collation. On SQL Server, Contains maps to SQL LIKE, which is case
insensitive. In SQLlite, with the default collation, it's case sensitive.
Navigate to /Movies/Index . Append a query string such as ?searchString=Ghost to the URL. The filtered movies
are displayed.
If you change the signature of the Index method to have a parameter named id , the id parameter will match
the optional {id} placeholder for the default routes set in Startup.cs.

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

Note: SQLlite is case sensitive, so you'll need to search for "Ghost" and not "ghost".
The previous Index method:

public async Task<IActionResult> Index(string searchString)

{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

return View(await movies.ToListAsync());

}

The updated Index method with id parameter:

public async Task<IActionResult> Index(string id)

{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(id))
{
movies = movies.Where(s => s.Title.Contains(id));
}

return View(await movies.ToListAsync());

}
You can now pass the search title as route data (a URL segment) instead of as a query string value.

However, you can't expect users to modify the URL every time they want to search for a movie. So now you'll add
UI to help them filter movies. If you changed the signature of the Index method to test how to pass the route-
bound ID parameter, change it back so that it takes a parameter named searchString :

public async Task<IActionResult> Index(string searchString)

{
var movies = from m in _context.Movie
select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

return View(await movies.ToListAsync());

}

Open the Views/Movies/Index.cshtml file, and add the <form> markup highlighted below:

ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-action="Create">Create New</a>
</p>

<form asp-controller="Movies" asp-action="Index">

<p>
Title: <input type="text" name="SearchString">
<input type="submit" value="Filter" />
</p>
</form>

<table class="table">
<thead>
The HTML <form> tag uses the Form Tag Helper, so when you submit the form, the filter string is posted to the
Index action of the movies controller. Save your changes and then test the filter.

There's no [HttpPost] overload of the Index method as you might expect. You don't need it, because the method
isn't changing the state of the app, just filtering data.
You could add the following [HttpPost] Index method.

[HttpPost]
public string Index(string searchString, bool notUsed)
{
return "From [HttpPost]Index: filter on " + searchString;
}

The notUsed parameter is used to create an overload for the Index method. We'll talk about that later in the
tutorial.
If you add this method, the action invoker would match the [HttpPost] Index method, and the [HttpPost] Index
method would run as shown in the image below.

However, even if you add this [HttpPost] version of the Index method, there's a limitation in how this has all
been implemented. Imagine that you want to bookmark a particular search or you want to send a link to friends
that they can click in order to see the same filtered list of movies. Notice that the URL for the HTTP POST request is
the same as the URL for the GET request (localhost:xxxxx/Movies/Index) -- there's no search information in the
URL. The search string information is sent to the server as a form field value. You can verify that with the browser
Developer tools or the excellent Fiddler tool. The image below shows the Chrome browser Developer tools:

You can see the search parameter and XSRF token in the request body. Note, as mentioned in the previous tutorial,
the Form Tag Helper generates an XSRF anti-forgery token. We're not modifying data, so we don't need to validate
the token in the controller method.
Because the search parameter is in the request body and not the URL, you can't capture that search information to
bookmark or share with others. We'll fix this by specifying the request should be HTTP GET .
Change the <form> tag in the Views\movie\Index.cshtml Razor view to specify method="get" :
 <form asp-controller="Movies" asp-action="Index" method="get">

Now when you submit a search, the URL contains the search query string. Searching will also go to the
HttpGet Index action method, even if you have a HttpPost Index method.

The following markup shows the change to the form tag:

<form asp-controller="Movies" asp-action="Index" method="get">

Adding Search by genre

Add the following MovieGenreViewModel class to the Models folder:

using Microsoft.AspNetCore.Mvc.Rendering;
using System.Collections.Generic;

namespace MvcMovie.Models
{
public class MovieGenreViewModel
{
public List<Movie> movies;
public SelectList genres;
public string movieGenre { get; set; }
}
}

The movie-genre view model will contain:

A list of movies.
A SelectList containing the list of genres. This will allow the user to select a genre from the list.
movieGenre , which contains the selected genre.

Replace the Index method in MoviesController.cs with the following code:

 // Requires using Microsoft.AspNetCore.Mvc.Rendering;
public async Task<IActionResult> Index(string movieGenre, string searchString)
{
// Use LINQ to get list of genres.
IQueryable<string> genreQuery = from m in _context.Movie
orderby m.Genre
select m.Genre;

var movies = from m in _context.Movie

select m;

if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Title.Contains(searchString));
}

if (!String.IsNullOrEmpty(movieGenre))
{
movies = movies.Where(x => x.Genre == movieGenre);
}

var movieGenreVM = new MovieGenreViewModel();

movieGenreVM.genres = new SelectList(await genreQuery.Distinct().ToListAsync());
movieGenreVM.movies = await movies.ToListAsync();

return View(movieGenreVM);
}

The following code is a LINQ query that retrieves all the genres from the database.

// Use LINQ to get list of genres.

IQueryable<string> genreQuery = from m in _context.Movie
orderby m.Genre
select m.Genre;

The SelectList of genres is created by projecting the distinct genres (we don't want our select list to have
duplicate genres).

movieGenreVM.genres = new SelectList(await genreQuery.Distinct().ToListAsync())

Adding search by genre to the Index view

Update Index.cshtml as follows:
@model MvcMovie.Models.MovieGenreViewModel

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-action="Create">Create New</a>
</p>

<form asp-controller="Movies" asp-action="Index" method="get">

<p>
<select asp-for="movieGenre" asp-items="Model.genres">
<option value="">All</option>
</select>

Title: <input type="text" name="SearchString">

<input type="submit" value="Filter" />
</p>
</form>

<table class="table">
<thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.movies[0].Title)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].ReleaseDate)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Genre)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Price)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model.movies)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
<a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
<a asp-action="Details" asp-route-id="@item.ID">Details</a> |
<a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>
}
</tbody>
</table>
Examine the lambda expression used in the following HTML Helper:
@Html.DisplayNameFor(model => model.movies[0].Title)

In the preceding code, the DisplayNameFor HTML Helper inspects the Title property referenced in the lambda
expression to determine the display name. Since the lambda expression is inspected rather than evaluated, you
don't receive an access violation when model , model.movies , or model.movies[0] are null or empty. When the
lambda expression is evaluated (for example, @Html.DisplayFor(modelItem => item.Title) ), the model's property
values are evaluated.
Test the app by searching by genre, by movie title, and by both.

P R E V IO U S - C O N T R O L L E R M E T H O D S A N D NE X T - ADD A
V IE W S F IE L D
 Adding a new field
9/22/2017 3 min to read Edit Online

By Rick Anderson
This tutorial will add a new field to the Movies table. We'll drop the database and create a new one when we
change the schema (add a new field). This workflow works well early in development when we don't have any
production data to perserve.
Once your app is deployed and you have data that you need to perserve, you can't drop your DB when you need to
change the schema. Entity Framework Code First Migrations allows you to update your schema and migrate the
database without losing data. Migrations is a popular feature when using SQL Server, but SQLlite does not support
many migration schema operations, so only very simply migrations are possible. See SQLite Limitations for more
information.

Adding a Rating Property to the Movie Model

Open the Models/Movie.cs file and add a Rating property:

public class Movie

{
public int ID { get; set; }
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }
public string Genre { get; set; }
public decimal Price { get; set; }
public string Rating { get; set; }
}

Because you've added a new field to the Movie class, you also need to update the binding whitelist so this new
property will be included. In MoviesController.cs, update the [Bind] attribute for both the Create and Edit
action methods to include the Rating property:

[Bind("ID,Title,ReleaseDate,Genre,Price,Rating")]

You also need to update the view templates in order to display, create, and edit the new Rating property in the
browser view.
Edit the /Views/Movies/Index.cshtml file and add a Rating field:
 <table class="table">
<thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.movies[0].Title)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].ReleaseDate)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Genre)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Price)
</th>
<th>
@Html.DisplayNameFor(model => model.movies[0].Rating)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model.movies)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.ReleaseDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Genre)
</td>
<td>
@Html.DisplayFor(modelItem => item.Price)
</td>
<td>
@Html.DisplayFor(modelItem => item.Rating)
</td>
<td>

Update the /Views/Movies/Create.cshtml with a Rating field.

The app won't work until we update the DB to include the new field. If you run it now, you'll get the following
SqliteException :

SqliteException: SQLite Error 1: 'no such column: m.Rating'.

You're seeing this error because the updated Movie model class is different than the schema of the Movie table of
the existing database. (There's no Rating column in the database table.)
There are a few approaches to resolving the error:
1. Drop the database and have the Entity Framework automatically re-create the database based on the new
model class schema. With this approach, you lose existing data in the database so you can't do this with a
production database! Using an initializer to automatically seed a database with test data is often a
productive way to develop an app.
2. Manually modify the schema of the existing database so that it matches the model classes. The advantage of
this approach is that you keep your data. You can make this change either manually or by creating a
database change script.
3. Use Code First Migrations to update the database schema.
For this tutorial, we'll drop and re-create the database when the schema changes. Run the following command
from a terminal to drop the db:
dotnet ef database drop

Update the SeedData class so that it provides a value for the new column. A sample change is shown below, but
you'll want to make this change for each new Movie .

new Movie
{
Title = "When Harry Met Sally",
ReleaseDate = DateTime.Parse("1989-1-11"),
Genre = "Romantic Comedy",
Rating = "R",
Price = 7.99M
},

Add the Rating field to the Edit , Details , and Delete view.
Run the app and verify you can create/edit/display movies with a Rating field. templates.

P R E V IO U S - A D D NE X T - ADD
SE A RCH V A L ID A T IO N
 Adding validation
9/22/2017 9 min to read Edit Online

By Rick Anderson
In this section you'll add validation logic to the Movie model, and you'll ensure that the validation rules are
enforced any time a user creates or edits a movie.

Keeping things DRY

One of the design tenets of MVC is DRY ("Don't Repeat Yourself"). ASP.NET MVC encourages you to specify
functionality or behavior only once, and then have it be reflected everywhere in an app. This reduces the amount of
code you need to write and makes the code you do write less error prone, easier to test, and easier to maintain.
The validation support provided by MVC and Entity Framework Core Code First is a good example of the DRY
principle in action. You can declaratively specify validation rules in one place (in the model class) and the rules are
enforced everywhere in the app.

Adding validation rules to the movie model

Open the Movie.cs file. DataAnnotations provides a built-in set of validation attributes that you apply declaratively
to any class or property. (It also contains formatting attributes like DataType that help with formatting and don't
provide any validation.)
Update the Movie class to take advantage of the built-in Required , StringLength , RegularExpression , and Range
validation attributes.

public class Movie

{
public int ID { get; set; }

[StringLength(60, MinimumLength = 3)]

[Required]
public string Title { get; set; }

[Display(Name = "Release Date")]

[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }

[Range(1, 100)]
[DataType(DataType.Currency)]
public decimal Price { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$")]
[Required]
[StringLength(30)]
public string Genre { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$")]
[StringLength(5)]
[Required]
public string Rating { get; set; }
}

The validation attributes specify behavior that you want to enforce on the model properties they are applied to. The
Required and MinimumLength attributes indicates that a property must have a value; but nothing prevents a user
from entering white space to satisfy this validation. The RegularExpression attribute is used to limit what
characters can be input. In the code above, Genre and Rating must use only letters (white space, numbers and
special characters are not allowed). The Range attribute constrains a value to within a specified range. The
StringLength attribute lets you set the maximum length of a string property, and optionally its minimum length.
Value types (such as decimal , int , float , DateTime ) are inherently required and don't need the [Required]
attribute.
Having validation rules automatically enforced by ASP.NET helps make your app more robust. It also ensures that
you can't forget to validate something and inadvertently let bad data into the database.

Validation Error UI in MVC

Run the app and navigate to the Movies controller.
Tap the Create New link to add a new movie. Fill out the form with some invalid values. As soon as jQuery client
side validation detects the error, it displays an error message.
 NOTE
You may not be able to enter decimal commas in the Price field. To support jQuery validation for non-English locales that
use a comma (",") for a decimal point, and non US-English date formats, you must take steps to globalize your app. This
GitHub issue 4076 for instructions on adding decimal comma.

Notice how the form has automatically rendered an appropriate validation error message in each field containing
an invalid value. The errors are enforced both client-side (using JavaScript and jQuery) and server-side (in case a
user has JavaScript disabled).
A significant benefit is that you didn't need to change a single line of code in the MoviesController class or in the
Create.cshtml view in order to enable this validation UI. The controller and views you created earlier in this tutorial
automatically picked up the validation rules that you specified by using validation attributes on the properties of
the Movie model class. Test validation using the Edit action method, and the same validation is applied.
The form data is not sent to the server until there are no client side validation errors. You can verify this by putting
a break point in the HTTP Post method, by using the Fiddler tool , or the F12 Developer tools.

How validation works

You might wonder how the validation UI was generated without any updates to the code in the controller or views.
The following code shows the two Create methods.

// GET: Movies/Create
public IActionResult Create()
{
return View();
}

// POST: Movies/Create
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Create(
[Bind("ID,Title,ReleaseDate,Genre,Price, Rating")] Movie movie)
{
if (ModelState.IsValid)
{
_context.Add(movie);
await _context.SaveChangesAsync();
return RedirectToAction("Index");
}
return View(movie);
}

The first (HTTP GET) Create action method displays the initial Create form. The second ( [HttpPost] ) version
handles the form post. The second Create method (The [HttpPost] version) calls ModelState.IsValid to check
whether the movie has any validation errors. Calling this method evaluates any validation attributes that have been
applied to the object. If the object has validation errors, the Create method re-displays the form. If there are no
errors, the method saves the new movie in the database. In our movie example, the form is not posted to the
server when there are validation errors detected on the client side; the second Create method is never called
when there are client side validation errors. If you disable JavaScript in your browser, client validation is disabled
and you can test the HTTP POST Create method ModelState.IsValid detecting any validation errors.
You can set a break point in the [HttpPost] Create method and verify the method is never called, client side
validation will not submit the form data when validation errors are detected. If you disable JavaScript in your
browser, then submit the form with errors, the break point will be hit. You still get full validation without
JavaScript.
The following image shows how to disable JavaScript in the FireFox browser.

The following image shows how to disable JavaScript in the Chrome browser.

After you disable JavaScript, post invalid data and step through the debugger.
Below is portion of the Create.cshtml view template that you scaffolded earlier in the tutorial. It's used by the action
methods shown above both to display the initial form and to redisplay it in the event of an error.

<form asp-action="Create">
<div class="form-horizontal">
<h4>Movie</h4>
<hr />

<div asp-validation-summary="ModelOnly" class="text-danger"></div>

<div class="form-group">
<label asp-for="Title" class="col-md-2 control-label"></label>
<div class="col-md-10">
<input asp-for="Title" class="form-control" />
<span asp-validation-for="Title" class="text-danger"></span>
</div>
</div>

@*Markup removed for brevity.*@

</div>
</form>

The Input Tag Helper uses the DataAnnotations attributes and produces HTML attributes needed for jQuery
Validation on the client side. The Validation Tag Helper displays validation errors. See Validation for more
information.
What's really nice about this approach is that neither the controller nor the Create view template knows anything
about the actual validation rules being enforced or about the specific error messages displayed. The validation
rules and the error strings are specified only in the Movie class. These same validation rules are automatically
applied to the Edit view and any other views templates you might create that edit your model.
When you need to change validation logic, you can do so in exactly one place by adding validation attributes to the
model (in this example, the Movie class). You won't have to worry about different parts of the application being
inconsistent with how the rules are enforced all validation logic will be defined in one place and used
everywhere. This keeps the code very clean, and makes it easy to maintain and evolve. And it means that you'll be
fully honoring the DRY principle.

Using DataType Attributes

Open the Movie.cs file and examine the Movie class. The System.ComponentModel.DataAnnotations namespace
provides formatting attributes in addition to the built-in set of validation attributes. We've already applied a
DataType enumeration value to the release date and to the price fields. The following code shows the ReleaseDate
and Price properties with the appropriate DataType attribute.
 [Display(Name = "Release Date")]
[DataType(DataType.Date)]
public DateTime ReleaseDate { get; set; }

[Range(1, 100)]
[DataType(DataType.Currency)]
public decimal Price { get; set; }

The DataType attributes only provide hints for the view engine to format the data (and supply attributes such as
<a> for URL's and <a href="mailto:EmailAddress.com"> for email. You can use the RegularExpression attribute to
validate the format of the data. The DataType attribute is used to specify a data type that is more specific than the
database intrinsic type, they are not validation attributes. In this case we only want to keep track of the date, not the
time. The DataType Enumeration provides for many data types, such as Date, Time, PhoneNumber, Currency,
EmailAddress and more. The DataType attribute can also enable the application to automatically provide type-
specific features. For example, a mailto: link can be created for DataType.EmailAddress , and a date selector can be
provided for DataType.Date in browsers that support HTML5. The DataType attributes emits HTML 5 data-
(pronounced data dash) attributes that HTML 5 browsers can understand. The DataType attributes do not provide
any validation.
DataType.Date does not specify the format of the date that is displayed. By default, the data field is displayed
according to the default formats based on the server's CultureInfo .
The DisplayFormat attribute is used to explicitly specify the date format:

[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

public DateTime ReleaseDate { get; set; }

The ApplyFormatInEditMode setting specifies that the formatting should also be applied when the value is displayed
in a text box for editing. (You might not want that for some fields for example, for currency values, you probably
do not want the currency symbol in the text box for editing.)
You can use the DisplayFormat attribute by itself, but it's generally a good idea to use the DataType attribute. The
DataType attribute conveys the semantics of the data as opposed to how to render it on a screen, and provides the
following benefits that you don't get with DisplayFormat:
The browser can enable HTML5 features (for example to show a calendar control, the locale-appropriate
currency symbol, email links, etc.)
By default, the browser will render data using the correct format based on your locale.
The DataType attribute can enable MVC to choose the right field template to render the data (the
DisplayFormat if used by itself uses the string template).

NOTE
jQuery validation does not work with the Range attribute and DateTime . For example, the following code will always
display a client side validation error, even when the date is in the specified range:

[Range(typeof(DateTime), "1/1/1966", "1/1/2020")]

You will need to disable jQuery date validation to use the Range attribute with DateTime . It's generally not a good
practice to compile hard dates in your models, so using the Range attribute and DateTime is discouraged.
The following code shows combining attributes on one line:
 public class Movie
{
public int ID { get; set; }

[StringLength(60, MinimumLength = 3)]

public string Title { get; set; }

[Display(Name = "Release Date"), DataType(DataType.Date)]

public DateTime ReleaseDate { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$"), Required, StringLength(30)]

public string Genre { get; set; }

[Range(1, 100), DataType(DataType.Currency)]

public decimal Price { get; set; }

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$"), StringLength(5)]
public string Rating { get; set; }
}

In the next part of the series, we'll review the application and make some improvements to the automatically
generated Details and Delete methods.

Additional resources
Working with Forms
Globalization and localization
Introduction to Tag Helpers
Authoring Tag Helpers

P R E V IO U S - A D D A N E X T - E X A M IN E T H E D E T A IL S A N D D E L E T E
F IE L D M E THOD S
 Examining the Details and Delete methods
7/5/2017 3 min to read Edit Online

By Rick Anderson
Open the Movie controller and examine the Details method:

// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie

.SingleOrDefaultAsync(m => m.ID == id);
if (movie == null)
{
return NotFound();
}

return View(movie);
}

The MVC scaffolding engine that created this action method adds a comment showing an HTTP request that
invokes the method. In this case it's a GET request with three URL segments, the Movies controller, the Details
method and an id value. Recall these segments are defined in Startup.cs.

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

EF makes it easy to search for data using the SingleOrDefaultAsync method. An important security feature built
into the method is that the code verifies that the search method has found a movie before it tries to do anything
with it. For example, a hacker could introduce errors into the site by changing the URL created by the links from
http://localhost:xxxx/Movies/Details/1 to something like http://localhost:xxxx/Movies/Details/12345 (or some
other value that doesn't represent an actual movie). If you did not check for a null movie, the app would throw an
exception.
Examine the Delete and DeleteConfirmed methods.
 // GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}

var movie = await _context.Movie

.SingleOrDefaultAsync(m => m.ID == id);
if (movie == null)
{
return NotFound();
}

return View(movie);
}

// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var movie = await _context.Movie.SingleOrDefaultAsync(m => m.ID == id);
_context.Movie.Remove(movie);
await _context.SaveChangesAsync();
return RedirectToAction("Index");
}

Note that the HTTP GET Delete method doesn't delete the specified movie, it returns a view of the movie where
you can submit (HttpPost) the deletion. Performing a delete operation in response to a GET request (or for that
matter, performing an edit operation, create operation, or any other operation that changes data) opens up a
security hole.
The [HttpPost] method that deletes the data is named DeleteConfirmed to give the HTTP POST method a unique
signature or name. The two method signatures are shown below:

// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{

// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{

The common language runtime (CLR) requires overloaded methods to have a unique parameter signature (same
method name but different list of parameters). However, here you need two Delete methods -- one for GET and
one for POST -- that both have the same parameter signature. (They both need to accept a single integer as a
parameter.)
There are two approaches to this problem, one is to give the methods different names. That's what the
scaffolding mechanism did in the preceding example. However, this introduces a small problem: ASP.NET maps
segments of a URL to action methods by name, and if you rename a method, routing normally wouldn't be able
to find that method. The solution is what you see in the example, which is to add the ActionName("Delete")
attribute to the DeleteConfirmed method. That attribute performs mapping for the routing system so that a URL
that includes /Delete/ for a POST request will find the DeleteConfirmed method.
Another common work around for methods that have identical names and signatures is to artificially change the
signature of the POST method to include an extra (unused) parameter. That's what we did in a previous post
when we added the notUsed parameter. You could do the same thing here for the [HttpPost] Delete method:

// POST: Movies/Delete/6
[ValidateAntiForgeryToken]
public async Task<IActionResult> Delete(int id, bool notUsed)

Thanks for completing this introduction to ASP.NET Core MVC. We appreciate any comments you leave. Getting
started with MVC and EF Core is an excellent follow up to this tutorial.

P R E V IO U S
 Getting started with ASP.NET Core and Entity
Framework Core using Visual Studio
7/5/2017 1 min to read Edit Online

This series of tutorials teaches you how to create ASP.NET Core MVC web applications that use Entity Framework
Core for data access. The tutorials require Visual Studio 2017.
1. Getting started
2. Create, Read, Update, and Delete operations
3. Sorting, filtering, paging, and grouping
4. Migrations
5. Creating a complex data model
6. Reading related data
7. Updating related data
8. Handling concurrency conflicts
9. Inheritance
10. Advanced topics
 Getting started with ASP.NET Core MVC and Entity
Framework Core using Visual Studio (1 of 10)
9/22/2017 20 min to read Edit Online

By Tom Dykstra and Rick Anderson

The Contoso University sample web application demonstrates how to create ASP.NET Core 2.0 MVC web
applications using Entity Framework (EF) Core 2.0 and Visual Studio 2017.
The sample application is a web site for a fictional Contoso University. It includes functionality such as student
admission, course creation, and instructor assignments. This is the first in a series of tutorials that explain how to
build the Contoso University sample application from scratch.
Download or view the completed application.
EF Core 2.0 is the latest version of EF but does not yet have all the features of EF 6.x. For information about how
to choose between EF 6.x and EF Core, see EF Core vs. EF6.x. If you choose EF 6.x, see the previous version of this
tutorial series.

NOTE
For the ASP.NET Core 1.1 version of this tutorial, see the VS 2017 Update 2 version of this tutorial in PDF format.
For the Visual Studio 2015 version of this tutorial, see the VS 2015 version of ASP.NET Core documentation in PDF
format.

Prerequisites
Install the following:
.NET Core 2.0.0 SDK or later.
Visual Studio 2017 version 15.3 or later with the ASP.NET and web development workload.

Troubleshooting
If you run into a problem you can't resolve, you can generally find the solution by comparing your code to the
completed project. For a list of common errors and how to solve them, see the Troubleshooting section of the
last tutorial in the series. If you don't find what you need there, you can post a question to StackOverflow.com
for ASP.NET Core or EF Core.

TIP
This is a series of 10 tutorials, each of which builds on what is done in earlier tutorials. Consider saving a copy of the
project after each successful tutorial completion. Then if you run into problems, you can start over from the previous
tutorial instead of going back to the beginning of the whole series.

The Contoso University web application

The application you'll be building in these tutorials is a simple university web site.
Users can view and update student, course, and instructor information. Here are a few of the screens you'll
create.

The UI style of this site has been kept close to what's generated by the built-in templates, so that the tutorial can
focus mainly on how to use the Entity Framework.

Create an ASP.NET Core MVC web application

Open Visual Studio and create a new ASP.NET Core C# web project named "ContosoUniversity".
From the File menu, select New > Project.
From the left pane, select Installed > Visual C# > Web.
Select the ASP.NET Core Web Application project template.
 Enter ContosoUniversity as the name and click OK.

Wait for the New ASP.NET Core Web Application (.NET Core) dialog to appear
Select ASP.NET Core 2.0 and the Web Application (Model-View-Controller) template.
Note: This tutorial requires ASP.NET Core 2.0 and EF Core 2.0 or later -- make sure that ASP.NET Core
1.1 is not selected.
Make sure Authentication is set to No Authentication.
Click OK

Set up the site style

A few simple changes will set up the site menu, layout, and home page.
Open Views/Shared/_Layout.cshtml and make the following changes:
 Change each occurrence of "ContosoUniversity" to "Contoso University". There are three occurrences.
Add menu entries for Students, Courses, Instructors, and Departments, and delete the Contact menu
entry.
The changes are highlighted.

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>@ViewData["Title"] - Contoso University</title>

<environment names="Development">
<link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.css" />
<link rel="stylesheet" href="~/css/site.css" />
</environment>
<environment names="Staging,Production">
<link rel="stylesheet" href="https://ajax.aspnetcdn.com/ajax/bootstrap/3.3.7/css/bootstrap.min.css"
asp-fallback-href="~/lib/bootstrap/dist/css/bootstrap.min.css"
asp-fallback-test-class="sr-only" asp-fallback-test-property="position" asp-fallback-test-
value="absolute" />
<link rel="stylesheet" href="~/css/site.min.css" asp-append-version="true" />
</environment>
@Html.Raw(JavaScriptSnippet.FullScript)
</head>
<body>
<nav class="navbar navbar-inverse navbar-fixed-top">
<div class="container">
<div class="navbar-header">
<button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-
collapse">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a asp-area="" asp-controller="Home" asp-action="Index" class="navbar-brand">Contoso
University</a>
</div>
<div class="navbar-collapse collapse">
<ul class="nav navbar-nav">
<li><a asp-area="" asp-controller="Home" asp-action="Index">Home</a></li>
<li><a asp-area="" asp-controller="Home" asp-action="About">About</a></li>
<li><a asp-area="" asp-controller="Students" asp-action="Index">Students</a></li>
<li><a asp-area="" asp-controller="Courses" asp-action="Index">Courses</a></li>
<li><a asp-area="" asp-controller="Instructors" asp-action="Index">Instructors</a></li>
<li><a asp-area="" asp-controller="Departments" asp-action="Index">Departments</a></li>
</ul>
</div>
</div>
</nav>
<div class="container body-content">
@RenderBody()
<hr />
<footer>
<p>&copy; 2017 - Contoso University</p>
</footer>
</div>

<environment names="Development">
<script src="~/lib/jquery/dist/jquery.js"></script>
<script src="~/lib/bootstrap/dist/js/bootstrap.js"></script>
<script src="~/js/site.js" asp-append-version="true"></script>
</environment>
<environment names="Staging,Production">
<script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-2.2.0.min.js"
 <script src="https://ajax.aspnetcdn.com/ajax/jquery/jquery-2.2.0.min.js"
asp-fallback-src="~/lib/jquery/dist/jquery.min.js"
asp-fallback-test="window.jQuery"
crossorigin="anonymous"
integrity="sha384-K+ctZQ+LL8q6tP7I94W+qzQsfRV2a+AfHIi9k8z8l9ggpc8X+Ytst4yBo/hH+8Fk">
</script>
<script src="https://ajax.aspnetcdn.com/ajax/bootstrap/3.3.7/bootstrap.min.js"
asp-fallback-src="~/lib/bootstrap/dist/js/bootstrap.min.js"
asp-fallback-test="window.jQuery && window.jQuery.fn && window.jQuery.fn.modal"
crossorigin="anonymous"
integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa">
</script>
<script src="~/js/site.min.js" asp-append-version="true"></script>
</environment>

@RenderSection("Scripts", required: false)

</body>
</html>

In Views/Home/Index.cshtml, replace the contents of the file with the following code to replace the text about
ASP.NET and MVC with text about this application:

@{
ViewData["Title"] = "Home Page";
}

<div class="jumbotron">
<h1>Contoso University</h1>
</div>
<div class="row">
<div class="col-md-4">
<h2>Welcome to Contoso University</h2>
<p>
Contoso University is a sample application that
demonstrates how to use Entity Framework Core in an
ASP.NET Core MVC web application.
</p>
</div>
<div class="col-md-4">
<h2>Build it from scratch</h2>
<p>You can build the application by following the steps in a series of tutorials.</p>
<p><a class="btn btn-default" href="https://docs.asp.net/en/latest/data/ef-mvc/intro.html">See the
tutorial &raquo;</a></p>
</div>
<div class="col-md-4">
<h2>Download it</h2>
<p>You can download the completed project from GitHub.</p>
<p><a class="btn btn-default" href="https://github.com/aspnet/Docs/tree/master/aspnetcore/data/ef-
mvc/intro/samples/cu-final">See project source code &raquo;</a></p>
</div>
</div>

Press CTRL+F5 to run the project or choose Debug > Start Without Debugging from the menu. You see the
home page with tabs for the pages you'll create in these tutorials.
Entity Framework Core NuGet packages
To add EF Core support to a project, install the database provider that you want to target. This tutorial uses SQL
Server, and the provider package is Microsoft.EntityFrameworkCore.SqlServer. This package is included in the
Microsoft.AspNetCore.All metapackage, so you don't have to install it.
This package and its dependencies ( Microsoft.EntityFrameworkCore and
Microsoft.EntityFrameworkCore.Relational ) provide runtime support for EF. You'll add a tooling package later, in
the Migrations tutorial.
For information about other database providers that are available for Entity Framework Core, see Database
providers.

Create the data model

Next you'll create entity classes for the Contoso University application. You'll start with the following three
entities.
There's a one-to-many relationship between Student and Enrollment entities, and there's a one-to-many
relationship between Course and Enrollment entities. In other words, a student can be enrolled in any number
of courses, and a course can have any number of students enrolled in it.
In the following sections you'll create a class for each one of these entities.
The Student entity

In the Models folder, create a class file named Student.cs and replace the template code with the following code.

using System;
using System.Collections.Generic;

namespace ContosoUniversity.Models
{
public class Student
{
public int ID { get; set; }
public string LastName { get; set; }
public string FirstMidName { get; set; }
public DateTime EnrollmentDate { get; set; }

public ICollection<Enrollment> Enrollments { get; set; }

}
}

The ID property will become the primary key column of the database table that corresponds to this class. By
default, the Entity Framework interprets a property that's named ID or classnameID as the primary key.
The Enrollments property is a navigation property. Navigation properties hold other entities that are related to
this entity. In this case, the Enrollments property of a Student entity will hold all of the Enrollment entities
that are related to that Student entity. In other words, if a given Student row in the database has two related
Enrollment rows (rows that contain that student's primary key value in their StudentID foreign key column), that
Student entity's Enrollments navigation property will contain those two Enrollment entities.

If a navigation property can hold multiple entities (as in many-to-many or one-to-many relationships), its type
must be a list in which entries can be added, deleted, and updated, such as ICollection<T> . You can specify
ICollection<T> or a type such as List<T> or HashSet<T> . If you specify ICollection<T> , EF creates a
HashSet<T> collection by default.
The Enrollment entity

In the Models folder, create Enrollment.cs and replace the existing code with the following code:

namespace ContosoUniversity.Models
{
public enum Grade
{
A, B, C, D, F
}

public class Enrollment

{
public int EnrollmentID { get; set; }
public int CourseID { get; set; }
public int StudentID { get; set; }
public Grade? Grade { get; set; }

public Course Course { get; set; }

public Student Student { get; set; }
}
}

The EnrollmentID property will be the primary key; this entity uses the classnameID pattern instead of ID by
itself as you saw in the Student entity. Ordinarily you would choose one pattern and use it throughout your
data model. Here, the variation illustrates that you can use either pattern. In a later tutorial, you'll see how using
ID without classname makes it easier to implement inheritance in the data model.
The Grade property is an enum . The question mark after the Grade type declaration indicates that the Grade
property is nullable. A grade that's null is different from a zero grade -- null means a grade isn't known or hasn't
been assigned yet.
The StudentID property is a foreign key, and the corresponding navigation property is Student . An Enrollment
entity is associated with one Student entity, so the property can only hold a single Student entity (unlike the
Student.Enrollments navigation property you saw earlier, which can hold multiple Enrollment entities).

The CourseID property is a foreign key, and the corresponding navigation property is Course . An Enrollment
entity is associated with one Course entity.
Entity Framework interprets a property as a foreign key property if it's named
<navigation property name><primary key property name> (for example, StudentID for the Student navigation
property since the Student entity's primary key is ID ). Foreign key properties can also be named simply
<primary key property name> (for example, CourseID since the Course entity's primary key is CourseID ).

The Course entity

In the Models folder, create Course.cs and replace the existing code with the following code:

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
public class Course
{
[DatabaseGenerated(DatabaseGeneratedOption.None)]
public int CourseID { get; set; }
public string Title { get; set; }
public int Credits { get; set; }

public ICollection<Enrollment> Enrollments { get; set; }

}
}

The Enrollments property is a navigation property. A Course entity can be related to any number of
Enrollment entities.
We'll say more about the DatabaseGenerated attribute in a later tutorial in this series. Basically, this attribute lets
you enter the primary key for the course rather than having the database generate it.

Create the Database Context

The main class that coordinates Entity Framework functionality for a given data model is the database context
class. You create this class by deriving from the Microsoft.EntityFrameworkCore.DbContext class. In your code you
specify which entities are included in the data model. You can also customize certain Entity Framework behavior.
In this project, the class is named SchoolContext .
In the project folder, create a folder named Data.
In the Data folder create a new class file named SchoolContext.cs, and replace the template code with the
following code:
 using ContosoUniversity.Models;
using Microsoft.EntityFrameworkCore;

namespace ContosoUniversity.Data
{
public class SchoolContext : DbContext
{
public SchoolContext(DbContextOptions<SchoolContext> options) : base(options)
{
}

public DbSet<Course> Courses { get; set; }

public DbSet<Enrollment> Enrollments { get; set; }
public DbSet<Student> Students { get; set; }
}
}

This code creates a DbSet property for each entity set. In Entity Framework terminology, an entity set typically
corresponds to a database table, and an entity corresponds to a row in the table.
You could have omitted the DbSet<Enrollment> and DbSet<Course> statements and it would work the same. The
Entity Framework would include them implicitly because the Student entity references the Enrollment entity
and the Enrollment entity references the Course entity.
When the database is created, EF creates tables that have names the same as the DbSet property names.
Property names for collections are typically plural (Students rather than Student), but developers disagree about
whether table names should be pluralized or not. For these tutorials you'll override the default behavior by
specifying singular table names in the DbContext. To do that, add the following highlighted code after the last
DbSet property.

using ContosoUniversity.Models;
using Microsoft.EntityFrameworkCore;

namespace ContosoUniversity.Data
{
public class SchoolContext : DbContext
{
public SchoolContext(DbContextOptions<SchoolContext> options) : base(options)
{
}

public DbSet<Course> Courses { get; set; }

public DbSet<Enrollment> Enrollments { get; set; }
public DbSet<Student> Students { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder)

{
modelBuilder.Entity<Course>().ToTable("Course");
modelBuilder.Entity<Enrollment>().ToTable("Enrollment");
modelBuilder.Entity<Student>().ToTable("Student");
}
}
}

Register the context with dependency injection

ASP.NET Core implements dependency injection by default. Services (such as the EF database context) are
registered with dependency injection during application startup. Components that require these services (such
as MVC controllers) are provided these services via constructor parameters. You'll see the controller constructor
code that gets a context instance later in this tutorial.
To register SchoolContext as a service, open Startup.cs, and add the highlighted lines to the ConfigureServices
method.

public void ConfigureServices(IServiceCollection services)

{
services.AddDbContext<SchoolContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

services.AddMvc();
}

The name of the connection string is passed in to the context by calling a method on a DbContextOptionsBuilder
object. For local development, the ASP.NET Core configuration system reads the connection string from the
appsettings.json file.
Add using statements for ContosoUniversity.Data and Microsoft.EntityFrameworkCore namespaces, and then
build the project.

using ContosoUniversity.Data;
using Microsoft.EntityFrameworkCore;

Open the appsettings.json file and add a connection string as shown in the following example.

{
"ConnectionStrings": {
"DefaultConnection": "Server=
(localdb)\\mssqllocaldb;Database=ContosoUniversity1;Trusted_Connection=True;MultipleActiveResultSets=true"
},
"Logging": {
"IncludeScopes": false,
"LogLevel": {
"Default": "Warning"
}
}
}

SQL Server Express LocalDB

The connection string specifies a SQL Server LocalDB database. LocalDB is a lightweight version of the SQL
Server Express Database Engine and is intended for application development, not production use. LocalDB starts
on demand and runs in user mode, so there is no complex configuration. By default, LocalDB creates .mdf
database files in the C:/Users/<user> directory.

Add code to initialize the database with test data

The Entity Framework will create an empty database for you. In this section, you write a method that is called
after the database is created in order to populate it with test data.
Here you'll use the EnsureCreated method to automatically create the database. In a later tutorial you'll see how
to handle model changes by using Code First Migrations to change the database schema instead of dropping
and re-creating the database.
In the Data folder, create a new class file named DbInitializer.cs and replace the template code with the following
code, which causes a database to be created when needed and loads test data into the new database.

using ContosoUniversity.Models;
using System;
using System.Linq;
using System.Linq;

namespace ContosoUniversity.Data
{
public static class DbInitializer
{
public static void Initialize(SchoolContext context)
{
context.Database.EnsureCreated();

// Look for any students.

if (context.Students.Any())
{
return; // DB has been seeded
}

var students = new Student[]

{
new Student{FirstMidName="Carson",LastName="Alexander",EnrollmentDate=DateTime.Parse("2005-09-
01")},
new Student{FirstMidName="Meredith",LastName="Alonso",EnrollmentDate=DateTime.Parse("2002-09-
01")},
new Student{FirstMidName="Arturo",LastName="Anand",EnrollmentDate=DateTime.Parse("2003-09-01")},
new Student{FirstMidName="Gytis",LastName="Barzdukas",EnrollmentDate=DateTime.Parse("2002-09-
01")},
new Student{FirstMidName="Yan",LastName="Li",EnrollmentDate=DateTime.Parse("2002-09-01")},
new Student{FirstMidName="Peggy",LastName="Justice",EnrollmentDate=DateTime.Parse("2001-09-
01")},
new Student{FirstMidName="Laura",LastName="Norman",EnrollmentDate=DateTime.Parse("2003-09-01")},
new Student{FirstMidName="Nino",LastName="Olivetto",EnrollmentDate=DateTime.Parse("2005-09-01")}
};
foreach (Student s in students)
{
context.Students.Add(s);
}
context.SaveChanges();

var courses = new Course[]

{
new Course{CourseID=1050,Title="Chemistry",Credits=3},
new Course{CourseID=4022,Title="Microeconomics",Credits=3},
new Course{CourseID=4041,Title="Macroeconomics",Credits=3},
new Course{CourseID=1045,Title="Calculus",Credits=4},
new Course{CourseID=3141,Title="Trigonometry",Credits=4},
new Course{CourseID=2021,Title="Composition",Credits=3},
new Course{CourseID=2042,Title="Literature",Credits=4}
};
foreach (Course c in courses)
{
context.Courses.Add(c);
}
context.SaveChanges();

var enrollments = new Enrollment[]

{
new Enrollment{StudentID=1,CourseID=1050,Grade=Grade.A},
new Enrollment{StudentID=1,CourseID=4022,Grade=Grade.C},
new Enrollment{StudentID=1,CourseID=4041,Grade=Grade.B},
new Enrollment{StudentID=2,CourseID=1045,Grade=Grade.B},
new Enrollment{StudentID=2,CourseID=3141,Grade=Grade.F},
new Enrollment{StudentID=2,CourseID=2021,Grade=Grade.F},
new Enrollment{StudentID=3,CourseID=1050},
new Enrollment{StudentID=4,CourseID=1050},
new Enrollment{StudentID=4,CourseID=4022,Grade=Grade.F},
new Enrollment{StudentID=5,CourseID=4041,Grade=Grade.C},
new Enrollment{StudentID=6,CourseID=1045},
new Enrollment{StudentID=7,CourseID=3141,Grade=Grade.A},
};
foreach (Enrollment e in enrollments)
{
 {
context.Enrollments.Add(e);
}
context.SaveChanges();
}
}
}

The code checks if there are any students in the database, and if not, it assumes the database is new and needs to
be seeded with test data. It loads test data into arrays rather than List<T> collections to optimize performance.
In Program.cs, modify the Main method to do the following on application startup:
Get a database context instance from the dependency injection container.
Call the seed method, passing to it the context.
Dispose the context when the seed method is done.

public static void Main(string[] args)

{
var host = BuildWebHost(args);

using (var scope = host.Services.CreateScope())

{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService<SchoolContext>();
DbInitializer.Initialize(context);
}
catch (Exception ex)
{
var logger = services.GetRequiredService<ILogger<Program>>();
logger.LogError(ex, "An error occurred while seeding the database.");
}
}

host.Run();
}

Add using statements:

using Microsoft.Extensions.DependencyInjection;
using ContosoUniversity.Data;

In older tutorials, you may see similar code in the Configure method in Startup.cs. We recommend that you use
the Configure method only to set up the request pipeline. Application startup code belongs in the Main
method.
Now the first time you run the application, the database will be created and seeded with test data. Whenever you
change your data model, you can delete the database, update your seed method, and start afresh with a new
database the same way. In later tutorials, you'll see how to modify the database when the data model changes,
without deleting and re-creating it.

Create a controller and views

Next, you'll use the scaffolding engine in Visual Studio to add an MVC controller and views that will use EF to
query and save data.
The automatic creation of CRUD action methods and views is known as scaffolding. Scaffolding differs from
code generation in that the scaffolded code is a starting point that you can modify to suit your own
requirements, whereas you typically don't modify generated code. When you need to customize generated code,
you use partial classes or you regenerate the code when things change.
Right-click the Controllers folder in Solution Explorer and select Add > New Scaffolded Item.
In the Add MVC Dependencies dialog, select Minimal Dependencies, and select Add.

Visual Studio adds the dependencies needed to scaffold a controller. The only change in the project file is
the addition of the Microsoft.VisualStudio.Web.CodeGeneration.Design package.
A ScaffoldingReadMe.txt file is created which you can delete.
Once again, right-click the Controllers folder in Solution Explorer and select Add > New Scaffolded
Item.
In the Add Scaffold dialog box:
Select MVC controller with views, using Entity Framework.
Click Add.
In the Add Controller dialog box:
In Model class select Student.
In Data context class select SchoolContext.
Accept the default StudentsController as the name.
Click Add.

When you click Add, the Visual Studio scaffolding engine creates a StudentsController.cs file and a set of
views (.cshtml files) that work with the controller.
(The scaffolding engine can also create the database context for you if you don't create it manually first as you
did earlier for this tutorial. You can specify a new context class in the Add Controller box by clicking the plus
sign to the right of Data context class. Visual Studio will then create your DbContext class as well as the
controller and views.)
You'll notice that the controller takes a SchoolContext as a constructor parameter.

namespace ContosoUniversity.Controllers
{
public class StudentsController : Controller
{
private readonly SchoolContext _context;

public StudentsController(SchoolContext context)

{
_context = context;
}

ASP.NET dependency injection will take care of passing an instance of SchoolContext into the controller. You
configured that in the Startup.cs file earlier.
The controller contains an Index action method, which displays all students in the database. The method gets a
list of students from the Students entity set by reading the Students property of the database context instance:

public async Task<IActionResult> Index()

{
return View(await _context.Students.ToListAsync());
}

You'll learn about the asynchronous programming elements in this code later in the tutorial.
The Views/Students/Index.cshtml view displays this list in a table:
 @model IEnumerable<ContosoUniversity.Models.Student>

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-action="Create">Create New</a>
</p>
<table class="table">
<thead>
<tr>
<th>
@Html.DisplayNameFor(model => model.LastName)
</th>
<th>
@Html.DisplayNameFor(model => model.FirstMidName)
</th>
<th>
@Html.DisplayNameFor(model => model.EnrollmentDate)
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model) {
<tr>
<td>
@Html.DisplayFor(modelItem => item.LastName)
</td>
<td>
@Html.DisplayFor(modelItem => item.FirstMidName)
</td>
<td>
@Html.DisplayFor(modelItem => item.EnrollmentDate)
</td>
<td>
<a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
<a asp-action="Details" asp-route-id="@item.ID">Details</a> |
<a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>
}
</tbody>
</table>

Press CTRL+F5 to run the project or choose Debug > Start Without Debugging from the menu.
Click the Students tab to see the test data that the DbInitializer.Initialize method inserted. Depending on
how narrow your browser window is, you'll see the Student tab link at the top of the page or you'll have to click
the navigation icon in the upper right corner to see the link.
View the Database
When you started the application, the DbInitializer.Initialize method calls EnsureCreated . EF saw that there
was no database and so it created one, then the remainder of the Initialize method code populated the
database with data. You can use SQL Server Object Explorer (SSOX) to view the database in Visual Studio.
Close the browser.
If the SSOX window isn't already open, select it from the View menu in Visual Studio.
In SSOX, click (localdb)\MSSQLLocalDB > Databases, and then click the entry for the database name that is in
the connection string in your appsettings.json file.
Expand the Tables node to see the tables in your database.
Right-click the Student table and click View Data to see the columns that were created and the rows that were
inserted into the table.

The .mdf and .ldf database files are in the C:\Users<yourusername> folder.
Because you're calling EnsureCreated in the initializer method that runs on app start, you could now make a
change to the Student class, delete the database, run the application again, and the database would
automatically be re-created to match your change. For example, if you add an EmailAddress property to the
Student class, you'll see a new EmailAddress column in the re-created table.

Conventions
The amount of code you had to write in order for the Entity Framework to be able to create a complete database
for you is minimal because of the use of conventions, or assumptions that the Entity Framework makes.
The names of DbSet properties are used as table names. For entities not referenced by a DbSet property,
entity class names are used as table names.
Entity property names are used for column names.
Entity properties that are named ID or classnameID are recognized as primary key properties.
A property is interpreted as a foreign key property if it's named (for example, StudentID for the Student
navigation property since the Student entity's primary key is ID ). Foreign key properties can also be
named simply (for example, EnrollmentID since the Enrollment entity's primary key is EnrollmentID ).
Conventional behavior can be overridden. For example, you can explicitly specify table names, as you saw earlier
in this tutorial. And you can set column names and set any property as primary key or foreign key, as you'll see
in a later tutorial in this series.

Asynchronous code
Asynchronous programming is the default mode for ASP.NET Core and EF Core.
A web server has a limited number of threads available, and in high load situations all of the available threads
might be in use. When that happens, the server can't process new requests until the threads are freed up. With
synchronous code, many threads may be tied up while they aren't actually doing any work because they're
waiting for I/O to complete. With asynchronous code, when a process is waiting for I/O to complete, its thread is
freed up for the server to use for processing other requests. As a result, asynchronous code enables server
resources to be used more efficiently, and the server is enabled to handle more traffic without delays.
Asynchronous code does introduce a small amount of overhead at run time, but for low traffic situations the
performance hit is negligible, while for high traffic situations, the potential performance improvement is
substantial.
In the following code, the async keyword, Task<T> return value, await keyword, and ToListAsync method
make the code execute asynchronously.

public async Task<IActionResult> Index()

{
return View(await _context.Students.ToListAsync());
}

The async keyword tells the compiler to generate callbacks for parts of the method body and to
automatically create the Task<IActionResult> object that is returned.
The return type Task<IActionResult> represents ongoing work with a result of type IActionResult .
The await keyword causes the compiler to split the method into two parts. The first part ends with the
operation that is started asynchronously. The second part is put into a callback method that is called when
the operation completes.
ToListAsync is the asynchronous version of the ToList extension method.

Some things to be aware of when you are writing asynchronous code that uses the Entity Framework:
Only statements that cause queries or commands to be sent to the database are executed asynchronously.
That includes, for example, ToListAsync , SingleOrDefaultAsync , and SaveChangesAsync . It does not
include, for example, statements that just change an IQueryable , such as
var students = context.Students.Where(s => s.LastName == "Davolio") .

An EF context is not thread safe: don't try to do multiple operations in parallel. When you call any async EF
method, always use the await keyword.
If you want to take advantage of the performance benefits of async code, make sure that any library
packages that you're using (such as for paging), also use async if they call any Entity Framework methods
that cause queries to be sent to the database.
For more information about asynchronous programming in .NET, see Async Overview.

Summary
You've now created a simple application that uses the Entity Framework Core and SQL Server Express LocalDB
to store and display data. In the following tutorial, you'll learn how to perform basic CRUD (create, read, update,
delete) operations.

NEXT
 Create, Read, Update, and Delete - EF Core with
ASP.NET Core MVC tutorial (2 of 10)
9/22/2017 19 min to read Edit Online

By Tom Dykstra and Rick Anderson

The Contoso University sample web application demonstrates how to create ASP.NET Core MVC web applications
using Entity Framework Core and Visual Studio. For information about the tutorial series, see the first tutorial in
the series.
In the previous tutorial, you created an MVC application that stores and displays data using the Entity Framework
and SQL Server LocalDB. In this tutorial, you'll review and customize the CRUD (create, read, update, delete) code
that the MVC scaffolding automatically creates for you in controllers and views.

NOTE
It's a common practice to implement the repository pattern in order to create an abstraction layer between your controller
and the data access layer. To keep these tutorials simple and focused on teaching how to use the Entity Framework itself,
they don't use repositories. For information about repositories with EF, see the last tutorial in this series.

In this tutorial, you'll work with the following web pages:

Customize the Details page
The scaffolded code for the Students Index page left out the Enrollments property, because that property holds a
collection. In the Details page, you'll display the contents of the collection in an HTML table.
In Controllers/StudentsController.cs, the action method for the Details view uses the SingleOrDefaultAsync method
to retrieve a single Student entity. Add code that calls Include . ThenInclude , and AsNoTracking methods, as
shown in the following highlighted code.

public async Task<IActionResult> Details(int? id)

{
if (id == null)
{
return NotFound();
}

var student = await _context.Students

.Include(s => s.Enrollments)
.ThenInclude(e => e.Course)
.AsNoTracking()
.SingleOrDefaultAsync(m => m.ID == id);

if (student == null)
{
return NotFound();
}

return View(student);
}

The Include and ThenInclude methods cause the context to load the Student.Enrollments navigation property,
and within each enrollment the Enrollment.Course navigation property. You'll learn more about these methods in
the reading related data tutorial.
The AsNoTracking method improves performance in scenarios where the entities returned will not be updated in
the current context's lifetime. You'll learn more about AsNoTracking at the end of this tutorial.
Route data
The key value that is passed to the Details method comes from route data. Route data is data that the model
binder found in a segment of the URL. For example, the default route specifies controller, action, and id segments:

app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});

In the following URL, the default route maps Instructor as the controller, Index as the action, and 1 as the id; these
are route data values.

http://localhost:1230/Instructor/Index/1?courseID=2021

The last part of the URL ("?courseID=2021") is a query string value. The model binder will also pass the ID value to
the Details method id parameter if you pass it as a query string value:

http://localhost:1230/Instructor/Index?id=1&CourseID=2021

In the Index page, hyperlink URLs are created by tag helper statements in the Razor view. In the following Razor
code, the id parameter matches the default route, so id is added to the route data.

<a asp-action="Edit" asp-route-id="@item.ID">Edit</a>

This generates the following HTML when item.ID is 6:

<a href="/Students/Edit/6">Edit</a>

In the following Razor code, studentID doesn't match a parameter in the default route, so it's added as a query
string.

<a asp-action="Edit" asp-route-studentID="@item.ID">Edit</a>

This generates the following HTML when item.ID is 6:

<a href="/Students/Edit?studentID=6">Edit</a>

For more information about tag helpers, see Tag helpers in ASP.NET Core.
Add enrollments to the Details view
Open Views/Students/Details.cshtml. Each field is displayed using DisplayNameFor and DisplayFor helpers, as
shown in the following example:
 <dt>
@Html.DisplayNameFor(model => model.LastName)
</dt>
<dd>
@Html.DisplayFor(model => model.LastName)
</dd>

After the last field and immediately before the closing </dl> tag, add the following code to display a list of
enrollments:

<dt>
@Html.DisplayNameFor(model => model.Enrollments)
</dt>
<dd>
<table class="table">
<tr>
<th>Course Title</th>
<th>Grade</th>
</tr>
@foreach (var item in Model.Enrollments)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.Course.Title)
</td>
<td>
@Html.DisplayFor(modelItem => item.Grade)
</td>
</tr>
}
</table>
</dd>

If code indentation is wrong after you paste the code, press CTRL-K-D to correct it.
This code loops through the entities in the Enrollments navigation property. For each enrollment, it displays the
course title and the grade. The course title is retrieved from the Course entity that's stored in the Course
navigation property of the Enrollments entity.
Run the app, select the Students tab, and click the Details link for a student. You see the list of courses and
grades for the selected student:
Update the Create page
In StudentsController.cs, modify the HttpPost Create method by adding a try-catch block and removing ID from
the Bind attribute.

[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Create(
[Bind("EnrollmentDate,FirstMidName,LastName")] Student student)
{
try
{
if (ModelState.IsValid)
{
_context.Add(student);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists " +
"see your system administrator.");
}
return View(student);
}

This code adds the Student entity created by the ASP.NET MVC model binder to the Students entity set and then
saves the changes to the database. (Model binder refers to the ASP.NET MVC functionality that makes it easier for
you to work with data submitted by a form; a model binder converts posted form values to CLR types and passes
them to the action method in parameters. In this case, the model binder instantiates a Student entity for you using
property values from the Form collection.)
You removed ID from the Bind attribute because ID is the primary key value which SQL Server will set
automatically when the row is inserted. Input from the user does not set the ID value.
Other than the Bind attribute, the try-catch block is the only change you've made to the scaffolded code. If an
exception that derives from DbUpdateException is caught while the changes are being saved, a generic error
message is displayed. DbUpdateException exceptions are sometimes caused by something external to the
application rather than a programming error, so the user is advised to try again. Although not implemented in this
sample, a production quality application would log the exception. For more information, see the Log for insight
section in Monitoring and Telemetry (Building Real-World Cloud Apps with Azure).
The ValidateAntiForgeryToken attribute helps prevent cross-site request forgery (CSRF) attacks. The token is
automatically injected into the view by the FormTagHelper and is included when the form is submitted by the
user. The token is validated by the ValidateAntiForgeryToken attribute. For more information about CSRF, see
Anti-Request Forgery.
Security note about overposting
The Bind attribute that the scaffolded code includes on the Create method is one way to protect against
overposting in create scenarios. For example, suppose the Student entity includes a Secret property that you
don't want this web page to set.

public class Student

{
public int ID { get; set; }
public string LastName { get; set; }
public string FirstMidName { get; set; }
public DateTime EnrollmentDate { get; set; }
public string Secret { get; set; }
}

Even if you don't have a Secret field on the web page, a hacker could use a tool such as Fiddler, or write some
JavaScript, to post a Secret form value. Without the Bind attribute limiting the fields that the model binder uses
when it creates a Student instance, the model binder would pick up that Secret form value and use it to create
the Student entity instance. Then whatever value the hacker specified for the Secret form field would be updated
in your database. The following image shows the Fiddler tool adding the Secret field (with the value "OverPost")
to the posted form values.

The value "OverPost" would then be successfully added to the Secret property of the inserted row, although you
never intended that the web page be able to set that property.
You can prevent overposting in edit scenarios by reading the entity from the database first and then calling
TryUpdateModel , passing in an explicit allowed properties list. That is the method used in these tutorials.

An alternative way to prevent overposting that is preferred by many developers is to use view models rather than
entity classes with model binding. Include only the properties you want to update in the view model. Once the
MVC model binder has finished, copy the view model properties to the entity instance, optionally using a tool such
as AutoMapper. Use _context.Entry on the entity instance to set its state to Unchanged , and then set
Property("PropertyName").IsModified to true on each entity property that is included in the view model. This
method works in both edit and create scenarios.
Test the Create page
The code in Views/Students/Create.cshtml uses label , input , and span (for validation messages) tag helpers for
each field.
Run the app, select the Students tab, and click Create New.
Enter names and a date. Try entering an invalid date if your browser lets you do that. (Some browsers force you to
use a date picker.) Then click Create to see the error message.

This is server-side validation that you get by default; in a later tutorial you'll see how to add attributes that will
generate code for client-side validation also. The following highlighted code shows the model validation check in
the Create method.
 [HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Create(
[Bind("EnrollmentDate,FirstMidName,LastName")] Student student)
{
try
{
if (ModelState.IsValid)
{
_context.Add(student);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists " +
"see your system administrator.");
}
return View(student);
}

Change the date to a valid value and click Create to see the new student appear in the Index page.

Update the Edit page

In StudentController.cs, the HttpGet Edit method (the one without the HttpPost attribute) uses the
SingleOrDefaultAsync method to retrieve the selected Student entity, as you saw in the Details method. You
don't need to change this method.
Recommended HttpPost Edit code: Read and update
Replace the HttpPost Edit action method with the following code.
 [HttpPost, ActionName("Edit")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> EditPost(int? id)
{
if (id == null)
{
return NotFound();
}
var studentToUpdate = await _context.Students.SingleOrDefaultAsync(s => s.ID == id);
if (await TryUpdateModelAsync<Student>(
studentToUpdate,
"",
s => s.FirstMidName, s => s.LastName, s => s.EnrollmentDate))
{
try
{
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
}
}
return View(studentToUpdate);
}

These changes implement a security best practice to prevent overposting. The scaffolder generated a Bind
attribute and added the entity created by the model binder to the entity set with a Modified flag. That code is not
recommended for many scenarios because the Bind attribute clears out any pre-existing data in fields not listed
in the Include parameter.
The new code reads the existing entity and calls TryUpdateModel to update fields in the retrieved entity based on
user input in the posted form data. The Entity Framework's automatic change tracking sets the Modified flag on
the fields that are changed by form input. When the SaveChanges method is called, the Entity Framework creates
SQL statements to update the database row. Concurrency conflicts are ignored, and only the table columns that
were updated by the user are updated in the database. (A later tutorial shows how to handle concurrency
conflicts.)
As a best practice to prevent overposting, the fields that you want to be updateable by the Edit page are
whitelisted in the TryUpdateModel parameters. (The empty string preceding the list of fields in the parameter list is
for a prefix to use with the form fields names.) Currently there are no extra fields that you're protecting, but listing
the fields that you want the model binder to bind ensures that if you add fields to the data model in the future,
they're automatically protected until you explicitly add them here.
As a result of these changes, the method signature of the HttpPost Edit method is the same as the HttpGet Edit
method; therefore you've renamed the method EditPost .
Alternative HttpPost Edit code: Create and attach
The recommended HttpPost edit code ensures that only changed columns get updated and preserves data in
properties that you don't want included for model binding. However, the read-first approach requires an extra
database read, and can result in more complex code for handling concurrency conflicts. An alternative is to attach
an entity created by the model binder to the EF context and mark it as modified. (Don't update your project with
this code, it's only shown to illustrate an optional approach.)
 public async Task<IActionResult> Edit(int id, [Bind("ID,EnrollmentDate,FirstMidName,LastName")] Student
student)
{
if (id != student.ID)
{
return NotFound();
}
if (ModelState.IsValid)
{
try
{
_context.Update(student);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
}
}
return View(student);
}

You can use this approach when the web page UI includes all of the fields in the entity and can update any of
them.
The scaffolded code uses the create-and-attach approach but only catches DbUpdateConcurrencyException
exceptions and returns 404 error codes. The example shown catches any database update exception and displays
an error message.
Entity States
The database context keeps track of whether entities in memory are in sync with their corresponding rows in the
database, and this information determines what happens when you call the SaveChanges method. For example,
when you pass a new entity to the Add method, that entity's state is set to Added . Then when you call the
SaveChanges method, the database context issues a SQL INSERT command.

An entity may be in one of the following states:

Added . The entity does not yet exist in the database. The SaveChanges method issues an INSERT statement.
Unchanged . Nothing needs to be done with this entity by the SaveChanges method. When you read an
entity from the database, the entity starts out with this status.
. Some or all of the entity's property values have been modified. The
Modified SaveChanges method issues
an UPDATE statement.
Deleted . The entity has been marked for deletion. The SaveChanges method issues a DELETE statement.
Detached . The entity isn't being tracked by the database context.

In a desktop application, state changes are typically set automatically. You read an entity and make changes to
some of its property values. This causes its entity state to automatically be changed to Modified . Then when you
call SaveChanges , the Entity Framework generates a SQL UPDATE statement that updates only the actual
properties that you changed.
In a web app, the DbContext that initially reads an entity and displays its data to be edited is disposed after a page
is rendered. When the HttpPost Edit action method is called, a new web request is made and you have a new
instance of the DbContext . If you re-read the entity in that new context, you simulate desktop processing.
But if you don't want to do the extra read operation, you have to use the entity object created by the model binder.
The simplest way to do this is to set the entity state to Modified as is done in the alternative HttpPost Edit code
shown earlier. Then when you call SaveChanges , the Entity Framework updates all columns of the database row,
because the context has no way to know which properties you changed.
If you want to avoid the read-first approach, but you also want the SQL UPDATE statement to update only the
fields that the user actually changed, the code is more complex. You have to save the original values in some way
(such as by using hidden fields) so that they are available when the HttpPost Edit method is called. Then you can
create a Student entity using the original values, call the Attach method with that original version of the entity,
update the entity's values to the new values, and then call SaveChanges .
Test the Edit page
Run the app, select the Students tab, then click an Edit hyperlink.

Change some of the data and click Save. The Index page opens and you see the changed data.

Update the Delete page

In StudentController.cs, the template code for the HttpGet Delete method uses the SingleOrDefaultAsync method
to retrieve the selected Student entity, as you saw in the Details and Edit methods. However, to implement a
custom error message when the call to SaveChanges fails, you'll add some functionality to this method and its
corresponding view.
As you saw for update and create operations, delete operations require two action methods. The method that is
called in response to a GET request displays a view that gives the user a chance to approve or cancel the delete
operation. If the user approves it, a POST request is created. When that happens, the HttpPost Delete method is
called and then that method actually performs the delete operation.
You'll add a try-catch block to the HttpPost Delete method to handle any errors that might occur when the
database is updated. If an error occurs, the HttpPost Delete method calls the HttpGet Delete method, passing it a
parameter that indicates that an error has occurred. The HttpGet Delete method then redisplays the confirmation
page along with the error message, giving the user an opportunity to cancel or try again.
Replace the HttpGet Delete action method with the following code, which manages error reporting.

public async Task<IActionResult> Delete(int? id, bool? saveChangesError = false)

{
if (id == null)
{
return NotFound();
}

var student = await _context.Students

.AsNoTracking()
.SingleOrDefaultAsync(m => m.ID == id);
if (student == null)
{
return NotFound();
}

if (saveChangesError.GetValueOrDefault())
{
ViewData["ErrorMessage"] =
"Delete failed. Try again, and if the problem persists " +
"see your system administrator.";
}

return View(student);
}

This code accepts an optional parameter that indicates whether the method was called after a failure to save
changes. This parameter is false when the HttpGet Delete method is called without a previous failure. When it is
called by the HttpPost Delete method in response to a database update error, the parameter is true and an error
message is passed to the view.
The read-first approach to HttpPost Delete
Replace the HttpPost Delete action method (named DeleteConfirmed ) with the following code, which performs
the actual delete operation and catches any database update errors.
 [HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var student = await _context.Students
.AsNoTracking()
.SingleOrDefaultAsync(m => m.ID == id);
if (student == null)
{
return RedirectToAction(nameof(Index));
}

try
{
_context.Students.Remove(student);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
return RedirectToAction(nameof(Delete), new { id = id, saveChangesError = true });
}
}

This code retrieves the selected entity, then calls the Remove method to set the entity's status to Deleted . When
SaveChanges is called, a SQL DELETE command is generated.

The create -and-attach approach to HttpPost Delete

If improving performance in a high-volume application is a priority, you could avoid an unnecessary SQL query by
instantiating a Student entity using only the primary key value and then setting the entity state to Deleted . That's
all that the Entity Framework needs in order to delete the entity. (Don't put this code in your project; it's here just
to illustrate an alternative.)

[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
try
{
Student studentToDelete = new Student() { ID = id };
_context.Entry(studentToDelete).State = EntityState.Deleted;
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
return RedirectToAction(nameof(Delete), new { id = id, saveChangesError = true });
}
}

If the entity has related data that should also be deleted, make sure that cascade delete is configured in the
database. With this approach to entity deletion, EF might not realize there are related entities to be deleted.
Update the Delete view
In Views/Student/Delete.cshtml, add an error message between the h2 heading and the h3 heading, as shown in
the following example:
 <h2>Delete</h2>
<p class="text-danger">@ViewData["ErrorMessage"]</p>
<h3>Are you sure you want to delete this?</h3>

Run the app, select the Students tab, and click a Delete hyperlink:

Click Delete. The Index page is displayed without the deleted student. (You'll see an example of the error handling
code in action in the concurrency tutorial.)

Closing database connections

To free up the resources that a database connection holds, the context instance must be disposed as soon as
possible when you are done with it. The ASP.NET Core built-in dependency injection takes care of that task for you.
In Startup.cs, you call the AddDbContext extension method to provision the DbContext class in the ASP.NET DI
container. That method sets the service lifetime to Scoped by default. Scoped means the context object lifetime
coincides with the web request life time, and the Dispose method will be called automatically at the end of the
web request.

Handling Transactions
By default the Entity Framework implicitly implements transactions. In scenarios where you make changes to
multiple rows or tables and then call SaveChanges , the Entity Framework automatically makes sure that either all
of your changes succeed or they all fail. If some changes are done first and then an error happens, those changes
are automatically rolled back. For scenarios where you need more control -- for example, if you want to include
operations done outside of Entity Framework in a transaction -- see Transactions.

No-tracking queries
When a database context retrieves table rows and creates entity objects that represent them, by default it keeps
track of whether the entities in memory are in sync with what's in the database. The data in memory acts as a
cache and is used when you update an entity. This caching is often unnecessary in a web application because
context instances are typically short-lived (a new one is created and disposed for each request) and the context
that reads an entity is typically disposed before that entity is used again.
You can disable tracking of entity objects in memory by calling the AsNoTracking method. Typical scenarios in
which you might want to do that include the following:
During the context lifetime you don't need to update any entities, and you don't need EF to automatically
load navigation properties with entities retrieved by separate queries. Frequently these conditions are met
in a controller's HttpGet action methods.
You are running a query that retrieves a large volume of data, and only a small portion of the returned data
will be updated. It may be more efficient to turn off tracking for the large query, and run a query later for
the few entities that need to be updated.
You want to attach an entity in order to update it, but earlier you retrieved the same entity for a different
purpose. Because the entity is already being tracked by the database context, you can't attach the entity that
you want to change. One way to handle this situation is to call AsNoTracking on the earlier query.
For more information, see Tracking vs. No-Tracking.

Summary
You now have a complete set of pages that perform simple CRUD operations for Student entities. In the next
tutorial you'll expand the functionality of the Index page by adding sorting, filtering, and paging.

P R E V IO U S NEXT
 Sorting, filtering, paging, and grouping - EF Core
with ASP.NET Core MVC tutorial (3 of 10)
9/22/2017 14 min to read Edit Online

By Tom Dykstra and Rick Anderson

The Contoso University sample web application demonstrates how to create ASP.NET Core MVC web applications
using Entity Framework Core and Visual Studio. For information about the tutorial series, see the first tutorial in
the series.
In the previous tutorial, you implemented a set of web pages for basic CRUD operations for Student entities. In this
tutorial you'll add sorting, filtering, and paging functionality to the Students Index page. You'll also create a page
that does simple grouping.
The following illustration shows what the page will look like when you're done. The column headings are links that
the user can click to sort by that column. Clicking a column heading repeatedly toggles between ascending and
descending sort order.

Add Column Sort Links to the Students Index Page

To add sorting to the Student Index page, you'll change the Index method of the Students controller and add
code to the Student Index view.
Add sorting Functionality to the Index method
In StudentsController.cs, replace the Index method with the following code:
 public async Task<IActionResult> Index(string sortOrder)
{
ViewData["NameSortParm"] = String.IsNullOrEmpty(sortOrder) ? "name_desc" : "";
ViewData["DateSortParm"] = sortOrder == "Date" ? "date_desc" : "Date";
var students = from s in _context.Students
select s;
switch (sortOrder)
{
case "name_desc":
students = students.OrderByDescending(s => s.LastName);
break;
case "Date":
students = students.OrderBy(s => s.EnrollmentDate);
break;
case "date_desc":
students = students.OrderByDescending(s => s.EnrollmentDate);
break;
default:
students = students.OrderBy(s => s.LastName);
break;
}
return View(await students.AsNoTracking().ToListAsync());
}

This code receives a sortOrder parameter from the query string in the URL. The query string value is provided by
ASP.NET Core MVC as a parameter to the action method. The parameter will be a string that's either "Name" or
"Date", optionally followed by an underscore and the string "desc" to specify descending order. The default sort
order is ascending.
The first time the Index page is requested, there's no query string. The students are displayed in ascending order
by last name, which is the default as established by the fall-through case in the switch statement. When the user
clicks a column heading hyperlink, the appropriate sortOrder value is provided in the query string.
The two ViewData elements (NameSortParm and DateSortParm) are used by the view to configure the column
heading hyperlinks with the appropriate query string values.

public async Task<IActionResult> Index(string sortOrder)

{
ViewData["NameSortParm"] = String.IsNullOrEmpty(sortOrder) ? "name_desc" : "";
ViewData["DateSortParm"] = sortOrder == "Date" ? "date_desc" : "Date";
var students = from s in _context.Students
select s;
switch (sortOrder)
{
case "name_desc":
students = students.OrderByDescending(s => s.LastName);
break;
case "Date":
students = students.OrderBy(s => s.EnrollmentDate);
break;
case "date_desc":
students = students.OrderByDescending(s => s.EnrollmentDate);
break;
default:
students = students.OrderBy(s => s.LastName);
break;
}
return View(await students.AsNoTracking().ToListAsync());
}

These are ternary statements. The first one specifies that if the sortOrder parameter is null or empty,
NameSortParm should be set to "name_desc"; otherwise, it should be set to an empty string. These two statements
enable the view to set the column heading hyperlinks as follows:

CURRENT SORT ORDER LAST NAME HYPERLINK DATE HYPERLINK

Last Name ascending descending ascending

Last Name descending ascending ascending

Date ascending ascending descending

Date descending ascending ascending

The method uses LINQ to Entities to specify the column to sort by. The code creates an IQueryable variable before
the switch statement, modifies it in the switch statement, and calls the ToListAsync method after the switch
statement. When you create and modify IQueryable variables, no query is sent to the database. The query is not
executed until you convert the IQueryable object into a collection by calling a method such as ToListAsync .
Therefore, this code results in a single query that is not executed until the return View statement.
This code could get verbose with a large number of columns. The last tutorial in this series shows how to write
code that lets you pass the name of the OrderBy column in a string variable.
Add column heading hyperlinks to the Student Index view
Replace the code in Views/Students/Index.cshtml, with the following code to add column heading hyperlinks. The
changed lines are highlighted.
 @model IEnumerable<ContosoUniversity.Models.Student>

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-action="Create">Create New</a>
</p>
<table class="table">
<thead>
<tr>
<th>
<a asp-action="Index" asp-route-
sortOrder="@ViewData["NameSortParm"]">@Html.DisplayNameFor(model => model.LastName)</a>
</th>
<th>
@Html.DisplayNameFor(model => model.FirstMidName)
</th>
<th>
<a asp-action="Index" asp-route-
sortOrder="@ViewData["DateSortParm"]">@Html.DisplayNameFor(model => model.EnrollmentDate)</a>
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model) {
<tr>
<td>
@Html.DisplayFor(modelItem => item.LastName)
</td>
<td>
@Html.DisplayFor(modelItem => item.FirstMidName)
</td>
<td>
@Html.DisplayFor(modelItem => item.EnrollmentDate)
</td>
<td>
<a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
<a asp-action="Details" asp-route-id="@item.ID">Details</a> |
<a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>
}
</tbody>
</table>

This code uses the information in ViewData properties to set up hyperlinks with the appropriate query string
values.
Run the app, select the Students tab, and click the Last Name and Enrollment Date column headings to verify
that sorting works.
Add a Search Box to the Students Index page
To add filtering to the Students Index page, you'll add a text box and a submit button to the view and make
corresponding changes in the Index method. The text box will let you enter a string to search for in the first name
and last name fields.
Add filtering functionality to the Index method
In StudentsController.cs, replace the Index method with the following code (the changes are highlighted).

public async Task<IActionResult> Index(string sortOrder, string searchString)

{
ViewData["NameSortParm"] = String.IsNullOrEmpty(sortOrder) ? "name_desc" : "";
ViewData["DateSortParm"] = sortOrder == "Date" ? "date_desc" : "Date";
ViewData["CurrentFilter"] = searchString;

var students = from s in _context.Students

select s;
if (!String.IsNullOrEmpty(searchString))
{
students = students.Where(s => s.LastName.Contains(searchString)
|| s.FirstMidName.Contains(searchString));
}
switch (sortOrder)
{
case "name_desc":
students = students.OrderByDescending(s => s.LastName);
break;
case "Date":
students = students.OrderBy(s => s.EnrollmentDate);
break;
case "date_desc":
students = students.OrderByDescending(s => s.EnrollmentDate);
break;
default:
students = students.OrderBy(s => s.LastName);
break;
}
return View(await students.AsNoTracking().ToListAsync());
}
You've added a searchString parameter to the Index method. The search string value is received from a text box
that you'll add to the Index view. You've also added to the LINQ statement a where clause that selects only
students whose first name or last name contains the search string. The statement that adds the where clause is
executed only if there's a value to search for.

NOTE
Here you are calling the Where method on an IQueryable object, and the filter will be processed on the server. In some
scenarios you might be calling the Where method as an extension method on an in-memory collection. (For example,
suppose you change the reference to _context.Students so that instead of an EF DbSet it references a repository
method that returns an IEnumerable collection.) The result would normally be the same but in some cases may be
different.
For example, the .NET Framework implementation of the Contains method performs a case-sensitive comparison by
default, but in SQL Server this is determined by the collation setting of the SQL Server instance. That setting defaults to
case-insensitive. You could call the ToUpper method to make the test explicitly case-insensitive: Where(s =>
s.LastName.ToUpper().Contains(searchString.ToUpper()). That would ensure that results stay the same if you change the
code later to use a repository which returns an IEnumerable collection instead of an IQueryable object. (When you call
the Contains method on an IEnumerable collection, you get the .NET Framework implementation; when you call it on an
IQueryable object, you get the database provider implementation.) However, there is a performance penalty for this
solution. The ToUpper code would put a function in the WHERE clause of the TSQL SELECT statement. That would prevent
the optimizer from using an index. Given that SQL is mostly installed as case-insensitive, it's best to avoid the ToUpper
code until you migrate to a case-sensitive data store.

Add a Search Box to the Student Index View

In Views/Student/Index.cshtml, add the highlighted code immediately before the opening table tag in order to
create a caption, a text box, and a Search button.

<p>
<a asp-action="Create">Create New</a>
</p>

<form asp-action="Index" method="get">

<div class="form-actions no-color">
<p>
Find by name: <input type="text" name="SearchString" value="@ViewData["currentFilter"]" />
<input type="submit" value="Search" class="btn btn-default" /> |
<a asp-action="Index">Back to Full List</a>
</p>
</div>
</form>

<table class="table">

This code uses the <form> tag helper to add the search text box and button. By default, the <form> tag helper
submits form data with a POST, which means that parameters are passed in the HTTP message body and not in
the URL as query strings. When you specify HTTP GET, the form data is passed in the URL as query strings, which
enables users to bookmark the URL. The W3C guidelines recommend that you should use GET when the action
does not result in an update.
Run the app, select the Students tab, enter a search string, and click Search to verify that filtering is working.
Notice that the URL contains the search string.

http://localhost:5813/Students?SearchString=an

If you bookmark this page, you'll get the filtered list when you use the bookmark. Adding method="get" to the
form tag is what caused the query string to be generated.

At this stage, if you click a column heading sort link you'll lose the filter value that you entered in the Search box.
You'll fix that in the next section.

Add paging functionality to the Students Index page

To add paging to the Students Index page, you'll create a PaginatedList class that uses Skip and Take
statements to filter data on the server instead of always retrieving all rows of the table. Then you'll make
additional changes in the Index method and add paging buttons to the Index view. The following illustration
shows the paging buttons.
In the project folder, create PaginatedList.cs , and then replace the template code with the following code.
 using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;

namespace ContosoUniversity
{
public class PaginatedList<T> : List<T>
{
public int PageIndex { get; private set; }
public int TotalPages { get; private set; }

public PaginatedList(List<T> items, int count, int pageIndex, int pageSize)

{
PageIndex = pageIndex;
TotalPages = (int)Math.Ceiling(count / (double)pageSize);

this.AddRange(items);
}

public bool HasPreviousPage

{
get
{
return (PageIndex > 1);
}
}

public bool HasNextPage

{
get
{
return (PageIndex < TotalPages);
}
}

public static async Task<PaginatedList<T>> CreateAsync(IQueryable<T> source, int pageIndex, int

pageSize)
{
var count = await source.CountAsync();
var items = await source.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync();
return new PaginatedList<T>(items, count, pageIndex, pageSize);
}
}
}

The CreateAsync method in this code takes page size and page number and applies the appropriate Skip and
Take statements to the IQueryable . When ToListAsync is called on the IQueryable , it will return a List
containing only the requested page. The properties HasPreviousPage and HasNextPage can be used to enable or
disable Previous and Next paging buttons.
A CreateAsync method is used instead of a constructor to create the PaginatedList<T> object because
constructors can't run asynchronous code.

Add paging functionality to the Index method

In StudentsController.cs, replace the Index method with the following code.
 public async Task<IActionResult> Index(
string sortOrder,
string currentFilter,
string searchString,
int? page)
{
ViewData["CurrentSort"] = sortOrder;
ViewData["NameSortParm"] = String.IsNullOrEmpty(sortOrder) ? "name_desc" : "";
ViewData["DateSortParm"] = sortOrder == "Date" ? "date_desc" : "Date";

if (searchString != null)
{
page = 1;
}
else
{
searchString = currentFilter;
}

ViewData["CurrentFilter"] = searchString;

var students = from s in _context.Students

select s;
if (!String.IsNullOrEmpty(searchString))
{
students = students.Where(s => s.LastName.Contains(searchString)
|| s.FirstMidName.Contains(searchString));
}
switch (sortOrder)
{
case "name_desc":
students = students.OrderByDescending(s => s.LastName);
break;
case "Date":
students = students.OrderBy(s => s.EnrollmentDate);
break;
case "date_desc":
students = students.OrderByDescending(s => s.EnrollmentDate);
break;
default:
students = students.OrderBy(s => s.LastName);
break;
}

int pageSize = 3;
return View(await PaginatedList<Student>.CreateAsync(students.AsNoTracking(), page ?? 1, pageSize));
}

This code adds a page number parameter, a current sort order parameter, and a current filter parameter to the
method signature.

public async Task<IActionResult> Index(

string sortOrder,
string currentFilter,
string searchString,
int? page)

The first time the page is displayed, or if the user hasn't clicked a paging or sorting link, all the parameters will be
null. If a paging link is clicked, the page variable will contain the page number to display.
The ViewData element named CurrentSort provides the view with the current sort order, because this must be
included in the paging links in order to keep the sort order the same while paging.
The ViewData element named CurrentFilter provides the view with the current filter string. This value must be
included in the paging links in order to maintain the filter settings during paging, and it must be restored to the
text box when the page is redisplayed.
If the search string is changed during paging, the page has to be reset to 1, because the new filter can result in
different data to display. The search string is changed when a value is entered in the text box and the Submit
button is pressed. In that case, the searchString parameter is not null.

if (searchString != null)
{
page = 1;
}
else
{
searchString = currentFilter;
}

At the end of the Index method, the PaginatedList.CreateAsync method converts the student query to a single
page of students in a collection type that supports paging. That single page of students is then passed to the view.

return View(await PaginatedList<Student>.CreateAsync(students.AsNoTracking(), page ?? 1, pageSize));

The PaginatedList.CreateAsync method takes a page number. The two question marks represent the null-
coalescing operator. The null-coalescing operator defines a default value for a nullable type; the expression
(page ?? 1) means return the value of page if it has a value, or return 1 if page is null.

Add paging links to the Student Index view

In Views/Students/Index.cshtml, replace the existing code with the following code. The changes are highlighted.

@model PaginatedList<ContosoUniversity.Models.Student>

@{
ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
<a asp-action="Create">Create New</a>
</p>

<form asp-action="Index" method="get">

<div class="form-actions no-color">
<p>
Find by name: <input type="text" name="SearchString" value="@ViewData["currentFilter"]" />
<input type="submit" value="Search" class="btn btn-default" /> |
<a asp-action="Index">Back to Full List</a>
</p>
</div>
</form>

<table class="table">
<thead>
<tr>
<th>
<a asp-action="Index" asp-route-sortOrder="@ViewData["NameSortParm"]" asp-route-
currentFilter="@ViewData["CurrentFilter"]">Last Name</a>
</th>
<th>
First Name
 First Name
</th>
<th>
<a asp-action="Index" asp-route-sortOrder="@ViewData["DateSortParm"]" asp-route-
currentFilter="@ViewData["CurrentFilter"]">Enrollment Date</a>
</th>
<th></th>
</tr>
</thead>
<tbody>
@foreach (var item in Model)
{
<tr>
<td>
@Html.DisplayFor(modelItem => item.LastName)
</td>
<td>
@Html.DisplayFor(modelItem => item.FirstMidName)
</td>
<td>
@Html.DisplayFor(modelItem => item.EnrollmentDate)
</td>
<td>
<a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
<a asp-action="Details" asp-route-id="@item.ID">Details</a> |
<a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
</td>
</tr>
}
</tbody>
</table>

@{
var prevDisabled = !Model.HasPreviousPage ? "disabled" : "";
var nextDisabled = !Model.HasNextPage ? "disabled" : "";
}

<a asp-action="Index"
asp-route-sortOrder="@ViewData["CurrentSort"]"
asp-route-page="@(Model.PageIndex - 1)"
asp-route-currentFilter="@ViewData["CurrentFilter"]"
class="btn btn-default @prevDisabled">
Previous
</a>
<a asp-action="Index"
asp-route-sortOrder="@ViewData["CurrentSort"]"
asp-route-page="@(Model.PageIndex + 1)"
asp-route-currentFilter="@ViewData["CurrentFilter"]"
class="btn btn-default @nextDisabled">
Next
</a>

The @model statement at the top of the page specifies that the view now gets a PaginatedList<T> object instead of
a List<T> object.
The column header links use the query string to pass the current search string to the controller so that the user
can sort within filter results:

<a asp-action="Index" asp-route-sortOrder="@ViewData["DateSortParm"]" asp-route-currentFilter

="@ViewData["CurrentFilter"]">Enrollment Date</a>

The paging buttons are displayed by tag helpers:

 <a asp-action="Index"
asp-route-sortOrder="@ViewData["CurrentSort"]"
asp-route-page="@(Model.PageIndex - 1)"
asp-route-currentFilter="@ViewData["CurrentFilter"]"
class="btn btn-default @prevDisabled">
Previous
</a>

Run the app and go to the Students page.

Click the paging links in different sort orders to make sure paging works. Then enter a search string and try paging
again to verify that paging also works correctly with sorting and filtering.

Create an About page that shows Student statistics

For the Contoso University website's About page, you'll display how many students have enrolled for each
enrollment date. This requires grouping and simple calculations on the groups. To accomplish this, you'll do the
following:
Create a view model class for the data that you need to pass to the view.
Modify the About method in the Home controller.
Modify the About view.
Create the view model
Create a SchoolViewModels folder in the Models folder.
In the new folder, add a class file EnrollmentDateGroup.cs and replace the template code with the following code:
 using System;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models.SchoolViewModels
{
public class EnrollmentDateGroup
{
[DataType(DataType.Date)]
public DateTime? EnrollmentDate { get; set; }

public int StudentCount { get; set; }

}
}

Modify the Home Controller

In HomeController.cs, add the following using statements at the top of the file:

using Microsoft.EntityFrameworkCore;
using ContosoUniversity.Data;
using ContosoUniversity.Models.SchoolViewModels;

Add a class variable for the database context immediately after the opening curly brace for the class, and get an
instance of the context from ASP.NET Core DI:

public class HomeController : Controller

{
private readonly SchoolContext _context;

public HomeController(SchoolContext context)

{
_context = context;
}

Replace the About method with the following code:

public async Task<ActionResult> About()

{
IQueryable<EnrollmentDateGroup> data =
from student in _context.Students
group student by student.EnrollmentDate into dateGroup
select new EnrollmentDateGroup()
{
EnrollmentDate = dateGroup.Key,
StudentCount = dateGroup.Count()
};
return View(await data.AsNoTracking().ToListAsync());
}

The LINQ statement groups the student entities by enrollment date, calculates the number of entities in each
group, and stores the results in a collection of EnrollmentDateGroup view model objects.

NOTE
In the 1.0 version of Entity Framework Core, the entire result set is returned to the client, and grouping is done on the
client. In some scenarios this could create performance problems. Be sure to test performance with production volumes of
data, and if necessary use raw SQL to do the grouping on the server. For information about how to use raw SQL, see the
last tutorial in this series.
Modify the About View
Replace the code in the Views/Home/About.cshtml file with the following code:

@model IEnumerable<ContosoUniversity.Models.SchoolViewModels.EnrollmentDateGroup>

@{
ViewData["Title"] = "Student Body Statistics";
}

<h2>Student Body Statistics</h2>

<table>
<tr>
<th>
Enrollment Date
</th>
<th>
Students
</th>
</tr>

@foreach (var item in Model)

{
<tr>
<td>
@Html.DisplayFor(modelItem => item.EnrollmentDate)
</td>
<td>
@item.StudentCount
</td>
</tr>
}
</table>

Run the app and go to the About page. The count of students for each enrollment date is displayed in a table.

Summary
In this tutorial, you've seen how to perform sorting, filtering, paging, and grouping. In the next tutorial, you'll learn
how to handle data model changes by using migrations.

P R E V IO U S NEXT
 Migrations - EF Core with ASP.NET Core MVC
tutorial (4 of 10)
9/22/2017 8 min to read Edit Online

By Tom Dykstra and Rick Anderson

The Contoso University sample web application demonstrates how to create ASP.NET Core MVC web applications
using Entity Framework Core and Visual Studio. For information about the tutorial series, see the first tutorial in
the series.
In this tutorial, you start using the EF Core migrations feature for managing data model changes. In later tutorials,
you'll add more migrations as you change the data model.

Introduction to migrations
When you develop a new application, your data model changes frequently, and each time the model changes, it
gets out of sync with the database. You started these tutorials by configuring the Entity Framework to create the
database if it doesn't exist. Then each time you change the data model -- add, remove, or change entity classes or
change your DbContext class -- you can delete the database and EF creates a new one that matches the model,
and seeds it with test data.
This method of keeping the database in sync with the data model works well until you deploy the application to
production. When the application is running in production it is usually storing data that you want to keep, and
you don't want to lose everything each time you make a change such as adding a new column. The EF Core
Migrations feature solves this problem by enabling EF to update the database schema instead of creating a new
database.

Entity Framework Core NuGet packages for migrations

To work with migrations, you can use the Package Manager Console (PMC) or the command-line interface
(CLI). These tutorials show how to use CLI commands. Information about the PMC is at the end of this tutorial.
The EF tools for the command-line interface (CLI) are provided in Microsoft.EntityFrameworkCore.Tools.DotNet.
To install this package, add it to the DotNetCliToolReference collection in the .csproj file, as shown. Note: You
have to install this package by editing the .csproj file; you can't use the install-package command or the package
manager GUI. You can edit the .csproj file by right-clicking the project name in Solution Explorer and selecting
Edit ContosoUniversity.csproj.

<ItemGroup>
<DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="2.0.0" />
<DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.0" />
</ItemGroup>

(The version numbers in this example were current when the tutorial was written.)

Change the connection string

In the appsettings.json file, change the name of the database in the connection string to ContosoUniversity2 or
some other name that you haven't used on the computer you're using.
 {
"ConnectionStrings": {
"DefaultConnection": "Server=
(localdb)\\mssqllocaldb;Database=ContosoUniversity2;Trusted_Connection=True;MultipleActiveResultSets=true"
},

This change sets up the project so that the first migration will create a new database. This isn't required for
getting started with migrations, but you'll see later why it's a good idea.

NOTE
As an alternative to changing the database name, you can delete the database. Use SQL Server Object Explorer (SSOX)
or the database drop CLI command:

dotnet ef database drop

The following section explains how to run CLI commands.

Create an initial migration

Save your changes and build the project. Then open a command window and navigate to the project folder.
Here's a quick way to do that:
In Solution Explorer, right-click the project and choose Open in File Explorer from the context menu.

Enter "cmd" in the address bar and press Enter.

Enter the following command in the command window:

dotnet ef migrations add InitialCreate

You see output like the following in the command window:

info: Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager[0]
User profile is available. Using 'C:\Users\username\AppData\Local\ASP.NET\DataProtection-Keys' as key
repository and Windows DPAPI to encrypt keys at rest.
info: Microsoft.EntityFrameworkCore.Infrastructure[100403]
Entity Framework Core 2.0.0-rtm-26452 initialized 'SchoolContext' using provider
'Microsoft.EntityFrameworkCore.SqlServer' with options: None
Done. To undo this action, use 'ef migrations remove'

NOTE
If you see an error message No executable found matching command "dotnet-ef", see this blog post for help
troubleshooting.

If you see an error message "cannot access the file ... ContosoUniversity.dll because it is being used by another
process.", find the IIS Express icon in the Windows System Tray, and right-click it, then click ContosoUniversity >
Stop Site.

Examine the Up and Down methods

When you executed the migrations add command, EF generated the code that will create the database from
scratch. This code is in the Migrations folder, in the file named <timestamp>_InitialCreate.cs. The Up method of
the InitialCreate class creates the database tables that correspond to the data model entity sets, and the Down
method deletes them, as shown in the following example.
 public partial class InitialCreate : Migration
{
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "Course",
columns: table => new
{
CourseID = table.Column<int>(nullable: false),
Credits = table.Column<int>(nullable: false),
Title = table.Column<string>(nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_Course", x => x.CourseID);
});

// Additional code not shown

}

protected override void Down(MigrationBuilder migrationBuilder)

{
migrationBuilder.DropTable(
name: "Enrollment");
// Additional code not shown
}
}

Migrations calls the Up method to implement the data model changes for a migration. When you enter a
command to roll back the update, Migrations calls the Down method.
This code is for the initial migration that was created when you entered the migrations add InitialCreate
command. The migration name parameter ("InitialCreate" in the example) is used for the file name and can be
whatever you want. It's best to choose a word or phrase that summarizes what is being done in the migration. For
example, you might name a later migration "AddDepartmentTable".
If you created the initial migration when the database already exists, the database creation code is generated but
it doesn't have to run because the database already matches the data model. When you deploy the app to
another environment where the database doesn't exist yet, this code will run to create your database, so it's a
good idea to test it first. That's why you changed the name of the database in the connection string earlier -- so
that migrations can create a new one from scratch.

Examine the data model snapshot

Migrations also creates a snapshot of the current database schema in
Migrations/SchoolContextModelSnapshot.cs. Here's what that code looks like:
 [DbContext(typeof(SchoolContext))]
partial class SchoolContextModelSnapshot : ModelSnapshot
{
protected override void BuildModel(ModelBuilder modelBuilder)
{
modelBuilder
.HasAnnotation("ProductVersion", "2.0.0-rtm-26452")
.HasAnnotation("SqlServer:ValueGenerationStrategy",
SqlServerValueGenerationStrategy.IdentityColumn);

modelBuilder.Entity("ContosoUniversity.Models.Course", b =>
{
b.Property<int>("CourseID");

b.Property<int>("Credits");

b.Property<string>("Title");

b.HasKey("CourseID");

b.ToTable("Course");
});

// Additional code for Enrollment and Student tables not shown

modelBuilder.Entity("ContosoUniversity.Models.Enrollment", b =>
{
b.HasOne("ContosoUniversity.Models.Course", "Course")
.WithMany("Enrollments")
.HasForeignKey("CourseID")
.OnDelete(DeleteBehavior.Cascade);

b.HasOne("ContosoUniversity.Models.Student", "Student")
.WithMany("Enrollments")
.HasForeignKey("StudentID")
.OnDelete(DeleteBehavior.Cascade);
});
}
}

Because the current database schema is represented in code, EF Core doesn't have to interact with the database
to create migrations. When you add a migration, EF determines what changed by comparing the data model to
the snapshot file. EF interacts with the database only when it has to update the database.
The snapshot file has to be kept in sync with the migrations that create it, so you can't remove a migration just by
deleting the file named <timestamp>_<migrationname>.cs. If you delete that file, the remaining migrations will
be out of sync with the database snapshot file. To delete the last migration that you added, use the dotnet ef
migrations remove command.

Apply the migration to the database

In the command window, enter the following command to create the database and tables in it.

dotnet ef database update

The output from the command is similar to the migrations add command, except that you see logs for the SQL
commands that set up the database. Most of the logs are omitted in the following sample output. If you prefer not
to see this level of detail in log messages, you can change the log levels in the appsettings.Development.json file.
For more information, see Introduction to logging.
 info: Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager[0]
User profile is available. Using 'C:\Users\username\AppData\Local\ASP.NET\DataProtection-Keys' as key
repository and Windows DPAPI to encrypt keys at rest.
info: Microsoft.EntityFrameworkCore.Infrastructure[100403]
Entity Framework Core 2.0.0-rtm-26452 initialized 'SchoolContext' using provider
'Microsoft.EntityFrameworkCore.SqlServer' with options: None
info: Microsoft.EntityFrameworkCore.Database.Command[200101]
Executed DbCommand (467ms) [Parameters=[], CommandType='Text', CommandTimeout='60']
CREATE DATABASE [ContosoUniversity2];
info: Microsoft.EntityFrameworkCore.Database.Command[200101]
Executed DbCommand (20ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
CREATE TABLE [__EFMigrationsHistory] (
[MigrationId] nvarchar(150) NOT NULL,
[ProductVersion] nvarchar(32) NOT NULL,
CONSTRAINT [PK___EFMigrationsHistory] PRIMARY KEY ([MigrationId])
);

<logs omitted for brevity>

info: Microsoft.EntityFrameworkCore.Database.Command[200101]
Executed DbCommand (3ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
INSERT INTO [__EFMigrationsHistory] ([MigrationId], [ProductVersion])
VALUES (N'20170816151242_InitialCreate', N'2.0.0-rtm-26452');
Done.

Use SQL Server Object Explorer to inspect the database as you did in the first tutorial. You'll notice the addition
of an __EFMigrationsHistory table that keeps track of which migrations have been applied to the database. View
the data in that table and you'll see one row for the first migration. (The last log in the preceding CLI output
example shows the INSERT statement that creates this row.)
Run the application to verify that everything still works the same as before.

Command-line interface (CLI) vs. Package Manager Console (PMC)

The EF tooling for managing migrations is available from .NET Core CLI commands or from PowerShell cmdlets
in the Visual Studio Package Manager Console (PMC) window. This tutorial shows how to use the CLI, but you
can use the PMC if you prefer.
The EF commands for the PMC commands are in the Microsoft.EntityFrameworkCore.Tools package. This package
is already included in the Microsoft.AspNetCore.All metapackage, so you don't have to install it.
Important: This is not the same package as the one you install for the CLI by editing the .csproj file. The name of
this one ends in Tools , unlike the CLI package name which ends in Tools.DotNet .
For more information about the CLI commands, see .NET Core CLI.
For more information about the PMC commands, see Package Manager Console (Visual Studio).

Summary
In this tutorial, you've seen how to create and apply your first migration. In the next tutorial, you'll begin looking
at more advanced topics by expanding the data model. Along the way you'll create and apply additional
migrations.

P R E V IO U S NEXT
 Creating a complex data model - EF Core with
ASP.NET Core MVC tutorial (5 of 10)
9/22/2017 30 min to read Edit Online

By Tom Dykstra and Rick Anderson

The Contoso University sample web application demonstrates how to create ASP.NET Core MVC web applications
using Entity Framework Core and Visual Studio. For information about the tutorial series, see the first tutorial in
the series.
In the previous tutorials, you worked with a simple data model that was composed of three entities. In this tutorial,
you'll add more entities and relationships and you'll customize the data model by specifying formatting,
validation, and database mapping rules.
When you're finished, the entity classes will make up the completed data model that's shown in the following
illustration:
Customize the Data Model by Using Attributes
In this section you'll see how to customize the data model by using attributes that specify formatting, validation,
and database mapping rules. Then in several of the following sections you'll create the complete School data
model by adding attributes to the classes you already created and creating new classes for the remaining entity
types in the model.
The DataType attribute
For student enrollment dates, all of the web pages currently display the time along with the date, although all you
care about for this field is the date. By using data annotation attributes, you can make one code change that will fix
the display format in every view that shows the data. To see an example of how to do that, you'll add an attribute
to the EnrollmentDate property in the Student class.
In Models/Student.cs, add a using statement for the System.ComponentModel.DataAnnotations namespace and add
DataType and DisplayFormat attributes to the EnrollmentDate property, as shown in the following example:

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class Student
{
public int ID { get; set; }
public string LastName { get; set; }
public string FirstMidName { get; set; }
[DataType(DataType.Date)]
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
public DateTime EnrollmentDate { get; set; }

public ICollection<Enrollment> Enrollments { get; set; }

}
}

The DataType attribute is used to specify a data type that is more specific than the database intrinsic type. In this
case we only want to keep track of the date, not the date and time. The DataType Enumeration provides for many
data types, such as Date, Time, PhoneNumber, Currency, EmailAddress, and more. The DataType attribute can also
enable the application to automatically provide type-specific features. For example, a mailto: link can be created
for DataType.EmailAddress , and a date selector can be provided for DataType.Date in browsers that support
HTML5. The DataType attribute emits HTML 5 data- (pronounced data dash) attributes that HTML 5 browsers
can understand. The DataType attributes do not provide any validation.
DataType.Date does not specify the format of the date that is displayed. By default, the data field is displayed
according to the default formats based on the server's CultureInfo.
The DisplayFormat attribute is used to explicitly specify the date format:

[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]

The ApplyFormatInEditMode setting specifies that the formatting should also be applied when the value is
displayed in a text box for editing. (You might not want that for some fields -- for example, for currency values,
you might not want the currency symbol in the text box for editing.)
You can use the DisplayFormat attribute by itself, but it's generally a good idea to use the DataType attribute also.
The DataType attribute conveys the semantics of the data as opposed to how to render it on a screen, and
provides the following benefits that you don't get with DisplayFormat :
 The browser can enable HTML5 features (for example to show a calendar control, the locale-appropriate
currency symbol, email links, some client-side input validation, etc.).
By default, the browser will render data using the correct format based on your locale.
For more information, see the <input> tag helper documentation.
Run the app, go to the Students Index page and notice that times are no longer displayed for the enrollment dates.
The same will be true for any view that uses the Student model.

The StringLength attribute

You can also specify data validation rules and validation error messages using attributes. The StringLength
attribute sets the maximum length in the database and provides client side and server side validation for ASP.NET
MVC. You can also specify the minimum string length in this attribute, but the minimum value has no impact on
the database schema.
Suppose you want to ensure that users don't enter more than 50 characters for a name. To add this limitation, add
StringLength attributes to the LastName and FirstMidName properties, as shown in the following example:
 using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace ContosoUniversity.Models
{
public class Student
{
public int ID { get; set; }
[StringLength(50)]
public string LastName { get; set; }
[StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
public string FirstMidName { get; set; }
[DataType(DataType.Date)]
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
public DateTime EnrollmentDate { get; set; }

public ICollection<Enrollment> Enrollments { get; set; }

}
}

The attribute won't prevent a user from entering white space for a name. You can use the
StringLength
RegularExpression attribute to apply restrictions to the input. For example, the following code requires the first
character to be upper case and the remaining characters to be alphabetical:

[RegularExpression(@"^[A-Z]+[a-zA-Z''-'\s]*$")]

The MaxLength attribute provides functionality similar to the StringLength attribute but doesn't provide client
side validation.
The database model has now changed in a way that requires a change in the database schema. You'll use
migrations to update the schema without losing any data that you may have added to the database by using the
application UI.
Save your changes and build the project. Then open the command window in the project folder and enter the
following commands:

dotnet ef migrations add MaxLengthOnNames

dotnet ef database update

The migrations add command warns that data loss may occur, because the change makes the maximum length
shorter for two columns. Migrations creates a file named <timeStamp>_MaxLengthOnNames.cs. This file contains
code in the Up method that will update the database to match the current data model. The database update
command ran that code.
The timestamp prefixed to the migrations file name is used by Entity Framework to order the migrations. You can
create multiple migrations before running the update-database command, and then all of the migrations are
applied in the order in which they were created.
Run the app, select the Students tab, click Create New, and enter either name longer than 50 characters. When
you click Create, client side validation shows an error message.
The Column attribute
You can also use attributes to control how your classes and properties are mapped to the database. Suppose you
had used the name FirstMidName for the first-name field because the field might also contain a middle name. But
you want the database column to be named FirstName , because users who will be writing ad-hoc queries against
the database are accustomed to that name. To make this mapping, you can use the Column attribute.
The Column attribute specifies that when the database is created, the column of the Student table that maps to
the FirstMidName property will be named FirstName . In other words, when your code refers to
Student.FirstMidName , the data will come from or be updated in the FirstName column of the Student table. If
you don't specify column names, they are given the same name as the property name.
In the Student.cs file, add a using statement for System.ComponentModel.DataAnnotations.Schema and add the
column name attribute to the FirstMidName property, as shown in the following highlighted code:
 using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
public class Student
{
public int ID { get; set; }
[StringLength(50)]
public string LastName { get; set; }
[StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
[Column("FirstName")]
public string FirstMidName { get; set; }
[DataType(DataType.Date)]
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
public DateTime EnrollmentDate { get; set; }

public ICollection<Enrollment> Enrollments { get; set; }

}
}

The addition of the Column attribute changes the model backing the SchoolContext , so it won't match the
database.
Save your changes and build the project. Then open the command window in the project folder and enter the
following commands to create another migration:

dotnet ef migrations add ColumnFirstName

dotnet ef database update

In SQL Server Object Explorer, open the Student table designer by double-clicking the Student table.

Before you applied the first two migrations, the name columns were of type nvarchar(MAX). They are now
nvarchar(50) and the column name has changed from FirstMidName to FirstName.
 NOTE
If you try to compile before you finish creating all of the entity classes in the following sections, you might get compiler
errors.

Final changes to the Student entity

In Models/Student.cs, replace the code you added earlier with the following code. The changes are highlighted.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ContosoUniversity.Models
{
public class Student
{
public int ID { get; set; }
[Required]
[StringLength(50)]
[Display(Name = "Last Name")]
public string LastName { get; set; }
[Required]
[StringLength(50, ErrorMessage = "First name cannot be longer than 50 characters.")]
[Column("FirstName")]
[Display(Name = "First Name")]
public string FirstMidName { get; set; }
[DataType(DataType.Date)]
[DisplayFormat(DataFormatString = "{0:yyyy-MM-dd}", ApplyFormatInEditMode = true)]
[Display(Name = "Enrollment Date")]
public DateTime EnrollmentDate { get; set; }
[Display(Name = "Full Name")]
public string FullName
{
get
{
return LastName + ", " + FirstMidName;
}
}

public ICollection<Enrollment> Enrollments { get; set; }

}
}

The Required attribute

The Required attribute makes the name properties required fields. The Required attribute is not needed for non-
nullable types such as value types (DateTime, int, double, float, etc.). Types that can't be null are automatically
treated as required fields.
You could remove the Required attribute and replace it with a minimum length parameter for the StringLength
attribute:

[Display(Name = "Last Name")]

[StringLength(50, MinimumLength=1)]
public string LastName { get; set; }

The Display attribute

The Display attribute specifies that the caption for the text boxes should be "First Name", "Last Name", "Full
Name", and "Enrollment Date" instead of the property name in each instance (which has no space dividing the
words).
The FullName calculated property
FullName is a calculated property that returns a value that's created by concatenating two other properties.
Therefore it has only a get accessor, and no FullName column will be generated in the database.

Create the Instructor Entity

Create Models/Instructor.cs, replacing the template code with the following code:
 u