Book Image

Mastering Entity Framework Core 2.0

By : Prabhakaran Anbazhagan
Book Image

Mastering Entity Framework Core 2.0

By: Prabhakaran Anbazhagan

Overview of this book

Being able to create and maintain data-oriented applications has become crucial in modern programming. This is why Microsoft came up with Entity Framework so architects can optimize storage requirements while also writing efficient and maintainable application code. This book is a comprehensive guide that will show how to utilize the power of the Entity Framework to build efficient .NET Core applications. It not only teaches all the fundamentals of Entity Framework Core but also demonstrates how to use it practically so you can implement it in your software development. The book is divided into three modules. The first module focuses on building entities and relationships. Here you will also learn about different mapping techniques, which will help you choose the one best suited to your application design. Once you have understood the fundamentals of the Entity Framework, you will move on to learn about validation and querying in the second module. It will also teach you how to execute raw SQL queries and extend the Entity Framework to leverage Query Objects using the Query Object Pattern. The final module of the book focuses on performance optimization and managing the security of your application. You will learn to implement failsafe mechanisms using concurrency tokens. The book also explores row-level security and multitenant databases in detail. By the end of the book, you will be proficient in implementing Entity Framework on your .NET Core applications.

Related Content you might be interested in

Current Title:

Small book image
Mastering Entity Framework Core 2.0
Prabhakaran Anbazhagan
Dec, 2017 | 386 pages
Small book image
Learning ASP.NET Core 2.0
Michel Bruchet | Jason De Oliveira
Dec, 2017 | 516 pages
Small book image
ASP.NET Core 2 Fundamentals
Onur Gumus | Mugilan T S Ragupathi
Aug, 2018 | 298 pages
Table of Contents (20 chapters)
Title Page
Title Page
Credits
Credits
About the Author
About the Author
About the Reviewers
About the Reviewers
www.PacktPub.com
www.PacktPub.com
Customer Feedback
Customer Feedback
Dedication
Dedication
Preface
Preface
Free Chapter
1
Kickstart - Introduction to Entity Framework Core
Kickstart - Introduction to Entity Framework Core
Prerequisites
Creating a new project
Installing Entity Framework
Data models
Database context
Registering the context in services (.NET Core DI)
Creating and seeding databases
CRUD operations
Summary
2
The Other Way Around – Database First Approach
The Other Way Around – Database First Approach
Preparing the database
Creating  new project
Reverse engineering the database
Registering context in services (.NET Core DI)
Performing CRUD operations
Summary
3
Relationships – Terminology and Conventions
Relationships – Terminology and Conventions
Understanding relationship terms
Conventions in a relationship
Summary
4
Building Relationships – Understanding Mapping
Building Relationships – Understanding Mapping
Relationships
Fluent API
Summary
5
Know the Validation – Explore Inbuilt Validations
Know the Validation – Explore Inbuilt Validations
Diving into built-in validations
Required field validation
EmailAddress field validation
Compare field validation
Url field validation
MinLength field validation
MaxLength field validation
RegularExpression field validation
Summary
6
Save Yourself – Hack Proof Your Entities
Save Yourself – Hack Proof Your Entities
Client-side validation
Validating data without client-side scripting
Custom validation
Remote validation
Summary
7
Going Raw – Leveraging SQL Queries in LINQ
Going Raw – Leveraging SQL Queries in LINQ
Basic raw SQL queries
Building parameterized queries
Composing with LINQ
Executing SQL query without a DBSet or POCO
Summary
8
Query Is All We Need – Query Object Pattern
Query Is All We Need – Query Object Pattern
Introduction to query objects
Improving repositories with the query object pattern
Composing queries with commands
Enhancing queries with expression trees
Summary
9
Fail Safe Mechanism – Transactions
Fail Safe Mechanism – Transactions
Default behavior of a transaction
Creating a simple transaction
Creating a cross-context transaction
Leveraging transactions between multiple technologies
Summary
10
Make It Real – Handling Concurrencies
Make It Real – Handling Concurrencies
Handling concurrency in EF
Introducing concurrency tokens
Non-timestamp based concurrency tokens
Timestamp-based concurrency tokens
Handling concurrency conflicts
Summary
11
Performance – It's All About Execution Time
Performance – It's All About Execution Time
The AsNoTracking() method
Detecting changes
Asynchronous operations
Unnecessary volume returned
The N+1 Select problem
More data than required
Mismatched data types
Missing indexes
Summary
12
Isolation – Building a Multi-Tenant Database
Isolation – Building a Multi-Tenant Database
Authentication in the blogging system
Row-Level Security
Multi-tenancy
Summary

