Book Overview & Buying
Table Of Contents
Feedback & Rating

Mastering Entity Framework Core 2.0

By : Prabhakaran Anbazhagan

3.8 (5)

Buy this Book

Mastering Entity Framework Core 2.0

3.8 (5)

By: Prabhakaran Anbazhagan

Buy this Book

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.

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

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

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

Relationships – Terminology and Conventions

Understanding relationship terms

Conventions in a relationship

Summary

Building Relationships – Understanding Mapping

Relationships

Fluent API

Summary

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

Save Yourself – Hack Proof Your Entities

Client-side validation

Validating data without client-side scripting

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

Composing queries with commands

Enhancing queries with expression trees

Summary

Fail Safe Mechanism – Transactions

Default behavior of a transaction

Creating a simple transaction

Creating a cross-context transaction

Leveraging transactions between multiple technologies

Summary

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

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

Isolation – Building a Multi-Tenant Database

Authentication in the blogging system

Row-Level Security

Multi-tenancy

Summary

Customer Reviews

3.8 (5)

5 star

60%

4 star

3 star

20%

2 star

1 star

20%

Mismatched data types

The mismatched data type would hurt the performance. This might look obvious at first, but if we take a closer look, it is evident that we should be addressing the concern. The following tweaked About view component illustrates the retrieval of data using PhoneNumber rather than Id:

    var aboutViewModel = _context.People
      .Where(item => item.PhoneNumber.Equals("9876543210"))
      //.Where(item => item.Id.Equals(id))
      .Select(item => new AboutViewModel
      {
        Name = item.FirstName,
        Biography = item.Biography
      }).SingleOrDefault();

The preceding LINQ query would be translated into the following SQL query: enable Actual Execution plan with the query execution, and it would be evident that something is wrong here. Whenever we have mismatched data types in a query, the data type conversion...