Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Entity Framework Core Cookbook - Second Edition

By : Peres

2 (3)

Entity Framework Core Cookbook

2 (3)

By: Peres

Overview of this book

Entity Framework is a highly recommended Object Relation Mapping tool used to build complex systems. In order to survive in this growing market, the knowledge of a framework that helps provide easy access to databases, that is, Entity Framework has become a necessity. This book will provide .NET developers with this knowledge and guide them through working efficiently with data using Entity Framework Core. You will start off by learning how to efficiently use Entity Framework in practical situations. You will gain a deep understanding of mapping properties and find out how to handle validation in Entity Framework. The book will then explain how to work with transactions and stored procedures along with improving Entity Framework using query libraries. Moving on, you will learn to improve complex query scenarios and implement transaction and concurrency control. You will then be taught to improve and develop Entity Framework in complex business scenarios. With the concluding chapter on performance and scalability, this book will get you ready to use Entity Framework proficiently.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Sections

Conventions

Reader feedback

Customer support

Downloading the example code

Free Chapter

1. Improving Entity Framework in the Real World

1. Improving Entity Framework in the Real World

Introduction

Improving Entity Framework by using a code-first approach

Unit testing and mocking

Creating databases from code

Creating mock database connections

Implementing the repository pattern

Implementing the unit of work pattern

2. Mapping Entities

2. Mapping Entities

Introduction

Mapping non-public members

Mapping interfaces

Shadow properties

Creating one-to-one maps

Creating one-to-many maps

Creating many-to-many maps

Creating custom conventions

Using sequence key generators

Using GUIDs as keys

Implementing inheritance – Table per Class hierarchy

3. Validation and Changes

3. Validation and Changes

Introduction

Validating simple properties

Validating the whole entity

Validating groups of entities

Intercepting saving changes

Intercepting property changes

Setting the state of an entity

Improving MVC UI with entity framework validation

Inserting, updating, and deleting entities with stored procedures

Updating the database from model changes

Dumping the SQL script for the database creation

4. Transactions and Concurrency Control

4. Transactions and Concurrency Control

Introduction

Using explicit transactions

Using transactions in custom SQL operations

Implementing optimistic concurrency in SQL Server

Implementing optimistic concurrency in a database-agnostic way

5. Querying

5. Querying

Introduction

Executing client-side functions in LINQ queries

Mixing SQL with LINQ queries

Getting entities from the local cache

Creating filtered collections

Creating reusable queries

Querying shadow properties

Implementing the query object pattern

Using dynamic LINQ

6. Advanced Scenarios

6. Advanced Scenarios

Introduction

Generating entities from the database

Implementing multitenancy

Strongly typed bulk operations

Handling soft deletes

Adding logging

Capturing the audit data

Retrieving entity metadata

Improving MVC applications

Hooking infrastructure services

Using other databases

7. Performance and Scalability

7. Performance and Scalability

Introduction

Improving the performance of queries

Testing and profiling queries

Using asynchronous operations

Eager loading

Using the cache

A. Pitfalls

A. Pitfalls

Introduction

GroupBy executes on the client side

Table per class hierarchy requires nullable columns for derived classes

References not eagerly fetched are lost

Date/time operations are not supported

Paging in SQL Server earlier than 2012

Database null semantics

Migrations and contexts with parameterized constructors

Migrations with contexts in different projects

Accessing the service provider too soon

Setting the maximum string length

Mapping discriminator columns

Composite primary keys

Refreshing entities

Cascading entity deletes

Index

Index

Database null semantics

Doing comparisons with NULL can yield unexpected results.

Problem

Relational database engines treat the NULL case differently. NULL is not a value; rather, it is the absence of a value, so the syntax around it is special. To check if a column value is NULL, this is the syntax we use:

SELECT * FROM MyTable WHERE MyCol IS NULL

Entity Framework, as with other Object-Relational Mappers, has to take this into account. So, what happens if we issue a LINQ query that needs to be executed with a parameter value that may be null? Let's consider this query:

var name = GetParameterValue();
var records = ctx
  .MyEntities
  .Where(x => x.Name == name)
  .ToList();

By default, it will produce the following SQL:

SELECT [x].[Id] AS Id, [x].[Name] AS Name
FROM [dbo].[MyEntities] AS [x]
WHERE ([x].[Name] == @__name_0)
OR (([x].[Name] IS NULL) AND ((@__name_0 IS NULL))

This is hardly ideal and it is caused by the fact that, when the SQL is being generated, Entity Framework does not...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Entity Framework Core Cookbook

Search

Your notes and bookmarks