Entity Framework Core: creazione dei modelli partendo da un database esistente

In questo tutorial verrà illustrato come creare il contesto e le classi di entità per un database esistente in Entity Framework Core. La creazione di classi di entità e contesto per un database esistente è denominata approccio Database-First.

Entity Framework Core è un framework di accesso ai dati che semplifica l'interazione con i database nelle applicazioni .NET. Una delle sue funzionalità principali è la capacità di generare automaticamente modelli di dati a partire da un database esistente, risparmiando tempo e sforzo nella scrittura di codice.

Ambiente di sviluppo utilizzato:

 - Visual Studio 2022
 - .Net 7.0
 - C# 10
 - Tipologia Progetto: App Web ASP.Net Core

Per creare un modello per un database esistente, dovrai seguire alcuni passaggi fondamentali. Prima di tutto, assicurati di avere Entity Framework Core installato nel tuo progetto. Puoi farlo tramite il package manager di Visual Studio (Strumenti -> Gestione pacchetti NuGet) o utilizzando il comando NuGet nella console di gestione dei pacchetti.

Per il nostro tutorial utilizzeremo un database SQLite esistente con la seguente struttura:

Installiamo anche le dipendenze per EF Core SQLite Microsoft.EntityFrameworkCore.Sqlite. Quindi l'elenco completo delle dipendenze installate è:

Dopo aver configurato correttamente l’ambiente, puoi utilizzare il comando scaffolding di Entity Framework Core per generare automaticamente il modello basato sullo schema del database. Questo comando analizzerà il database e creerà le classi corrispondenti alle tabelle e alle relazioni presenti.

PM> Scaffold-DbContext [-Connection] [-Provider] [-OutputDir] [-Context] [-Schemas>] [-Tables>]
[-DataAnnotations] [-Force] [-Project] [-StartupProject] []

In Visual Studio selezionare il menu Strumenti -> Gestione pacchetti NuGet -> Console Gestione pacchetti ed eseguire il comando seguente:

PM> Scaffold-DbContext "DataSource=\tutorialdb.db" Microsoft.EntityFrameworkCore.Sqlite -OutputDir Models

Il comando crea classi di entità per ogni tabella nel database e classe di contesto con configurazioni API Fluent per tutte le entità nella cartella Models.

Di seguito è riportata una delle classi di entità generate per la tabella Studenti:

public partial class Studenti
{
    public long Id { get; set; }

    public string? Nome { get; set; }

    public string? Cognome { get; set; }

    public virtual ICollection Corsos { get; set; } = new List();
}

Di seguito è riportata la classe TutorialDbContext che è possibile utilizzare per salvare o recuperare dati:

public partial class TutorialdbContext : DbContext
{
    public TutorialdbContext()
    {
    }

    public TutorialdbContext(DbContextOptions options)
        : base(options)
    {
    }

    public virtual DbSet Corsis { get; set; }

    public virtual DbSet Professoris { get; set; }

    public virtual DbSet Studentis { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder.UseSqlite("DataSource=\\tutorialdb.db");

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity(entity =>
        {
            entity.ToTable("Corsi");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Descrizione).HasColumnName("descrizione");
            entity.Property(e => e.Nome).HasColumnName("nome");

            entity.HasMany(d => d.Professores).WithMany(p => p.Corsos)
                .UsingEntity<Dictionary<string, object>>(
                    "CorsiProfessori",
                    r => r.HasOne().WithMany()
                        .HasForeignKey("ProfessoreId")
                        .OnDelete(DeleteBehavior.ClientSetNull),
                    l => l.HasOne().WithMany()
                        .HasForeignKey("CorsoId")
                        .OnDelete(DeleteBehavior.ClientSetNull),
                    j =>
                    {
                        j.HasKey("CorsoId", "ProfessoreId");
                        j.ToTable("CorsiProfessori");
                        j.IndexerProperty("CorsoId").HasColumnName("corso_id");
                        j.IndexerProperty("ProfessoreId").HasColumnName("professore_id");
                    });

            entity.HasMany(d => d.Studentes).WithMany(p => p.Corsos)
                .UsingEntity<Dictionary<string, object>>(
                    "CorsiStudenti",
                    r => r.HasOne().WithMany()
                        .HasForeignKey("StudenteId")
                        .OnDelete(DeleteBehavior.ClientSetNull),
                    l => l.HasOne().WithMany()
                        .HasForeignKey("CorsoId")
                        .OnDelete(DeleteBehavior.ClientSetNull),
                    j =>
                    {
                        j.HasKey("CorsoId", "StudenteId");
                        j.ToTable("CorsiStudenti");
                        j.IndexerProperty("CorsoId").HasColumnName("corso_id");
                        j.IndexerProperty("StudenteId").HasColumnName("studente_id");
                    });
        });

        modelBuilder.Entity(entity =>
        {
            entity.ToTable("Professori");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Cognome).HasColumnName("cognome");
            entity.Property(e => e.Nome).HasColumnName("nome");
        });

        modelBuilder.Entity(entity =>
        {
            entity.ToTable("Studenti");

            entity.Property(e => e.Id).HasColumnName("id");
            entity.Property(e => e.Cognome).HasColumnName("cognome");
            entity.Property(e => e.Nome).HasColumnName("nome");
        });

        OnModelCreatingPartial(modelBuilder);
    }

    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}

EF Core crea classi di entità solo per le tabelle e non per StoredProcedures o Views.

Per ottenere la guida dettagliata sul comando Scaffold-DbContext puoi utilizzare il seguente comando:

PM> get-help scaffold-dbcontext –detailed

Nota: Dopo aver creato il modello, è necessario utilizzare i comandi di Migrazione ogni volta che si modifica il modello per mantenere il database aggiornato.

Conclusione

Entity Framework Core è uno strumento potente per la gestione dei dati nelle applicazioni .NET, che offre la possibilità di creare facilmente modelli per database esistenti. Con Entity Framework Core, puoi evitare la scrittura manuale di codice ripetitivo e ottenere un accesso semplificato e intuitivo ai dati.

Spero che questa guida ti abbia fornito una panoramica chiara e utile per creare il tuo modello per un database esistente utilizzando Entity Framework Core.

Il codice sorgente completo del progetto lo trovi su GitHub.

* Obbligatorio

Invia