Entity Framework (EF) is a popular ORM framework for .
NET that allows
developers to interact with a database using .NET objects, eliminating the need
to write most of the SQL queries manually.
Object-Relational Mapping (ORM) is a programming technique used to convert
data between incompatible systems—in this case, between object-oriented
programming languages like C# and relational databases.
How Entity Framework Works for Database Integration
Entity Framework (EF) serves as a bridge between your application and the
database. It provides the following functionalities:
1. Mapping: EF maps your .NET classes to database tables and your class
properties to columns in those tables.
2. Queries: EF allows you to write LINQ (Language Integrated Query)
queries in C#, which EF translates into SQL queries that are executed
against the database.
3. Change Tracking: EF tracks changes made to the objects during runtime
and automatically generates the necessary SQL commands to update the
database.
4. Migrations: EF provides a way to handle changes to the database schema
over time through a process called migrations.
● Approaches with ORM :
When using an ORM, there are three main approaches to work with the database
schema:
1. Code-First Approach:
○ In this approach, you start by writing the classes (code) that
represent the data model. The ORM then generates the database
schema based on these classes.
○ Example: Entity Framework's Code-First approach.
2. Database-First Approach:
○ In this approach, you start with an existing database. The ORM
generates classes (entities) based on the existing database schema.
○ Example: Entity Framework's Database-First approach.
Note : Code-First is a specific approach under ORM where the database schema
is generated based on the classes you define in your code.
Example: ORM with Entity Framework in C#
Let's walk through a simple example to illustrate how EF works for database
integration:
1. Create a Model Class
● This class represents a table in the database.
public class Product //Entity class
{
public int Id { get; set; }
public string Name { get; set; }
public decimal Price { get; set; }
2. Create a DbContext Class
● The DbContext class manages the database connection and acts as
a gateway to the database.
public class ApplicationDbContext : DbContext
public
ApplicationDbContext(DbContextOptions<ApplicationDbContext>
options)
: base(options)
public DbSet<Product> Products { get; set; }
3. Configure the Database Connection
● In your Program.cs, configure the DbContext to connect to your
database.
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("D
efaultConnection")));
var app = builder.Build();
// Use your middlewares, controllers, etc.
app.MapControllers();
app.Run();
5. Define Connection Strings in appsettings.json
● Define the connection strings and database provider in appsettings.json:
{
"ConnectionStrings": {
"DefaultConnection": "YourConnectionStringForMSSQLOrPostgreSQL"
},
"DatabaseProvider": "SqlServer" // or "PostgreSQL"
}
6. Implement CRUD Operations
public class ProductService
private readonly ApplicationDbContext _context;
public ProductService(ApplicationDbContext context)
_context = context;
// Create a new product
public async Task CreateProduct(Product product)
_context.Products.Add(product);
await _context.SaveChangesAsync();
// Read products
public async Task<List<Product>> GetProducts()
return await _context.Products.ToListAsync();
}
// Update a product
public async Task UpdateProduct(Product product)
_context.Products.Update(product);
await _context.SaveChangesAsync();
// Delete a product
public async Task DeleteProduct(int id)
var product = await _context.Products.FindAsync(id);
if (product != null)
_context.Products.Remove(product);
await _context.SaveChangesAsync();
}
5. Apply Migrations
● Use EF migrations to create the database schema based on your
model classes.
dotnet ef migrations add InitialCreate //Add-Migration
dotnet ef database update //Update-Database
Summary:
● Model Class (Product): This represents a table in the database, where
each property corresponds to a column.
● DbContext (ApplicationDbContext): This is the primary class
responsible for interacting with the database. It maps the model classes to
database tables and handles database operations.
● CRUD Operations: You use the DbContext to create, read, update, and
delete records in the database.
● Migrations: Migrations allow you to evolve your database schema as your
application changes, without losing data.
Note : By using Entity Framework as an ORM, you can interact with the
database in an object-oriented way, making your code cleaner and reducing
the need to write raw SQL queries.
Database Configuration
1. Install Required Packages
● Use the following commands to add the necessary EF Core packages:
dotnet add package Microsoft.EntityFrameworkCore.SqlServer //Ms-sql server
dotnet add package Microsoft.EntityFrameworkCore.Npgsql //PostgreSql
2. Create the Entity Model
● Define your entity model class, which represents the database table.
public class Product //YourEntity
{
public int Id { get; set; }
public string Name { get; set; }
public DateTime CreatedAt { get; set; }
}
3. Create the DbContext
● Define a DbContext.cs class to manage your database sessions within the Data
directory.
using dependencyInjection.Models;
using Microsoft.EntityFrameworkCore;
public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: base(options) { }
public DbSet<Product> Products { get; set; }
}
4. Configure the Database in Program.cs
● In ASP.NET Core 8.0, the Program.cs file combines the setup that was previously split
between Startup.cs and Program.cs.
Here's how to set up the database connection conditionally:
var builder = WebApplication.CreateBuilder(args);
// Load configuration from appsettings.json
var databaseProvider = builder.Configuration["DatabaseProvider"];
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
// Conditionally choose the database provider
if (databaseProvider == "SqlServer")
{
builder.Services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(connectionString));
}
else if (databaseProvider == "PostgreSQL")
{
builder.Services.AddDbContext<ApplicationDbContext>(options =>
options.UseNpgsql(connectionString));
}
var app = builder.Build();
// Use your database and other middlewares
app.UseRouting();
app.MapControllers();
app.Run();
5. Define Connection Strings in appsettings.json
● Define the connection strings and database provider in appsettings.json:
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"ConnectionStrings": {
"DefaultConnection":
"Server=LAPTOP-2C0VA32U\\MSSQLSERVER_ASUS;Database=ProductDb;Integrated
Security=True;MultipleActiveResultSets=True;TrustServerCertificate=True;"
},
"DatabaseProvider": "SqlServer" // or "PostgreSQL"
}
6. Implement CRUD Operations
● Create a repository class to handle CRUD operations:
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;
namespace YourNamespace.Repositories
{
public class ProductRepository : IProductRepository
{
private readonly YourDbContext _context;
public ProductRepository(YourDbContext context)
{
_context = context;
}
// Get all products
public IEnumerable<Product> GetProducts()
{
return _context
// Get product by ID
public Product GetProductById(int productId)
{
return _context.Products.Find(productId);
}
// Add a new product
public void AddProduct(Product product)
{
_context.Products.Add(product);
Save();
}
// Update an existing product
public void UpdateProduct(Product product)
{
_context.Entry(product).State = EntityState.Modified;
Save();
}
// Delete a product by ID
public void DeleteProduct(int productId)
{
var product = _context.Products.Find(productId);
if (product != null)
{
_context.Products.Remove(product);
Save();
}
}
// Save changes to the database
public void Save()
{
_context.SaveChanges();
}
}
}
7. Apply Migrations
● Run the following commands to create and apply migrations:
dotnet ef migrations add InitialCreate //Add-Migration
dotnet ef database update //Update-Database
8. LINQ Query Syntax vs. Method Syntax (Lambda Expressions)
● Query Syntax (Plain LINQ Syntax):
○ This is the more SQL-like way of writing LINQ queries. It's often considered
the "plain" or "traditional" LINQ syntax because it resembles SQL query
structure.
○ Example:
var products = from p in context.Products
where p.Price > 100
orderby p.Name
select new { p.Name, p.Price };
Characteristics:
● It uses keywords like from, where, select, orderby, etc., similar to SQL.
● It can be more intuitive for those familiar with SQL.
● Suitable for simpler queries, but it may become cumbersome for more complex
operations.
Method Syntax (Lambda Expressions):
● This syntax involves calling LINQ extension methods directly on collections or
IQueryable objects. Lambda expressions are used to define the logic for these
methods.
● Example:
var products = context.Products
.Where(p => p.Price > 100)
.OrderBy(p => p.Name)
.Select(p => new { p.Name, p.Price })
.ToList();
Characteristics:
● It uses method calls like Where, OrderBy, Select, etc., with lambda expressions
to define operations.
● Often more concise and flexible, especially for complex queries.
● Allows for fluent chaining of methods.
- Example of Lambda Expressions with Entity Framework:
using (var context = new ApplicationDbContext())
{
var expensiveProducts = context.Products
.Where(p => p.Price > 100)
.OrderBy(p => p.Name)
.Select(p => new { p.Name, p.Price })
.ToList();
}
- using LINQ without lambda expressions would look like this:
using (var context = new ApplicationDbContext())
{
var expensiveProducts = from p in context.Products
where p.Price > 100
orderby p.Name
select new { p.Name, p.Price };
var resultList = expensiveProducts.ToList();
}
