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

Entity Framework: un ORM para .NET

Para los programadores Java que han usado Hibernate o cualquier otro ORM sabrán que son herramientas muy útiles para el mapeo de tablas y clases Java. Pues ahorran una gran cantidad de código y horas de esfuerzo.

.NET tiene un ORM llamado EntityFramework (EF), el cual es:

"... un mapeador objeto-relacional (ORM) de Microsoft para .NET que permite a los desarrolladores interactuar con bases de datos relacionales usando objetos de C# en lugar de escribir consultas SQL".

Un ORM nos permite manipular la información de las tablas como objetos. Esto nos evita tener que lidiar con SQL nativo.

Al usar EntityFramework podemos:

• Mapear las tablas de nuestra base de datos como si fueran clases. 
• Manipular la información de las tablas sin necesidad de sentencias SQL. 
• Contar con las operaciones CRUD ya "integradas". 
• Compatibilidad con LINQ (un lenguaje para realizar consultas con C#). 
• Permitir conectarnos distintas fuentes de datos como MS SQL Server, MySQL, PostgreSQL, etc. 
• Simplificar nuestro código.

También debemos tener cuidado de:

1. Observar el rendimiento de las consultas. 
2. Entender cómo se usa LINQ.

Al usar un ORM debemos entender:

1. Qué base de datos vamos a usar. 
2. Qué es lo que queremos mapear (tablas). 
3. Convertir la estructura de las tablas a objetos (mapeo). 
4. Qué operaciones vamos a realizar sobre esos objetos (operaciones CRUD).

Comenzando con EntityFramework

Crearemos una sencilla aplicación C# usando el ORM EntityFramework.

Requisitos:

• Contar con la herramienta dotnet instalada. 
• Contar con MariaDB instalado. 
• Tener nociones de C#.

1. Es necesario contar con una base de datos ("cursomariadb") y al menos una tabla en la misma (persons).

CREATE OR REPLACE TABLE persons(
personid int, 
lastname varchar(255), 
firstname varchar(255), 
address varchar(255), 
city varchar(255)
);

3. Crearemos el proyecto con la herramienta dotnet y nos ubicaremos en el directorio creado:

$ dotnet new console -n DemoEFMariaDB
$ cd DemoEFMariaDB

4. Instalar los paquetes nugets necesarios:

$ dotnet add package Microsoft.EntityFrameworkCore --version 8.0.0
$ dotnet add package Pomelo.EntityFrameworkCore.MySql --version 8.0.0

Con estos instalamos EntityFramework y el conector a MariaDB (recordar que es un fork de MySQL).

5. Dentro del directorio del proyecto crearemos una carpeta llamada Model y dentro una clase C# que homologue a la tabla.

Person.cs

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;
        }

    }

}

6. Ahora crearemos una clase contexto para la conexión a la base de datos.

AppDbContext.cs

using Microsoft.EntityFrameworkCore;
using Model;


public class AppDbContext : DbContext
{
    public DbSet<Person> Persons { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseMySql(
            "server=localhost;database=cursomariadb;user=root;password=secreta",
            new MySqlServerVersion(new Version(10, 11, 2)) 
        );
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Person>().ToTable("persons"); 
        modelBuilder.Entity<Person>().HasKey(p => p.PersonId);
    }
}

7. Modificaremos el programa principal del proyecto para agregar las operaciones CRUD. Comenzaremos con la operación INSERT INTO .

Program.cs

using System;
using System.Linq;
using Model;

class Program
{
    static void Main()
    {
        using var db = new AppDbContext();

        // INSERT
        var newPerson = new Person
        {
            PersonId = 4,
            FirstName = "Juan",
            LastName = "Pérez",
            Address = "Calle Falsa 123",
            City = "CDMX"
        };
        db.Persons.Add(newPerson);
        db.SaveChanges();
        Console.WriteLine("Insertado correctamente.");
    }

}

Seguiremos con la instrucción SELECT:

