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/