Mastering Entity Framework Core 2.0电子书

Title Page

Copyright

Mastering Entity Framework Core 2.0

Credits

About the Author

About the Reviewers

www.PacktPub.com

Why subscribe?

Customer Feedback

Dedication

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

Kickstart - Introduction to Entity Framework Core

Prerequisites

Creating a new project

The Start page

The File menu

Structuring the web app

Installing Entity Framework

Data models

Blog entity

Post entity

Database context

Registering the context in services (.NET Core DI)

Creating and seeding databases

CRUD operations

Summary

The Other Way Around – Database First Approach

Preparing the database

Blog entity script

Post entity script

Creating new project

Installing Entity Framework

Reverse engineering the database

Configuring data context

Working with the Blog entity

Working with the Post entity

Registering context in services (.NET Core DI)

Refactoring the OnConfiguring() method

Refactoring the ConfigureServices method

The appsettings.json setting

Performing CRUD operations

Creating controller action

Edit controller action

The Delete view

Summary

Relationships – Terminology and Conventions

Understanding relationship terms

Data models

Blog entity

The Post entity

Principal entity

Principal key

Dependent entity

Foreign key

Navigation property

Collection navigation property

Reference navigation property

Inverse navigation property

Conventions in a relationship

Fully-defined relationships

Fully-defined relationships - under the hood

No foreign key property

No foreign key property - under the hood

Single navigation property

Foreign key

Inverse property

Summary

Building Relationships – Understanding Mapping

Relationships

The one-to-one relationship

Building one-to-one relationships using the Fluent API

The one-to-many relationship

The many-to-many relationship

Building many-to-many relationship using the Fluent API

Fluent API

Identifying navigation property and inverse navigation

Identifying the single navigation property

Relationship-building techniques

Building relationship using a foreign key

Building relationships using a principal key

Building relationships using the IsRequired method

Cascade delete

Data migration issue with EF Core 2.0

Summary

Know the Validation – Explore Inbuilt Validations

Diving into built-in validations

Required field validation

Incorporating the Required validation in blogging system models

EmailAddress field validation

Incorporating EmailAddress validation in blogging system models

Compare field validation

Incorporating the Compare validation in blogging system models

Url field validation

Incorporating Url validation in blogging system models

MinLength field validation

MaxLength field validation

RegularExpression field validation

Summary

Save Yourself – Hack Proof Your Entities

Client-side validation

Validating data without client-side scripting

Server-side validation

Manual validation

Custom validation

Creating client-side logic for custom validation

Remote validation

Summary

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

Query Is All We Need – Query Object Pattern

Introduction to query objects

Improving repositories with the query object pattern

Introduction to repositories

Solution to the repository assignment

Incorporating the query object pattern into repositories

List query object support in the repository

Single query object support in the repository

Solution to the repository with the queries assignment

Composing queries with commands

Solution to the command queries assignment

Enhancing queries with expression trees

Solution to the expression trees assignment

Summary

Fail Safe Mechanism – Transactions

Default behavior of a transaction

Adding tags support in the blogging system

Leveraging default transaction behavior

Creating a simple transaction

Creating a cross-context transaction

File upload support to the blogging system

Limitations to the transaction scope

Custom transaction scope support

Adding date picker support to the blogging system

Leveraging transactions between multiple technologies

Recent posts support to the blogging system

Anonymous posts list and individual blog post

Listing comments

Adding comments using external database transactions

Summary

Make It Real – Handling Concurrencies

Handling concurrency in EF

Understanding the concurrency conflicts

Optimistic concurrency

Pessimistic concurrency

Introducing concurrency tokens

Non-timestamp based concurrency tokens

Configuring non-timestamp tokens through data annotation

Configuring non-timestamp tokens through Fluent API

Timestamp-based concurrency tokens

Configuring timestamp tokens through data annotation

Configuring timestamp tokens through Fluent API

Handling concurrency conflicts

Applying optimistic concurrency

Database wins

Client wins

User-specific custom resolution

Applying pessimistic concurrency

Summary

Performance – It's All About Execution Time

The AsNoTracking() method

How does tracking work?

No-tracking queries

Projections

Detecting changes

Asynchronous operations

Transactions leveraging asynchronous operations

Unnecessary volume returned

The N+1 Select problem

More data than required

Mismatched data types

Missing indexes

Summary

Isolation – Building a Multi-Tenant Database

Authentication in the blogging system

Row-Level Security

Filter predicate

Block predicate

Multi-tenancy

Standalone

Database-per-tenant

Shared multi-tenant

Dive into multi-tenancy

Blocking cross-tenant write operation

Summary