// SELECT
        var persons = db.Persons.ToList();
        Console.WriteLine("Listado de personas:");
        foreach (var p in persons)
        {
            Console.WriteLine($"{p.PersonId} - {p.FirstName} {p.LastName} - {p.City}");
        }

Ahora con la instrucción UPDATE:

 // UPDATE
        var personToUpdate = db.Persons.FirstOrDefault(p => p.PersonId == 4);
        if (personToUpdate != null)
        {
            personToUpdate.City = "Guadalajara";
            db.SaveChanges();
            Console.WriteLine("Actualizado correctamente.");
        }

Finalmente con la instrucción DELETE:

// DELETE
        var personToDelete = db.Persons.FirstOrDefault(p => p.PersonId == 4);
        if (personToDelete != null)
        {
            db.Persons.Remove(personToDelete);
            db.SaveChanges();
            Console.WriteLine("Eliminado correctamente.");
        }

Código completo:

using System;
using System.Linq;
using Model;

class Program
{
    static void Main()
    {
        using var db = new AppDbContext();

        // INSERT
        var newPerson = new Person
        {
            PersonId = 4,
            FirstName = "Juan",
            LastName = "Pérez",
            Address = "Calle Falsa 123",
            City = "CDMX"
        };
        db.Persons.Add(newPerson);
        db.SaveChanges();
        Console.WriteLine("Insertado correctamente.");

        // SELECT
        var persons = db.Persons.ToList();
        Console.WriteLine("Listado de personas:");
        foreach (var p in persons)
        {
            Console.WriteLine($"{p.PersonId} - {p.FirstName} {p.LastName} - {p.City}");
        }

        // UPDATE
        var personToUpdate = db.Persons.FirstOrDefault(p => p.PersonId == 4);
        if (personToUpdate != null)
        {
            personToUpdate.City = "Guadalajara";
            db.SaveChanges();
            Console.WriteLine("Actualizado correctamente.");
        }

        // DELETE
        var personToDelete = db.Persons.FirstOrDefault(p => p.PersonId == 4);
        if (personToDelete != null)
        {
            db.Persons.Remove(personToDelete);
            db.SaveChanges();
            Console.WriteLine("Eliminado correctamente.");
        }
    }
}

8. Ejecutamos la aplicación:

$ dotnet run

Salida:

Insertado correctamente.
Listado de personas:
1 - Carmen Moreno - EDOMEX
2 - Jimena Torres - Toluca
3 - Torres Manuel - Cuajimalpa
4 - Juan Pérez - CDMX
Actualizado correctamente.

¡Hemos creado una aplicación C# con EntityFramework !

Conclusiones:

• EntityFramework es una herramienta poderosa que nos ahorra tiempo de desarrollo simplificando el acceso datos y su manipulación. 
• LINQ hace que las operaciones sobre las tablas sea más sencillo.
• Su soporte a varias fuentes de datos es muy útil y no nos limita a usar una sola.
• La complejidad de código se reduce abruptamente, ¡parece magia!
• Aunque tiene muchas ventajas hay que considerar el rendimiento cuando existe una gran cantidad de datos.

Seguiremos con esta serie sobre C#.

Enlaces:

https://andresledo.es/csharp/entity-framework-core/
https://medium.com/@ravipatel.it/a-beginners-guide-to-entity-framework-core-ef-core-5cde48fc7f7a
https://codemonkeyjunior.blogspot.com/2025/08/programando-en-c-no-9-usando-nuget.html
https://codemonkeyjunior.blogspot.com/2019/06/instalar-paquetes-nuget-con-dotnet.html
https://es.wikipedia.org/wiki/Language_Integrated_Query
https://blog.georgekosmidis.net/using-mariadb-in-an-aspnet-core-api-with-entity-framework-core.html
https://www.entityframeworktutorial.net/
https://www.learnentityframeworkcore.com/
https://learn.microsoft.com/es-es/ef/