Entity Framework (0-1), Overview Additions

After I wrote several articles on this site, I found out it seemed almost for every article, I needed to set up a sample application associated with an entity framework if accessing the database. And, every time, I needed to rewrite the setup process from scratch in order for a new reader to follow along easily. Even for introducing a very simple concept, such as Caching, I needed to spend 80% of the time setting up the sample app, and only 20%  on introducing the Caching concept itself.

Therefore, I think it is better to write a basic model such as entity framework sample for various approaches, and then I can reuse them when needed. I made a list of the series of articles below, I will write them one by one, while the Entity framework overview and concept will be covered in article (0):

• Entity Framework (0), Overview
  • Entity Framework (0-1), Overview Additions --- this article
• Entity Framework (1), with .Net MVC, Code-First 
• Entity Framework (2), with .Net MVC, Database-First
• Entity Framework (3), with .Net MVC, Model-First
• Entity Framework (4), with .Net Core MVC, Code-First
• Entity Framework (5), with .Net Core MVC, Database-First
• Entity Framework (6), with .Net Core MVC, Model-First
• Entity Framework (7), with .Net WPF, Database-First
• Entity Framework (8), with .NET Core Web API, Stored Procedure
• Entity Framework (9), with .NET Core Web API, Stored Procedure Implementation

Note
We write the Entity Framework for MVC module, but the pattern is the same or similar when applying to Web Application or Web API.

Introduction

This article is a note written on 10/27/2020.  I think they are additions to the article Entity Framework (0), Overview, I will not add them to the previous article, but add them here as a continuous part. 

The paragraph numbers will follow the article, Entity Framework (0), Overview:

• Introduction
• D - Overview of the ADO.NET Entity Framework
• E - Entity Framework Features
• F - Entity Framework History
• G - Difference between Entity Framework and LINQ to SQL by .NET 4.0 

D - Overview of the ADO.NET Entity Framework

Entity Framework is an open-source ORM framework for .NET applications supported by Microsoft. It enables developers to work with data using objects of domain specific classes without focusing on the underlying database tables and columns where this data is stored. With the Entity Framework, developers can work at a higher level of abstraction when they deal with data, and can create and maintain data-oriented applications with less code compared with traditional applications.

Official Definition: “Entity Framework is an object-relational mapper (O/RM) that enables .NET developers to work with a database using .NET objects. It eliminates the need for most of the data-access code that developers usually need to write.”

The following figure illustrates where the Entity Framework fits into your application.

As per the above figure, Entity Framework fits between the business entities (domain classes) and the database. It saves data stored in the properties of business entities and also retrieves data from the database and converts it to business entities objects automatically.

E - Entity Framework Features

• Cross-platform: EF Core is a cross-platform framework which can run on Windows, Linux and Mac.
• Modelling: EF (Entity Framework) creates an EDM (Entity Data Model) based on POCO (Plain Old CLR Object) entities with get/set properties of different data types. It uses this model when querying or saving entity data to the underlying database.
• Querying: EF allows us to use LINQ queries (C#/VB.NET) to retrieve data from the underlying database. The database provider will translate this LINQ queries to the database-specific query language (e.g. SQL for a relational database). EF also allows us to execute raw SQL queries directly to the database.
• Change Tracking: EF keeps track of changes occurred to instances of your entities (Property values) which need to be submitted to the database.
• Saving: EF executes INSERT, UPDATE, and DELETE commands to the database based on the changes occurred to your entities when you call the SaveChanges() method. EF also provides the asynchronous SaveChangesAsync() method.
• Concurrency: EF uses Optimistic Concurrency by default to protect overwriting changes made by another user since data was fetched from the database.
• Transactions: EF performs automatic transaction management while querying or saving data. It also provides options to customize transaction management.
• Caching: EF includes first level of caching out of the box. So, repeated querying will return data from the cache instead of hitting the database.
• Built-in Conventions: EF follows conventions over the configuration programming pattern, and includes a set of default rules which automatically configure the EF model.
• Configurations: EF allows us to configure the EF model by using data annotation attributes or Fluent API to override default conventions.
• Migrations: EF provides a set of migration commands that can be executed on the NuGet Package Manager Console or the Command Line Interface to create or manage underlying database Schema.

F - Entity Framework History

Microsoft introduced Entity Framework in 2008 with .NET Framework 3.5. Since then, it released many versions of Entity Framework. Currently, there are two latest versions of Entity Framework: EF 6 and EF Core. (Note: this note is taken in 10/07/2020)

G - Difference between Entity Framework and LINQ to SQL by .NET 4.0

They are somewhat similar, and can be used in a very similar way, code-wise, but they have some important differences. Note that "LINQ" is not the same thing as "LINQ to SQL"; the EF also uses LINQ. Some notable differences are:

• LINQ to SQL is largely SQL Server only, not so much by design as by implementation. The EF is designed to support, and does support, multiple DBs, if you have a compatible ADO.NET provider.
• Out of the box, LINQ to SQL has a very poor story for DB metadata changes. You have to regenerate parts of your model from scratch, and you lose customizations.
• The EF supports model features like many-to-many relationships and inheritance. LINQ to SQL does not directly support these.
• In .NET 3.5, LINQ to SQL had much better support for SQL-Server-specific functionality than the EF. This is mostly not true in .NET 4; they're fairly similar in that respect.
• The EF lets you choose Model First, DB First, or Code First modeling. LINQ to SQL, out of the box, really only supports DB First.

Difference between LINQ to SQL and Entity Framework:

LINQ to SQL

• It only works with SQL Server Database.
• It generates a .dbml to maintain the relation
• It has no support for complex type.
• It cannot generate a database from model.
• It allows only one to one mapping between the entity classes and the relational tables /views.
• It allows you to query data using DataContext.
• It provides a tightly coupled approach.
• It can be used for rapid application development only with SQL Server.

Entity Framework

• It can work with various databases like Oracle, DB2, MYSQL, SQL Server, etc.
• It generates a .edmx file initially. The relation is maintained using 3 different files .csdl, .msl and .ssdl
• It has support for complex type.
• It can generate a database from model.
• It allows one-to-one, one-to-many & many-to-many mappings between the Entity classes and the relational tables /views
• It allows you to query data using EntitySQL, ObjectContext, DbContext.
• It provides a loosely coupled approach. Since its code first approach allows you to use Dependency Injection pattern which make it loosely coupled.
• It can be used for rapid application development with RDBMS like SQL Server, Oracle, DB2 and MySQL, etc.