Databasen först

Den här videon och den stegvisa genomgången ger en introduktion till Database First-utveckling med Entity Framework. Med Database First kan du omvänt konstruera en modell från en befintlig databas. Modellen lagras i en EDMX-fil (.edmx-tillägget) och kan visas och redigeras i Entity Framework Designer. De klasser som du interagerar med i ditt program genereras automatiskt från EDMX-filen.

Titta på videon

Den här videon ger en introduktion till Database First-utveckling med Entity Framework. Med Database First kan du omvänt konstruera en modell från en befintlig databas. Modellen lagras i en EDMX-fil (.edmx-tillägget) och kan visas och redigeras i Entity Framework Designer. De klasser som du interagerar med i ditt program genereras automatiskt från EDMX-filen.

Presenterad av: Rowan Miller

Video: WMV | MP4 | WMV (ZIP)

Förutsättningar

Du måste ha minst Visual Studio 2010 eller Visual Studio 2012 installerat för att slutföra den här genomgången.

Om du använder Visual Studio 2010 måste du också ha NuGet installerat.

1. Skapa en befintlig databas

Vanligtvis när du riktar in dig på en befintlig databas skapas den redan, men för den här genomgången måste vi skapa en databas för åtkomst.

Databasservern som är installerad med Visual Studio skiljer sig beroende på vilken version av Visual Studio du har installerat:

Om du använder Visual Studio 2010 skapar du en SQL Express-databas.
Om du använder Visual Studio 2012 skapar du en LocalDB-databas .

Nu ska vi gå vidare och generera databasen.

Öppna Visual Studio
Visa –> ServerUtforskaren
Högerklicka på Dataanslutningar –> Lägg till anslutning...
Om du inte har anslutit till en databas från Server Explorer innan du måste välja Microsoft SQL Server som datakälla
Anslut till antingen LocalDB eller SQL Express, beroende på vilken du har installerat, och ange DatabaseFirst.Blogging som databasnamn
Välj OK så tillfrågas du om du vill skapa en ny databas och väljer Ja
Den nya databasen visas nu i Server Explorer, högerklickar på den och väljer Ny fråga
Kopiera följande SQL till den nya frågan och högerklicka sedan på frågan och välj Kör

CREATE TABLE [dbo].[Blogs] (
    [BlogId] INT IDENTITY (1, 1) NOT NULL,
    [Name] NVARCHAR (200) NULL,
    [Url]  NVARCHAR (200) NULL,
    CONSTRAINT [PK_dbo.Blogs] PRIMARY KEY CLUSTERED ([BlogId] ASC)
);

