Enum-stöd – kod-först

Anmärkning

ENDAST EF5 – De funktioner, API:er osv. som beskrivs på den här sidan introducerades i Entity Framework 5. Om du använder en tidigare version gäller inte en del av eller all information.

Den här videon och den steg-för-steg-genomgången visar hur du använder enum-typer med Entity Framework Code First. Det visar också hur du använder uppräkningar i en LINQ-fråga.

Den här genomgången använder Code First för att skapa en ny databas, men du kan också använda Code First för att mappa till en befintlig databas.

`Enum-stöd introducerades i Entity Framework 5.` Om du vill använda de nya funktionerna som uppräkningar, rumsliga datatyper och tabellvärdesfunktioner måste du rikta in dig på .NET Framework 4.5. Visual Studio 2012 riktar in sig på .NET 4.5 som standard.

I Entity Framework kan en uppräkning ha följande underliggande typer: Byte, Int16, Int32, Int64 eller SByte.

Titta på videon

Den här videon visar hur du använder enum-typer med Entity Framework Code First. Det visar också hur du använder uppräkningar i en LINQ-fråga.

Presenterad av: Julia Kornich

Video: WMV | MP4 | WMV (ZIP)

Förutsättningar

Du måste ha Visual Studio 2012, Ultimate, Premium, Professional eller Web Express edition installerat för att slutföra den här genomgången.

 

Konfigurera projektet

1. Öppna Visual Studio 2012
2. Peka på Nytt på Arkiv-menyn och klicka sedan på Projekt
3. Klicka på Visual C# i den vänstra rutan och välj sedan konsolmallen
4. Ange EnumCodeFirst som namnet på projektet och klicka på OK

Definiera en ny modell med kod först

När du använder Code First-utveckling börjar du vanligtvis med att skriva .NET Framework-klasser som definierar din konceptuella modell (domän). Koden nedan definierar klassen Avdelning.

Koden definierar även uppräkning av DepartmentNames. Som standard är uppräkningen av int-typ . Egenskapen Name på klassen Department är av typen DepartmentNames.

Öppna filen Program.cs och klistra in följande klassdefinitioner.

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; }
}

 

Definiera DbContext-deriverad typ

Förutom att definiera entiteter måste du definiera en klass som härleds från DbContext och exponerar DbSet<TEntity-egenskaper> . Egenskaperna DbSet<TEntity> meddelar kontexten vilka typer du vill ta med i modellen.

En instans av den härledda typen DbContext hanterar entitetsobjekten under körningen, vilket omfattar att fylla i objekt med data från en databas, ändra spårning och spara data i databasen.

Typerna DbContext och DbSet definieras i EntityFramework-sammansättningen. Vi lägger till en referens till denna DLL med hjälp av EntityFramework NuGet-paketet.

1. Högerklicka på projektnamnet i Solution Explorer.
2. Välj Hantera NuGet-paket...
3. I dialogrutan Hantera NuGet-paket väljer du fliken Online och väljer EntityFramework-paketet .
4. Klicka på Installera

Observera att förutom EntityFramework-sammansättningen läggs även referenser till System.ComponentModel.DataAnnotations och System.Data.Entity-sammansättningar.

Överst i filen Program.cs lägger du till följande using-sats:

using System.Data.Entity;

Lägg till kontextdefinitionen i Program.cs. 

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

 

Spara och hämta data

Öppna filen Program.cs där Main-metoden har definierats. Lägg till följande kod i funktionen Main. Koden lägger till ett nytt avdelningsobjekt i kontexten. Sedan sparas data. Koden kör också en LINQ-fråga som returnerar en avdelning där namnet är 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);
}

Kompilera och kör programmet. Programmet genererar följande utdata:

DepartmentID: 1 Name: English

 

Visa den genererade databasen

När du kör programmet första gången skapar Entity Framework en databas åt dig. Eftersom Visual Studio 2012 är installerat skapas databasen på LocalDB-instansen. Som standard namnger Entity Framework databasen efter det fullständigt kvalificerade namnet på den härledda kontexten (för det här exemplet är EnumCodeFirst.EnumTestContext). Följande gånger används den befintliga databasen.  

Observera att om du gör några ändringar i din modell när databasen har skapats bör du använda Code First Migrations för att uppdatera databasschemat. Se Koda först till en ny databas för ett exempel på hur du använder migreringar.

Om du vill visa databasen och data gör du följande:

1. I huvudmenyn i Visual Studio 2012 väljer du Visa ->SQL Server Object Explorer.
2. Om LocalDB inte finns med i listan över servrar klickar du på höger musknapp på SQL Server och väljer Lägg till SQL Server Använd standard-Windows-autentisering för att ansluta till LocalDB-instansen
3. Expandera LocalDB-noden
4. Expandera mappen Databaser för att se den nya databasen och navigera till tabellen Avdelning. Observera att Code First inte skapar en tabell som mappar till uppräkningstypen.
5. Om du vill visa data högerklickar du på tabellen och väljer Visa data

Sammanfattning

I den här genomgången tittade vi på hur du använder uppräkningstyper med Entity Framework Code First.