C# Academy · Lezione

Nozioni di base su DbContext e DbSet

Configuri un DbContext, definisca le entità, imposti la stringa di connessione ed esegua la prima query.

Nozioni di base su DbContext e DbSet è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 1 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 cos'è Entity Framework Core

EF Core è l'Object-Relational Mapper (ORM) ufficiale di .NET. Associa le classi C#, cioè le entità, alle tabelle del database e consente di interrogare e salvare i dati utilizzando LINQ, senza dover scrivere SQL per la maggior parte delle operazioni.

Definizione di un'entità

Un'entità è una semplice classe C# le cui proprietà vengono associate alle colonne del database. Per convenzione, una proprietà denominata Id o <TypeName>Id diventa la chiave primaria.

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal Price { get; set; }
    public int Stock { get; set; }
    public DateTime CreatedAt { get; set; }
}

Creazione di un DbContext

DbContext è il punto di accesso al database. Contiene proprietà DbSet<T> per ogni entità e gestisce la connessione, il rilevamento delle modifiche e le transazioni.

using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options)
        : base(options) { }

    public DbSet<Product> Products => Set<Product>();
    public DbSet<Order>   Orders   => Set<Order>();
}

Registrazione di DbContext con DI

Chiami AddDbContext in Program.cs per registrare il contesto come servizio Scoped e configurare il provider del database.

builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("Default")));

// For SQLite (great for development/testing):
// options.UseSqlite("Data Source=app.db");

Query di base con DbSet

DbSet<T> espone gli operatori LINQ. Le query non vengono eseguite finché non vengono enumerate (await ...ToListAsync()). Questo viene chiamato esecuzione differita.

public class ProductService
{
    private readonly AppDbContext _db;
    public ProductService(AppDbContext db) => _db = db;

    public async Task<List<Product>> GetExpensiveAsync(decimal minPrice)
    {
        return await _db.Products
            .Where(p => p.Price >= minPrice)
            .OrderBy(p => p.Name)
            .ToListAsync();
    }
}

Ricerca tramite chiave primaria

FindAsync controlla prima la cache locale del change tracker, prima di accedere al database. Lo utilizzi per le query tramite chiave primaria, così da evitare round-trip ridondanti.

var product = await _db.Products.FindAsync(42);
if (product is null)
    throw new KeyNotFoundException("Product not found");

// For complex keys, pass all key values:
var orderLine = await _db.OrderLines.FindAsync(orderId, productId);

Aggiunta di nuovi record

Chiami Add per mettere in coda un'entità per l'inserimento, quindi chiami SaveChangesAsync per confermare le modifiche. EF Core genera l'SQL INSERT e valorizza automaticamente Id.

var product = new Product
{
    Name = "Mechanical Keyboard",
    Price = 149.99m,
    Stock = 50,
    CreatedAt = DateTime.UtcNow
};

_db.Products.Add(product);
await _db.SaveChangesAsync();

Console.WriteLine(product.Id); // Auto-generated PK

Aggiornamento dei record

Le entità caricate da EF Core vengono tracciate. Modifichi direttamente le proprietà e chiami SaveChangesAsync: EF Core rileva le modifiche e genera un'istruzione UPDATE ottimizzata.

var product = await _db.Products.FindAsync(42);
if (product is not null)
{
    product.Price = 129.99m;
    product.Stock -= 1;
    await _db.SaveChangesAsync(); // UPDATE Products SET Price=...
}

Eliminazione dei record

Chiami Remove per contrassegnare un'entità per l'eliminazione, quindi chiami SaveChangesAsync. Utilizzi ExecuteDeleteAsync (.NET 7+) per le eliminazioni di massa senza caricare le entità.

// Delete a tracked entity
_db.Products.Remove(product);
await _db.SaveChangesAsync();

// Bulk delete without loading (EF Core 7+)
await _db.Products
    .Where(p => p.Stock == 0)
    .ExecuteDeleteAsync();

Configurazione con Fluent API

Esegua l'override di OnModelCreating per configurare le entità usando la Fluent API: nomi delle tabelle, tipi di colonna, vincoli, indici e relazioni.

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>(entity =>
    {
        entity.ToTable("products");
        entity.Property(p => p.Name).IsRequired().HasMaxLength(200);
        entity.Property(p => p.Price).HasColumnType("decimal(18,2)");
        entity.HasIndex(p => p.Name);
    });
}

Esempio reale: repository che utilizza DbContext

Un repository tipico incapsula DbContext per centralizzare la logica di accesso ai dati e mantenere i dettagli delle query fuori dalle classi di servizio.

public class ProductRepository : IProductRepository
{
    private readonly AppDbContext _db;
    public ProductRepository(AppDbContext db) => _db = db;

    public async Task<Product?> GetByIdAsync(int id)
        => await _db.Products.AsNoTracking().FirstOrDefaultAsync(p => p.Id == id);

    public async Task<List<Product>> SearchAsync(string query)
        => await _db.Products
            .Where(p => p.Name.Contains(query))
            .AsNoTracking()
            .ToListAsync();
}

Verifica rapida

Che cosa fa AsNoTracking() quando si eseguono query con EF Core?

Riepilogo: nozioni di base su DbContext e DbSet

Punti chiave:

DbContext è la sessione con il database; DbSet<T> rappresenta una tabella
Registrare con AddDbContext in DI; per impostazione predefinita è Scoped
Le query LINQ sono differite: eseguirle con ToListAsync, FirstOrDefaultAsync
Il rilevamento delle modifiche abilita automaticamente UPDATE/DELETE tramite SaveChangesAsync
Utilizzare AsNoTracking() per le query di sola lettura, così da migliorare le prestazioni

Domande Frequenti

La lezione «Nozioni di base su DbContext e DbSet» è gratuita?

Sì — il testo completo di «Nozioni di base su DbContext e DbSet» è 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 «Nozioni di base su DbContext e DbSet»?

Configuri un DbContext, definisca le entità, imposti la stringa di connessione ed esegua la prima query. 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 1 di 4.

Quanto tempo richiede la lezione «Nozioni di base su DbContext e DbSet»?

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