En una anterior entrega vimos lo que era EntityFramework (EF), un ORM para .NET (C#). En está ocasión veremos una alternativa: Dapper.
Dapper es un micro ORM para .NET que:
- Permite ejecutar consultas SQL directamente, pero mapeando resultados a objetos C#.
- Es extremadamente rápido y ligero.
- Compatible con múltiples bases de datos (SQL Server, MySQL/MariaDB, PostgreSQL, etc.).
- Ideal para proyectos donde el rendimiento es crítico y no se requiere toda la abstracción de EF.
Siguiendo el ejemplo del anterior post, crearemos una aplicación usando esta herramienta.
Requisitos:
- Tener instalado dotnet.
- Contar con MariaDB.
- Conocimientos básicos de C# y SQL.
Usaremos la estructura de la tabla persons:
CREATE OR REPLACE TABLE persons( personid INT, lastname VARCHAR(255), firstname VARCHAR(255), address VARCHAR(255), city VARCHAR(255) );
1. Crearemos el proyecto y nos ubicaremos en el directorio creado:
$ dotnet new console -n DemoDapperMariaDB $ cd DemoDapperMariaDB
2. Instalaremos los paquetes nugets necesarios:
$ dotnet add package Dapper $ dotnet add package MySql.Data
3. En el directorio principal crearemos una carpeta llamada Model y dentro de este una clase llamada Person.cs , la cual tendrá este contenido:
namespace Model { public class Person { public int PersonId { get; set; } public string FirstName { get; set; } public string LastName { get; set; } public string Address { get; set; } public string City { get; set; } public Person() { PersonId = 0; LastName = string.Empty; FirstName = string.Empty; Address = string.Empty; City = string.Empty; } } }
4. Ahora crearemos el contexto de conexión a la base de datos:
DbContext.cs
using System.Data; using MySql.Data.MySqlClient; public class DbContext { private readonly string _connectionString = "server=localhost;database=cursomariadb;user=root;password=secreta"; public IDbConnection CreateConnection() => new MySqlConnection(_connectionString); }
5. Modificaremos el programa principal Program.cs para incluir las operaciones CRUD:
using System; using Dapper; using System.Linq; class Program { static void Main() { var db = new DbContext(); // INSERT using (var conn = db.CreateConnection()) { var newPerson = new Person { PersonId = 4, FirstName = "Juan", LastName = "Pérez", Address = "Calle Falsa 123", City = "CDMX" }; conn.Execute("INSERT INTO persons VALUES (@PersonId,@LastName,@FirstName,@Address,@City)", newPerson); Console.WriteLine("Insertado correctamente."); } // SELECT using (var conn = db.CreateConnection()) { var persons = conn.Query<Person>("SELECT * FROM persons").ToList(); Console.WriteLine("Listado de personas:"); foreach (var p in persons) Console.WriteLine($"{p.PersonId} - {p.FirstName} {p.LastName} - {p.City}"); } // UPDATE using (var conn = db.CreateConnection()) { conn.Execute("UPDATE persons SET City=@City WHERE PersonId=@PersonId", new { City = "Guadalajara", PersonId = 4 }); Console.WriteLine("Actualizado correctamente."); } // DELETE using (var conn = db.CreateConnection()) { conn.Execute("DELETE FROM persons WHERE PersonId=@PersonId", new { PersonId = 4 }); Console.WriteLine("Eliminado correctamente."); } } }
Como se puede observar fue necesario la creación de consultas SQL nativas para realizar las operaciones CRUD.
6. Ejecutamos la aplicación:
$ dotnet run
Tabla comparativa Dapper vs EntityFramework
He aquí una tabla comparando ambas herramientas.
| Aspecto | Entity Framework | Dapper |
|---|---|---|
| Tipo de ORM | ORM completo | Micro ORM |
| Abstracción | Alta: genera modelos y consultas automáticamente | Baja: requiere escribir SQL manual |
| Facilidad de uso | Muy sencillo para CRUD básico, menos control sobre SQL | Más control sobre SQL, pero requiere mayor conocimiento |
| Rendimiento | Más lento en escenarios de alto volumen | Muy rápido y eficiente |
| Flexibilidad | Limitada por el modelo y LINQ | Total: puedes usar cualquier consulta SQL |
| Aprendizaje | Curva más suave para principiantes | Curva más técnica, ideal para quienes dominan SQL |
| Casos de uso | Aplicaciones con lógica compleja y necesidad de abstracción | Microservicios, APIs rápidas, proyectos donde el rendimiento es crítico |
| Soporte de base de datos | Amplio, con integración nativa | Amplio, pero depende del proveedor ADO.NET |
| Mantenimiento | Código más limpio y menos SQL explícito | Código más explícito, pero más controlado |
Conclusiones:
- Dapper es más ligero que EF y ofrece control total sobre el SQL.
- Ideal para proyectos donde el rendimiento importa más que la abstracción.
- Aunque requiere escribir consultas manualmente, el código sigue siendo limpio y fácil de mantener.
Continuaremos con esta serie sobre .NET y C#.
Enlaces:
https://www.learndapper.com/https://aspnetcoremaster.com/dotnet/introduccion-a-dapper.html
https://codemonkeyjunior.blogspot.com/2025/11/entity-framework-un-orm-para-net.html
