Comparing .NET EF Core and Dapper: A Developer’s Guide

When it comes to data access in the .NET ecosystem, Entity Framework Core (EF Core) and Dapper are among the most popular choices. Both libraries offer a set of high-level APIs for interacting with relational databases, but they differ significantly in terms of complexity, performance, and flexibility. In this blog post, we’ll compare these two libraries to help you make an informed decision for your next .NET project.

Introduction

Entity Framework Core (EF Core)
Entity Framework Core is an Object-Relational Mapping (ORM) framework developed by Microsoft. It allows developers to work with databases using .NET objects, abstracting much of the underlying database interactions. It’s a feature-rich, extensible, and highly configurable framework that provides everything from data retrieval to data modeling.

Dapper
Dapper is a micro-ORM, also built for the .NET ecosystem. It was developed by the Stack Overflow team and is more lightweight compared to EF Core. Dapper provides a set of helper functions for executing raw SQL queries, offering a performance-optimized, straightforward approach to data access.
Comparison Criteria

Ease of Use
Performance
Flexibility
Community and Support
Advanced Features

Ease of Use
EF Core

Code-First Approach: EF Core allows developers to define database schema using C# classes.
LINQ Support: Offers seamless integration with LINQ, making data queries more intuitive.
Database Migrations: Built-in support for database migrations and schema management.

Dapper

SQL-Centric: Requires writing raw SQL queries, which could be more intuitive for those familiar with SQL.
Less Boilerplate: Typically requires less boilerplate code for simple CRUD operations.

Performance
EF Core

Overhead: The abstraction layer and additional features can introduce performance overhead.
Lazy Loading: Offers lazy loading, which can be both an advantage and a drawback based on use-case.

Dapper

Speed: Known for high-performance data access, as it’s closer to raw SQL.
No Overhead: Minimal abstraction layer means less overhead.

Flexibility
EF Core

Extensible: Highly configurable and extensible, allowing for a wide range of customization.
Multiple Database Support: Built-in support for multiple database providers.

Dapper

Focused: Does one thing (data access) and does it well.
Custom Queries: Since you write raw SQL, you have complete control over the queries.

Community and Support
EF Core

Strong Community: Being a Microsoft product, it has a strong community and extensive documentation.
Regular Updates: Regularly updated with new features and performance improvements.

Dapper

Growing Community: Although smaller than EF Core, the community is active and growing.
Good Documentation: Adequate documentation and plenty of third-party tutorials.

Advanced Features
EF Core

Change Tracking: Automatically tracks changes to entities and updates them in the database.
Relationship Management: Built-in support for managing complex relationships, transactions, and joins.

Dapper

Batch Queries: Supports batch querying and multiple result sets.
Stored Procedures: Easy to call stored procedures and map results.

Here is the working sample for the Entity Framework Core.

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

Now, let’s define the DbContext

public class AppDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("YourConnectionStringHere");
    }
}

CRUD Operations

// Create
using (var context = new AppDbContext())
{
    var product = new Product { Name = "Laptop", Price = 1000M };
    context.Products.Add(product);
    context.SaveChanges();
}

// Read
using (var context = new AppDbContext())
{
    var product = context.Products.Find(1);
    Console.WriteLine(product.Name);
}

// Update
using (var context = new AppDbContext())
{
    var product = context.Products.Find(1);
    product.Price = 1200M;
    context.SaveChanges();
}

// Delete
using (var context = new AppDbContext())
{
    var product = context.Products.Find(1);
    context.Products.Remove(product);
    context.SaveChanges();
}

Now, let’s look at Dapper example:

First, let’s define the Product class, similar to the EF Core example.

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

CRUD Operations

using System.Data.SqlClient;
using Dapper;

// Create
using (var connection = new SqlConnection("YourConnectionStringHere"))
{
    var product = new Product { Name = "Laptop", Price = 1000M };
    connection.Execute("INSERT INTO Products (Name, Price) VALUES (@Name, @Price)", product);
}

// Read
using (var connection = new SqlConnection("YourConnectionStringHere"))
{
    var product = connection.QueryFirstOrDefault<Product>("SELECT * FROM Products WHERE Id = @Id", new { Id = 1 });
    Console.WriteLine(product.Name);
}

// Update
using (var connection = new SqlConnection("YourConnectionStringHere"))
{
    var product = new Product { Id = 1, Price = 1200M };
    connection.Execute("UPDATE Products SET Price = @Price WHERE Id = @Id", product);
}

// Delete
using (var connection = new SqlConnection("YourConnectionStringHere"))
{
    connection.Execute("DELETE FROM Products WHERE Id = @Id", new { Id = 1 });
}

Conclusion

Choosing between EF Core and Dapper depends on your project’s needs. If you need a full-featured ORM with advanced capabilities and don’t mind the extra overhead, EF Core is the way to go. On the other hand, if you need a lightweight, high-performance library and are comfortable with SQL, Dapper could be a better fit.

Both libraries have their strengths and weaknesses, and the “best” choice is highly contextual. Consider your team’s expertise, your project’s requirements, and your performance needs when making a decision.

In order to understand the both with realworld examples, I have created Microservices Learning Series in detail.

Docker, Kubernetes, Identity Server 4, Rabbit MQ, Angular 15, GRPC, Istio Service Mesh, SQL Server, MongoDB, PostGreSQL, Dapper, Redis, Ocelot, Nginx, Azure, Helm Charts, and Auto Scale.

In this comprehensive course, you’ll gain hands-on experience with Docker and Kubernetes to deploy and manage your Microservices. You’ll learn how to integrate Identity Server 4 for secure authentication and authorization, Rabbit MQ for messaging, and GRPC for efficient communication between Microservices.

You’ll also learn how to use Istio Service Mesh to manage Microservices traffic, and how to configure and optimize SQL Server, MongoDB, PostGreSQL, and Redis for your Microservices. You’ll use Ocelot and Nginx to manage your Microservices API gateway and deploy your Microservices to Azure using Helm Charts.

By the end of this course, you’ll have a solid understanding of how to design, develop, and deploy Microservices using the latest industry-standard tools and practices, including auto-scaling.

Who Should Take This Course?

1. Freshers who want to learn how to build scalable and efficient systems using Microservices architecture.
2. Junior Developers who are looking to level up their skills and gain experience building real-world Microservices applications.
3. Mid-Level Developers who want to learn how to build and deploy Microservices using the latest industry-standard tools and practices.
4. Senior Developers who are looking to stay ahead of the curve and keep their skills up-to-date with the latest trends and technologies.
5. Software Architects who want to learn how to design and develop scalable, distributed, and fault-tolerant systems using Microservices.
6. Technical Leads who want to gain a deeper understanding of Microservices architecture and lead their teams in building scalable and efficient systems.

In this comprehensive course, you’ll gain invaluable knowledge and hands-on experience as we explore the following exciting topics:

Implementing clean architecture principles in .Net Core Microservices

Building scalable and maintainable Microservices using industry best practices

Applying Containerization techniques with Docker for Microservice deployment

Orchestrating Microservices using Kubernetes for seamless scalability

Enroll here Creating .Net Core Microservices using Clean Architecture

Take advantage of these limited-time offers and continue your learning journey today! Don’t miss out on expanding your Microservices expertise. Enroll now and unlock the potential of clean architecture with me!

Thanks for Joining Me.

Happy Coding

---

Also published on Medium.