Dapper: un micro ORM para .NET

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