C# Tutorial Dapper: Conectar NET a base de datos

Existen diversos métodos con los que podemos conectar una aplicación .NET con una base de datos, podemos hacerlo a la vieja usanza con el SQL Command, con Entity Framework o con Dapper que es lo que veremos en este tutorial.

Qué es Dapper

Dapper al igual que Entity Framework es un ORM, sin embargo, a diferencia del propio Entity Framework, Dapper es mucho más ligero, por lo que podríamos decir que es un Micro ORM o un ORM ligero.

Dapper es muchísimo más rápido que Entity Framework aunque sinceramente esa velocidad no la vas a notar tú en el día a día, porque la diferencia entre uno u otro muchas veces no llega ni a milisegundos, así que más bien debes escoger Dapper sobre Entity Framework por cuestiones de simplicidad o ligereza.

Dapper es perfecto para aquellas aplicaciones pequeñas y ligeras en las que no debes realizar una gran cantidad de consultas a la base de datos.

Bases de datos soportadas por Dapper

Dapper soporta practicamente todas las bases de datos conocidas, obviamente no vas a tener problemas con las más conocidas: SQLServer, MySQL, SQLite, Oracle, PostgreSQL, etc…

Incluso es posible conectar Dapper a ODBC haciéndolo prácticamente compatible con cualquier motor de base de datos que se te ocurra.

Tutorial Dapper

Comencemos con el tutorial de Dapper, en él verás como conectarlo a SQLServer, aunque simplemente cambiando la cadena de conexión y el proveedor de base de datos te sirve para prácticamente cualquier base de datos.

Creando el proyecto .NET

Comenzaremos nuestra andadura creando un proyecto sobre el que haremos las pruebas, abrimos Visual Studio y creamos una aplicación de consola.

Como framework escojo el último disponible .NET 6 en mi caso, es posible que cuando tú veas el tutorial ya haya salido NET 7 o ¿Quizás NET 8? Escoge el que quieras no habrá grandes cambios en el código fuente de uno a otro.

Pulsamos siguiente y ya tendremos nuestro proyecto creado.

Creando la base de datos de pruebas en SQL Server

Creamos una nueva base de datos con Microsoft SQL Server Management Studio, llamamos a esta base de datos “Notas”.

Creamos la tabla y los registros de nuestra base de datos con el siguiente código:

