C# Academy · Lezione

Migrazioni e gestione dello schema

Crei, applichi e annulli le migrazioni per evolvere lo schema del database in modo sicuro.

Lezione 2 di 413 passaggi

Migrazioni e gestione dello schema è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Che cosa sono le migrazioni di EF Core

Le migrazioni sono file generati dal codice che descrivono modifiche incrementali allo schema del database. Invece di scrivere manualmente l'SQL DDL, EF Core lo genera e lo applica automaticamente, mantenendo sincronizzati il codice e il database.

Installazione degli strumenti EF Core

Lo strumento CLI di EF Core (dotnet-ef) deve essere installato globalmente (o come strumento locale) per eseguire i comandi delle migrazioni dal terminale.

# Install globally
dotnet tool install --global dotnet-ef

# Verify
dotnet ef --version

# Required NuGet packages in your project:
# Microsoft.EntityFrameworkCore.Design
# Microsoft.EntityFrameworkCore.SqlServer (or Sqlite, etc.)

Creazione della prima migrazione

dotnet ef migrations add confronta il modello corrente con l'ultimo snapshot e genera un file di migrazione con i metodi Up() (applicazione) e Down() (rollback).

# Create initial migration
dotnet ef migrations add InitialCreate

# Output files created:
# Migrations/20240101_InitialCreate.cs       <- Up/Down
# Migrations/20240101_InitialCreate.Designer.cs
# Migrations/AppDbContextModelSnapshot.cs   <- current model

Struttura di un file di migrazione

Ogni migrazione contiene un metodo Up (che applica le modifiche) e un metodo Down (che le annulla). EF Core li genera automaticamente a partire dalle differenze nel modello.

public partial class InitialCreate : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.CreateTable(
            name: "Products",
            columns: table => new
            {
                Id    = table.Column<int>(nullable: false)
                             .Annotation("SqlServer:Identity", "1, 1"),
                Name  = table.Column<string>(maxLength: 200, nullable: false),
                Price = table.Column<decimal>(type: "decimal(18,2)", nullable: false)
            },
            constraints: table => table.PrimaryKey("PK_Products", x => x.Id));
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(name: "Products");
    }
}

Applicazione delle migrazioni

dotnet ef database update applica tutte le migrazioni in sospeso. EF Core tiene traccia delle migrazioni già eseguite nella tabella __EFMigrationsHistory.

# Apply all pending migrations
dotnet ef database update

# Apply up to a specific migration
dotnet ef database update AddProductIndex

# Roll back to a previous migration
dotnet ef database update InitialCreate

Migrazione programmatica all'avvio

In produzione è possibile applicare le migrazioni programmaticamente all'avvio, così il database è sempre aggiornato senza passaggi manuali con la CLI.

var app = builder.Build();

// Apply pending migrations at startup
using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
    await db.Database.MigrateAsync();
}

app.Run();

Aggiunta di una colonna in una nuova migrazione

Aggiunga una proprietà all'entità, quindi crei una nuova migrazione. EF Core rileva la modifica e genera un'operazione AddColumn.

// 1. Add property to entity
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
    public string? Description { get; set; } // NEW
}

// 2. Generate migration
// dotnet ef migrations add AddProductDescription

// Generated Up():
migrationBuilder.AddColumn<string>(
    name: "Description",
    table: "Products",
    nullable: true);

Popolamento dei dati nelle migrazioni

Utilizzi HasData in OnModelCreating per inserire dati di riferimento. EF Core li include nel metodo Up della migrazione come istruzioni INSERT.

modelBuilder.Entity<Category>().HasData(
    new Category { Id = 1, Name = "Electronics" },
    new Category { Id = 2, Name = "Books" },
    new Category { Id = 3, Name = "Clothing" }
);

// Then regenerate the migration:
// dotnet ef migrations add SeedCategories

SQL personalizzato nelle migrazioni

Quando è necessario usare DDL che EF Core non può generare automaticamente (trigger, viste, stored procedure), utilizzi migrationBuilder.Sql().

protected override void Up(MigrationBuilder migrationBuilder)
{
    migrationBuilder.Sql(@"
        CREATE VIEW vw_ActiveProducts AS
        SELECT Id, Name, Price
        FROM Products
        WHERE IsActive = 1
    ");
}

protected override void Down(MigrationBuilder migrationBuilder)
{
    migrationBuilder.Sql("DROP VIEW vw_ActiveProducts");
}

Rimozione di una migrazione

Se non ha ancora applicato una migrazione, può eliminarla con dotnet ef migrations remove. In questo modo è possibile rimuovere solo l'ultima migrazione.

# Remove the last unapplied migration
dotnet ef migrations remove

# List all migrations and their status
dotnet ef migrations list

# Script all migrations to SQL (for DBA review)
dotnet ef migrations script --output deploy.sql

Esempio reale: strategia di migrazione CI/CD

In una pipeline CI/CD, generi uno script di migrazione e lo sottoponga alla revisione di un DBA prima di applicarlo in produzione: non esegua mai MigrateAsync() alla cieca in sistemi di produzione critici.

# Generate idempotent script for all pending migrations
dotnet ef migrations script --idempotent --output migrations.sql

# Review migrations.sql, then apply via sqlcmd / psql:
# sqlcmd -S server -d db -i migrations.sql

Verifica rapida

Quale tabella di EF Core tiene traccia delle migrazioni già applicate a un database?

Rispondi nella lezione interattiva

Riepilogo: migrazioni e gestione dello schema

Punti chiave:

dotnet ef migrations add <Name> genera file incrementali per le modifiche allo schema
Ogni migrazione contiene i metodi Up() (applicazione) e Down() (rollback)
dotnet ef database update applica le migrazioni in sospeso
Utilizzare MigrateAsync() all'avvio dell'applicazione per le distribuzioni automatizzate
Generare script SQL idempotenti da sottoporre alla revisione di un DBA nelle pipeline di produzione

Gratis per iniziare

Impara C# con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 93
Lezioni: 346

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Migrazioni e gestione dello schema» è gratuita?

Sì — il testo completo di «Migrazioni e gestione dello schema» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Migrazioni e gestione dello schema»?

Crei, applichi e annulli le migrazioni per evolvere lo schema del database in modo sicuro. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Migrazioni e gestione dello schema»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C# Academy