CREATE TABLE [dbo].[Posts] (
    [PostId] INT IDENTITY (1, 1) NOT NULL,
    [Title] NVARCHAR (200) NULL,
    [Content] NTEXT NULL,
    [BlogId] INT NOT NULL,
    CONSTRAINT [PK_dbo.Posts] PRIMARY KEY CLUSTERED ([PostId] ASC),
    CONSTRAINT [FK_dbo.Posts_dbo.Blogs_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [dbo].[Blogs] ([BlogId]) ON DELETE CASCADE
);

2. Skapa programmet

För att hålla det enkelt ska vi skapa ett grundläggande konsolprogram som använder Database First för att utföra dataåtkomst:

Öppna Visual Studio
Fil –> Ny –> Projekt...
Välj Windows på den vänstra menyn och Konsolprogram
Ange DatabaseFirstSample som namn
Välj OK

3. Omvänd ingenjörsmodell

Vi ska använda Entity Framework Designer, som ingår som en del av Visual Studio, för att skapa vår modell.

Projekt –> Lägg till nytt objekt...
Välj Data på den vänstra menyn och sedan ADO.NET entitetsdatamodell
Ange BloggingModel som namn och klicka på OK
Detta startar Entitetsdatamodellguiden
Välj Generera från databas och klicka på Nästa
Välj anslutningen till den databas som du skapade i det första avsnittet, ange BloggingContext som namnet på anslutningssträngen och klicka på Nästa
Klicka på kryssrutan bredvid Tabeller för att importera alla tabeller och klicka på Slutför

När processen för omvänd ingenjörsarbete har slutförts läggs den nya modellen till i projektet och öppnas så att du kan se den i Entity Framework Designer. En App.config fil har också lagts till i projektet med anslutningsinformationen för databasen.

Modell initial

Ytterligare steg i Visual Studio 2010

Om du arbetar i Visual Studio 2010 finns det några ytterligare steg som du behöver följa för att uppgradera till den senaste versionen av Entity Framework. Uppgradering är viktigt eftersom det ger dig åtkomst till en förbättrad API-yta, som är mycket enklare att använda samt de senaste felkorrigeringarna.

Först måste vi hämta den senaste versionen av Entity Framework från NuGet.

Projekt–> Hantera NuGet-paket...Om du inte har alternativet Hantera NuGet-paket... bör du installera den senaste versionen av NuGet
Välj fliken Online
Välj EntityFramework-paketet
Klicka på Installera

Därefter måste vi byta modell för att generera kod som använder DbContext-API:et, som introducerades i senare versioner av Entity Framework.

Högerklicka på en tom plats för din modell i EF Designer och välj Lägg till kodgenereringsobjekt...
Välj Onlinemallar på den vänstra menyn och sök efter DbContext
Välj EF 5.x DbContext Generator för C#, ange BloggingModel som namn och klicka på Lägg till

4. Läsa och skriva data

Nu när vi har en modell är det dags att använda den för att komma åt vissa data. De klasser som vi ska använda för att komma åt data genereras automatiskt åt dig baserat på EDMX-filen.

Den här skärmbilden är från Visual Studio 2012, om du använder Visual Studio 2010 hamnar BloggingModel.tt och BloggingModel.Context.tt filer direkt under projektet i stället för kapslade under EDMX-filen.

Genererade klasser DF

Implementera main-metoden i Program.cs enligt nedan. Den här koden skapar en ny instans av kontexten och använder den sedan för att infoga en ny blogg. Sedan använder den en LINQ-fråga för att hämta alla bloggar från databasen som ordnas alfabetiskt efter Rubrik.

class Program
{
    static void Main(string[] args)
    {
        using (var db = new BloggingContext())
        {
            // Create and save a new Blog
            Console.Write("Enter a name for a new Blog: ");
            var name = Console.ReadLine();

            var blog = new Blog { Name = name };
            db.Blogs.Add(blog);
            db.SaveChanges();

            // Display all Blogs from the database
            var query = from b in db.Blogs
                        orderby b.Name
                        select b;

            Console.WriteLine("All blogs in the database:");
            foreach (var item in query)
            {
                Console.WriteLine(item.Name);
            }

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}

Nu kan du köra programmet och testa det.

Enter a name for a new Blog: ADO.NET Blog
All blogs in the database:
ADO.NET Blog
Press any key to exit...

5. Hantera databasändringar

Nu är det dags att göra vissa ändringar i vårt databasschema, när vi gör dessa ändringar måste vi också uppdatera vår modell för att återspegla dessa ändringar.

Det första steget är att göra vissa ändringar i databasschemat. Vi ska lägga till tabellen Användare i schemat.

Högerklicka på databasen DatabaseFirst.Blogging i Server Explorer och välj Ny fråga
Kopiera följande SQL till den nya frågan och högerklicka sedan på frågan och välj Kör

CREATE TABLE [dbo].[Users]
(
    [Username] NVARCHAR(50) NOT NULL PRIMARY KEY,  
    [DisplayName] NVARCHAR(MAX) NULL
)

Nu när schemat har uppdaterats är det dags att uppdatera modellen med dessa ändringar.

Högerklicka på en tom plats för din modell i EF Designer och välj "Uppdatera modell från databas...", detta startar uppdateringsguiden
På fliken Lägg till i uppdateringsguiden markerar du kryssrutan bredvid Tabeller, vilket anger att vi vill lägga till nya tabeller från schemat. Fliken Uppdatera visar alla befintliga tabeller i modellen som ska kontrolleras för ändringar under uppdateringen. Flikarna Ta bort visar alla tabeller som har tagits bort från schemat och som också tas bort från modellen som en del av uppdateringen. Informationen på dessa två flikar identifieras automatiskt och tillhandahålls endast i informationssyfte, du kan inte ändra några inställningar.
Klicka på Slutför i uppdateringsguiden

Modellen har nu uppdaterats så att den innehåller en ny användarentitet som mappar till tabellen Användare som vi har lagt till i databasen.

Modellen har uppdaterats

Sammanfattning

I den här genomgången tittade vi på Database First-utvecklingen, som gjorde det möjligt för oss att skapa en modell i EF Designer baserat på en befintlig databas. Sedan använde vi modellen för att läsa och skriva data från databasen. Slutligen uppdaterade vi modellen så att den återspeglar ändringar som vi har gjort i databasschemat.

Feedback

Var den här sidan till hjälp?

Last updated on 2026-03-27