Creating a new project

Open Visual Studio and create a new project either from the File menu or from the Start page.

The Start page

From the New Project section, create a new project using any one of the following approaches:

  1. Select Create new project.... On the left pane, select Templates | Visual C# | .NETCore. Select the ASP.NET Core Web Application template from the list.
  1. Search the project templates for the ASP.NET Core Web Application and select it. As displayed in the following screenshot, enter MasteringEFCore.Web as the Name and MasteringEFCore as  the Solution name and click OK:

New project

The File menu

From the File menu, perform the following steps:

  1. Select New | Project.
  2. On the left pane, select Templates | Visual C# | .NET Core.
  3. Select the ASP.NET Core Web Application template from the list.

 

  1. As displayed in the previous screenshot, enter MasteringEFCore.CodeFirst.Starter as the Name and MasteringEFCore as the Solution name and click OK.

Irrespective of the previous two approaches, the selected template will provide New ASP.NET Web Application (.NET Core) dialog, to let us choose from the following:

    • Empty
    • Web API: Creates a Web API project
    • Web Application (Model-View-Controller): Creates an MVC Web application which also allows us to create APIs

We will be selecting Web Application (Model-View-Controller) from the dialog as shown here:

New ASP.NET web project dialog

  1. In our case, select .NET Core, ASP.NET Core 2.0, and the Web Application (Model-View-Controller) template, and also keep the Authentication set to No Authentication. Click OK:

ASP.NET Core web application

The generated web application displays a tabbed interface which is new to us (instead of displaying index.cshtml). It allows us to access documentation, connect to any service or even decide on publishing options right from the start page.

Note

If we look closely, we will notice that Visual Studio was silently restoring the packages, and almost everything was part of a package in .NET Core. No more heavyweight framework which always loads tons of DLLs even though we don't require them! Now everything is broken into lighter packages which we could utilize based on our requirements.

I know getting into MVC would be a little outside of the scope of this chapter, but let's dig into a few details before we deep dive into the Entity Framework.

Structuring the web app

A .NET Core web application is composed of the following folders:

  • Dependencies: SDK, server, and client-side dependencies
  • wwwroot: All static resources should reside here
  • Connected Services: To connect external services available in Marketplace
  • launchSettings.json: Settings required to launch a web application
  • appSettings.json: Configurations such as logging and connection strings
  • bower.json: Client-side dependencies should be configured here
  • bundleConfig.json: Bundling is moved to the JSON configuration now
  • Program.cs: Everything starts from Main() and any program can be made into a web application using the WebHostBuilder API
  • Startup.cs: For adding and configuring startup services like MVC support, logging, static files support and so on
  • Controllers, Views: Part of MVC and contains actions and corresponding views

The structure we had discussed so far is illustrated in the following screenshot:

ASP.NET Core Web Application structure

The following highlighted sections in Views\Shared\_Layout.cshtml should be modified with the desired application name:

    <!DOCTYPE html>
    <html>
    <head>
      <meta charset="utf-8" />
      <meta name="viewport" content="width=device-width, 
          initial-scale=1.0" />
      <title>@ViewData["Title"] - MasteringEFCore.Web</title>
      ...
    </head>
    <body>
     <nav class="navbar navbar-inverse navbar-fixed-top">
      <div class="container">
        <div class="navbar-header">
          ...
          <a asp-area="" asp-controller="Home" asp-action="Index"
            class="navbar-brand">MasteringEFCore.Web</a>
          ...
        <div class="container body-content">
        ...
        <footer>
           <p>&copy; 2017 - MasteringEFCore.Web</p>
        </footer>
       ...
    </body>

We have created a .NET Core web application with no authentication and explored the structure of the project, which might help us understand MVC in .NET Core. If we expand the dependencies, it is evident that we don't have built-in support for Entity Framework (EF) Core. We will look at the different ways of identifying and installing the packages.

Previous Section
End of Section 3
Next Section