USE [Notas]
GO
/****** Object:  Table [dbo].[Marks]    Script Date: 23/09/2022 9:34:14 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Marks](
	[Id] [int] IDENTITY(1,1) NOT NULL,
	[Name] [nvarchar](50) NOT NULL,
	[Surname] [nvarchar](100) NOT NULL,
	[Nota] [decimal](18, 2) NOT NULL
) ON [PRIMARY]
GO
SET IDENTITY_INSERT [dbo].[Marks] ON 
GO
INSERT [dbo].[Marks] ([Id], [Name], [Surname], [Nota]) VALUES (4, N'higinio', N'canales', CAST(5.00 AS Decimal(18, 2)))
GO
INSERT [dbo].[Marks] ([Id], [Name], [Surname], [Nota]) VALUES (5, N'alexandra', N'climent', CAST(6.00 AS Decimal(18, 2)))
GO
INSERT [dbo].[Marks] ([Id], [Name], [Surname], [Nota]) VALUES (6, N'alina', N'contreras', CAST(4.00 AS Decimal(18, 2)))
GO
INSERT [dbo].[Marks] ([Id], [Name], [Surname], [Nota]) VALUES (8, N'isaias ', N'picazo', CAST(3.00 AS Decimal(18, 2)))
GO
INSERT [dbo].[Marks] ([Id], [Name], [Surname], [Nota]) VALUES (10, N'antoni', N'baez', CAST(8.00 AS Decimal(18, 2)))
GO
INSERT [dbo].[Marks] ([Id], [Name], [Surname], [Nota]) VALUES (11, N'raul', N'adan', CAST(6.00 AS Decimal(18, 2)))
GO
INSERT [dbo].[Marks] ([Id], [Name], [Surname], [Nota]) VALUES (12, N'edgar', N'echeverria', CAST(10.00 AS Decimal(18, 2)))
GO
INSERT [dbo].[Marks] ([Id], [Name], [Surname], [Nota]) VALUES (13, N'maribel ', N'checa', CAST(9.00 AS Decimal(18, 2)))
GO
INSERT [dbo].[Marks] ([Id], [Name], [Surname], [Nota]) VALUES (15, N'francesc ', N'tudela', CAST(1.00 AS Decimal(18, 2)))
GO
INSERT [dbo].[Marks] ([Id], [Name], [Surname], [Nota]) VALUES (17, N'valeria ', N'moro', CAST(3.00 AS Decimal(18, 2)))
GO
SET IDENTITY_INSERT [dbo].[Marks] OFF
GO

NOTA: Lógicamente, lo ideal sería crear dos tablas, una de alumnos y otra de notas y relacionarlas entre ellas, pero como esto pretende ser un tutorial se crea en una única tabla, aunque esto no es una práctica que debes de seguir en tus proyectos.

El resultado sería el siguiente.

Instalar Dapper en el proyecto .NET

Dapper se instala como cualquier otro paquete NuGet, para ello vamos a Visual Studio hacemos un clic derecho sobre nuestro proyecto y pulsamos en “Administrador de paquetes”, clicamos en examinar y buscamos Dapper y pulsamos en instalar.

Para acabar la instalación de Dapper también debemos instalar el proveedor de la base de datos, en nuestro caso sería Microsoft.Data.SqlClient. Este es uno de los pasos que debes cambiar en caso de que la base de datos a la que te quieres conectar no sea SQL Server.

Estructurando el proyecto

Para crear una estructura más o menos correcta vamos a crear dos carpetas en nuestro proyecto, una llamada “Entities” que contendrá los modelos de las tablas de nuestra base de datos y otra llamada “Services” que contendrá los servicios que nos permitirán hacer acciones sobre nuestra base de datos.

Creamos el modelo de la tabla notas

Empezaremos creando un modelo que será el que nos permita almacenar nuestros registros de la base de datos, para ello hacemos clic derecho sobre la carpeta, pulsamos en agregar y luego en clase, el nombre de esta clase será “Mark.cs” y reemplazamos el contenido por lo siguiente:

namespace TutorialDapper.Entities
{
    public class Mark
    {
        public int Id { get; set; }
        public string Name { get; set; } = String.Empty;
        public string Surname { get; set; } = String.Empty;
        public decimal Nota { get; set; }
    }
}

Creando el servicio

Pulsamos clic derecho sobre la carpeta Services, pulsamos en agregar, luego en clase y como nombre escribimos “MarkService.cs”.

CRUD con Dapper

Volvemos a abrir nuestro MarkService y substituimos el código por el siguiente, está comentado lo que hace cada función.

using Dapper;
using Microsoft.Data.SqlClient;
using TutorialDapper.Entities;

namespace TutorialDapper.Services
{
    public class MarkService
    {
        //Connection string de nuestra base de datos, substituir por tus parámetros de conexión
        //NOTA: No es recomendable guardar la connection string en el código fuente, para no hacer
        //más largo el tutorial la guardamos aquí, pero debería escribirse en un json externo al código
        private static string _connectionString = "Server=TORRE;Database=Notas;User Id=sa;Password=Informatica_1;";

        public static List<Mark> GetMarks()
        {
            //SQL que ejecutara Dapper, aquí puedes jugar con los orders que quieras.
            string sql = @"SELECT [Id]
                              ,[Name]
                              ,[Surname]
                              ,[Nota]
                          FROM [Marks] 
                          ORDER BY Surname";

            //Iniciar la conexión con la base de datos
            var db = new SqlConnection(_connectionString);

            //Ejecutar la consulta SQL y almacenar las líneas en nuestro modelo. 
            var marks = db.Query<Mark>(sql);

            //Dapper devuelve un IEnumerable para trabajar más cómodos lo convertimos a listas. 
            return marks.ToList();
        }

        public static Mark GetMark(int id)
        {
            //En este caso tenemos que introducir un parametro para el Id,
            //NUNCA concatenes directamente la variable en el SQL porque puedes padecer inyecciones SQL
            string sql = @"SELECT [Id]
                              ,[Name]
                              ,[Surname]
                              ,[Nota]
                          FROM [Marks] 
                          WHERE Id = @id";

            //Iniciar la conexión con la base de datos
            var db = new SqlConnection(_connectionString);

            //Ejecutar la consulta SQL y pasar los parametros en un objeto, como id se llama igual
            //en la variable que en el parametro no hace falta escribir id = id. 
            //Agregamos first para que solo nos devuelva una línea (obviamente solo va a haber una al buscar por id)
            var mark = db.QueryFirst<Mark>(sql, new { id });

            //Devolvemos el objeto.
            return mark;
        }

        public static int CreateMark(Mark mark)
        {
            //Generamos la consulta con sus correspondientes parametros, agregamos
            //OUTPUT para que nos devuelva el id del registro insertado.
            string sql = @"INSERT INTO [Marks] ([Name], [Surname], [Nota])
                            OUTPUT INSERTED.Id
                           VALUES (@name, @surname, @mark);";

            //Iniciar la conexión con la base de datos
            var db = new SqlConnection(_connectionString);

            //Mapeamos los parametros y ejecutamos la consulta.
            var id = db.QuerySingle<int>(sql, new
            {
                name = mark.Name,
                surname = mark.Surname,
                mark = mark.Nota,
            });

            //Devolvemos el id del registro insertado
            return id;

        }

        public static void UpdateMark(Mark mark, int id)
        {
            //Generamos la consulta con sus correspondientes parametros
            string sql = @"UPDATE [Marks] 
                           SET
                                [Name] = @name, 
                                [Surname] = @surname, 
                                [Nota] = @mark 
                           WHERE 
                                [Id] = @id";

            //Iniciar la conexión con la base de datos
            var db = new SqlConnection(_connectionString);

            //Mapeamos los parametros y ejecutamos la consulta.
            db.Query(sql, new
            {
                id,
                name = mark.Name,
                surname = mark.Surname,
                mark = mark.Nota,
            });
        }

        public static void DeleteMark(int id)
        {
            //Generamos la consulta con sus correspondientes parametros
            string sql = @"DELETE FROM [Marks]       
                           WHERE [Id] = @id";

            //Iniciar la conexión con la base de datos
            var db = new SqlConnection(_connectionString);

            //Mapeamos los parametros y ejecutamos la consulta.
            db.Query(sql, new { id});
        }


    }
}

Como esto pretende ser un tutorial simple, la connection string se mapea directamente en el servicio, lo correcto sería incluirla en un fichero de configuración y en una variable global para no tener que llamarla en cada servicio.

Para probar todos estos métodos que acabamos de crear, modificamos nuestro Program por lo siguiente:

using TutorialDapper.Entities;
using TutorialDapper.Services;

//Listar todos los registros 
var marks = MarkService.GetMarks();

foreach (var mark in marks)
{
    Console.WriteLine($"{mark.Surname} {mark.Name} = {mark.Nota}");
}

//Insertar un registro en la base de datos
var newMark = new Mark()
{
    Name = "Juan",
    Surname = "Pablo",
    Nota = 8.00m,
};

var id = MarkService.CreateMark(newMark);
Console.WriteLine($"Se creo la nota con id = {id}");

//Buscar un registro por id
var findMark = MarkService.GetMark(id);
Console.WriteLine($"El registro con {id} se llama {findMark.Name}");

//Actualizar un registro en la base de datos
findMark.Name = "Pedro";
MarkService.UpdateMark(findMark, id);
Console.WriteLine($"El registro con {id} ahora se llama Pedro {findMark.Name}");

//Eliminamos el registro
MarkService.DeleteMark(id);
Console.WriteLine($"Pedro ahora está en un lugar mejor...");

Con esto ya tendrías hecho un CRUD con Dapper, ahora te toca a ti dedicarle un poco de tiempo y realizar alguna prueba por tu cuenta, por ejemplo podrías intentar introducir los alumnos en otra tabla y realizar un Inner Join de las dos tablas.

Código fuente.