Supporto per enumerazioni - Code First

Questo video e la procedura dettagliata illustrano come usare i tipi di enumerazione con Entity Framework Code First. Viene inoltre illustrato come usare le enumerazioni in una query LINQ.

Questa procedura dettagliata userà Code First per creare un nuovo database, ma è anche possibile usare Code First per eseguire il mapping a un database esistente.

Il supporto delle enumerazioni è stato introdotto in Entity Framework 5. Per usare le nuove funzionalità come enumerazioni, tipi di dati spaziali e funzioni con valori di tabella, è necessario usare .NET Framework 4.5. Visual Studio 2012 è destinato a .NET 4.5 per impostazione predefinita.

In Entity Framework un'enumerazione può avere i tipi sottostanti seguenti: Byte, Int16, Int32, Int64 o SByte.

Guarda il video

Questo video illustra come usare i tipi di enumerazione con Entity Framework Code First. Viene inoltre illustrato come usare le enumerazioni in una query LINQ.

Presentato da: Julia Kornich

Video: WMV | MP4 | WMV (ZIP)

Prerequisiti

Per completare questa procedura dettagliata, è necessario avere installato Visual Studio 2012, Ultimate, Premium, Professional o Web Express Edition.

Configurare il progetto

1. Aprire Visual Studio 2012
2. Scegliere Nuovo dal menu File e quindi fare clic su Progetto
3. Nel riquadro sinistro fare clic su Visual C#, quindi selezionare il modello console
4. Immettere EnumCodeFirst come nome del progetto e fare clic su OK

Definire un nuovo modello usando Code First

Quando si usa lo sviluppo Code First, in genere si inizia scrivendo classi .NET Framework che definiscono il modello concettuale (dominio). Il codice seguente definisce la classe Department.

Il codice definisce anche l'enumerazione DepartmentNames. Per impostazione predefinita, l'enumerazione è di tipo int . La proprietà Name nella classe Department è del tipo DepartmentNames.

Aprire il file Program.cs e incollare le definizioni di classe seguenti.

public enum DepartmentNames
{
    English,
    Math,
    Economics
}     

public partial class Department
{
    public int DepartmentID { get; set; }
    public DepartmentNames Name { get; set; }
    public decimal Budget { get; set; }
}

Definire il tipo derivato DbContext

Oltre a definire le entità, è necessario definire una classe che deriva da DbContext ed espone le proprietà DbSet<TEntity> . Le proprietà DbSet<TEntity> consentono al contesto di conoscere i tipi da includere nel modello.

Un'istanza del tipo derivato DbContext gestisce gli oggetti entità durante l'esecuzione, che include il popolamento di oggetti con dati di un database, il rilevamento delle modifiche e la persistenza dei dati nel database.

I tipi DbContext e DbSet sono definiti nell'assembly EntityFramework. Verrà aggiunto un riferimento a questa DLL usando il pacchetto NuGet EntityFramework.

1. In Esplora soluzioni fare clic con il pulsante destro del mouse sul nome del progetto.
2. Selezionare Gestisci pacchetti NuGet...
3. Nella finestra di dialogo Gestisci pacchetti NuGet selezionare la scheda Online e scegliere il pacchetto EntityFramework .
4. Fai clic su Install (Installa).

Si noti che, oltre all'assembly EntityFramework, vengono aggiunti anche i riferimenti agli assembly System.ComponentModel.DataAnnotations e System.Data.Entity.

Nella parte superiore del file Program.cs aggiungere l'istruzione using seguente:

using System.Data.Entity;

In Program.cs aggiungere la definizione del contesto. 

public partial class EnumTestContext : DbContext
{
    public DbSet<Department> Departments { get; set; }
}

Rendere persistenti e recuperare i dati

Aprire il file Program.cs in cui è definito il metodo Main. Aggiungere il codice seguente alla funzione Main. Il codice aggiunge un nuovo oggetto Department al contesto. Salva quindi i dati. Il codice esegue anche una query LINQ che restituisce un reparto in cui il nome è DepartmentNames.English.

using (var context = new EnumTestContext())
{
    context.Departments.Add(new Department { Name = DepartmentNames.English });

    context.SaveChanges();

    var department = (from d in context.Departments
                        where d.Name == DepartmentNames.English
                        select d).FirstOrDefault();

    Console.WriteLine(
        "DepartmentID: {0} Name: {1}",
        department.DepartmentID,  
        department.Name);
}

Compilare l'applicazione ed eseguirla. Il programma produce l'output seguente:

DepartmentID: 1 Name: English

Visualizzare il database generato

Quando si esegue l'applicazione per la prima volta, Entity Framework crea automaticamente un database. Poiché Visual Studio 2012 è installato, il database verrà creato nell'istanza di Local DB. Per impostazione predefinita, Entity Framework denomina il database dopo il nome completo del contesto derivato( per questo esempio EnumCodeFirst.EnumTestContext). Le volte successive in cui verrà utilizzato il database esistente.  

Si noti che se si apportano modifiche al modello dopo la creazione del database, è consigliabile usare Migrazioni Code First per aggiornare lo schema del database. Per un esempio di uso delle migrazioni, vedere Code First in un nuovo database .

Per visualizzare il database e i dati, eseguire le operazioni seguenti:

1. Nel menu principale di Visual Studio 2012 selezionare Visualizza ->SQL Server Esplora oggetti.
2. Se Local DB non è presente nell'elenco dei server, fare clic sul pulsante destro del mouse in SQL Server e selezionare Aggiungi SQL Server Usare l'autenticazione di Windows predefinita per connettersi all'istanza di Local DB
3. Espandere il nodo Local DB
4. Espandere la cartella Database per visualizzare il nuovo database e passare alla tabella Reparto Nota, che Code First non crea una tabella che esegue il mapping al tipo di enumerazione
5. Per visualizzare i dati, fare clic con il pulsante destro del mouse sulla tabella e selezionare Visualizza dati

Riepilogo

In questa procedura dettagliata è stato illustrato come usare i tipi di enumerazione con Entity Framework Code First.