NEXT FRAMEWORK
C#
0

Entity Framework Core (EF Core) con Sql Server

Entity Framework Core es un ORM (Object-Relational Mapper) que nos permite trabajar con bases de datos relacionales utilizando objetos en C#, evitando escribir SQL manual para la gran mayoría de operaciones CRUD.

1. Paquetes NuGet Necesarios

Para trabajar con EF Core y SQL Server, necesitas instalar los siguientes paquetes. Puedes agregarlos desde la Consola del Administrador de Paquetes o ejecutando los siguientes comandos en la terminal desde la carpeta de tu proyecto:

# Proveedor oficial de EF Core para SQL Server
dotnet add package Microsoft.EntityFrameworkCore.SqlServer

# Herramientas para ejecutar migraciones y comandos en la terminal
dotnet add package Microsoft.EntityFrameworkCore.Tools

# (Opcional) Necesario si usas herramientas de comandos globales de .NET CLI
dotnet add package Microsoft.EntityFrameworkCore.Design

Concepto clave: Microsoft.EntityFrameworkCore.SqlServer contiene los traductores de LINQ a T-SQL, mientras que Tools y Design te permiten crear y aplicar las migraciones (Add-Migration, Update-Database).

2. Creación de las Entidades

Las entidades son clases en C# que representan las tablas en la base de datos. Cada propiedad de la clase se mapeará a una columna.

Supongamos que estamos modelando un sistema simple con Blog y Publicación (Post):

namespace TuProyecto.Models
{
    public class Blog
    {
        // Convenión de EF Core: La propiedad 'Id' se detecta automáticamente como Clave Primaria (PK)
        public int Id { get; set; }
        public string Nombre { get; set; } = string.Empty;
        public string Url { get; set; } = string.Empty;

        // Propiedad de navegación: Un Blog tiene muchas publicaciones
        public List<Post> Posts { get; set; } = new();
    }

    public class Post
    {
        public int Id { get; set; }
        public string Titulo { get; set; } = string.Empty;
        public string Contenido { get; set; } = string.Empty;
        public DateTime FechaPublicacion { get; set; } = DateTime.UtcNow;

        // Clave Foránea (FK)
        public int BlogId { get; set; }
        
        // Propiedad de navegación principal
        public Blog Blog { get; set; } = null!;
    }
}

3. Configuración del DbContext

El DbContext es la pieza central de EF Core. Modela la sesión con la base de datos y permite consultar o guardar instancias de tus entidades.

Crear la clase DbContext

Crea una clase que herede de DbContext y define los DbSet<T> para cada tabla:

using Microsoft.EntityFrameworkCore;
using TuProyecto.Models;

namespace TuProyecto.Data
{
    public class ApplicationDbContext : DbContext
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
            : base(options)
        {
        }

        // Representan las tablas en SQL Server
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            // Fluent API: Personalización detallada de esquemas y restricciones

            modelBuilder.Entity<Blog>(entity =>
            {
                entity.HasKey(b => b.Id);
                entity.Property(b => b.Nombre).IsRequired().HasMaxLength(100);
                entity.Property(b => b.Url).HasMaxLength(200);
            });

            modelBuilder.Entity<Post>(entity =>
            {
                entity.HasKey(p => p.Id);
                entity.Property(p => p.Titulo).IsRequired().HasMaxLength(150);
                
                // Configuración de la relación 1 a Muchos
                entity.HasOne(p => p.Blog)
                      .WithMany(b => b.Posts)
                      .HasForeignKey(p => p.BlogId)
                      .OnDelete(DeleteBehavior.Cascade);
            });
        }
    }
}

4. Registro de Inyección de Dependencias y Cadena de Conexión

Para habilitar el contexto en una aplicación Web API o MVC moderna (.NET 6/7/8+), realizamos lo siguiente:

A. Definir la cadena de conexión en appsettings.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MiBaseDeDatosDb;Trusted_Connection=True;TrustServerCertificate=True;"
  }
}

B. Registrar el DbContext en Program.cs

using Microsoft.EntityFrameworkCore;
using TuProyecto.Data;

var builder = WebApplication.CreateBuilder(args);

// Extraer la cadena de conexión
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");

// Registrar elDbContext en el contenedor de servicios
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));

var app = builder.Build();

5. Aplicar la Primera Migración

Una vez configurado todo, generas la base de datos con las herramientas CLI de .NET ejecutando en tu terminal:

# 1. Crear el archivo de migración
dotnet ef migrations add Inicial

# 2. Aplicar los cambios a la instancia de SQL Server
dotnet ef database update
Post a Comment