Dela via

Koda först till en befintlig databas

Den här stegvisa genomgången ger en introduktion till Code First-utveckling som riktar sig till en befintlig databas. Med Code First kan du definiera din modell med hjälp av C# eller VB.Net klasser. Du kan också utföra ytterligare konfiguration med hjälp av attribut i dina klasser och egenskaper eller med hjälp av ett fluent-API.

Förutsättningar

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

Du behöver också version 6.1 (eller senare) av Entity Framework Tools för Visual Studio installerat. Mer information om hur du installerar den senaste versionen av Entity Framework Tools finns i Hämta Entity Framework .

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.

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

    Välj datakälla

  • Anslut till din LocalDB-instans och ange Blogging som databasnamn

    LocalDB-anslutning

  • Välj OK så tillfrågas du om du vill skapa en ny databas och väljer Ja

    Dialogrutan Skapa databas

  • 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
);

INSERT INTO [dbo].[Blogs] ([Name],[Url])
VALUES ('The Visual Studio Blog', 'http://blogs.msdn.com/visualstudio/')

INSERT INTO [dbo].[Blogs] ([Name],[Url])
VALUES ('.NET Framework Blog', 'http://blogs.msdn.com/dotnet/')

2. Skapa programmet

För att hålla det enkelt skapar vi ett grundläggande konsolprogram som använder Code First för att göra dataåtkomsten:

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

 

3. Omvänd ingenjörsmodell

Vi kommer att använda Entity Framework Tools för Visual Studio för att hjälpa oss att generera viss initial kod för att mappa till databasen. Dessa verktyg genererar bara kod som du också kan skriva för hand om du vill.

  • Projekt –> Lägg till nytt objekt...

  • Välj Data på den vänstra menyn och sedan ADO.NET entitetsdatamodell

  • Ange BloggingContext som namn och klicka på OK

  • Detta startar Entitetsdatamodellguiden

  • Välj Kod först från databasen och klicka på Nästa

    Guiden One CFE

  • Välj anslutningen till databasen som du skapade i det första avsnittet och klicka på Nästa

    Wizard Two CFE

  • Klicka på kryssrutan bredvid Tabeller för att importera alla tabeller och klicka på Slutför

    Wizard Tre CFE

När omvänd ingenjörsprocess har slutförts har ett antal objekt lagts till i projektet, låt oss ta en titt på vad som har lagts till.

Konfigurationsfil

En App.config fil har lagts till i projektet innehåller den här filen anslutningssträngen till den befintliga databasen.

<connectionStrings>
  <add  
    name="BloggingContext"  
    connectionString="data source=(localdb)\mssqllocaldb;initial catalog=Blogging;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework"  
    providerName="System.Data.SqlClient" />
</connectionStrings>

Du kommer också att märka några andra inställningar i konfigurationsfilen. Det här är standardinställningar för EF som talar om för Code First var du ska skapa databaser. Eftersom vi mappar till en befintlig databas ignoreras den här inställningen i vårt program.

Härledd kontext

En BloggingContext-klass har lagts till i projektet. Kontexten representerar en session med databasen, så att vi kan fråga efter och spara data. Kontexten exponerar en DbSet<TEntity> för varje typ i vår modell. Du kommer också att märka att standardkonstruktorn anropar en baskonstruktor med hjälp av syntaxen name= . Detta meddelar Code First att anslutningssträngen som ska användas för den här kontexten ska läsas in från konfigurationsfilen.

public partial class BloggingContext : DbContext
    {
        public BloggingContext()
            : base("name=BloggingContext")
        {
        }

        public virtual DbSet<Blog> Blogs { get; set; }
        public virtual DbSet<Post> Posts { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
        }
    }

Du bör alltid använda syntaxen name= när du använder en anslutningssträng i konfigurationsfilen. Detta säkerställer att om anslutningssträngen inte finns kommer Entity Framework att generera i stället för att skapa en ny databas enligt konvention.

Modellklasser

Slutligen har även en blogg- och postklass lagts till i projektet. Det här är de domänklasser som utgör vår modell. Du ser dataanteckningar som tillämpas på klasserna för att ange konfiguration där Code First-konventionerna inte överensstämmer med strukturen för den befintliga databasen. Du ser till exempel StringLength-kommentaren på Blog.Name och Blog.Url eftersom de har en maximal längd på 200 i databasen (standardvärdet Kod först är att använda den maximala längd som stöds av databasprovidern – nvarchar(max) i SQL Server).

public partial class Blog
{
    public Blog()
    {
        Posts = new HashSet<Post>();
    }

    public int BlogId { get; set; }

    [StringLength(200)]
    public string Name { get; set; }

    [StringLength(200)]
    public string Url { get; set; }

    public virtual ICollection<Post> Posts { get; set; }
}

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. 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:
.NET Framework Blog
ADO.NET Blog
The Visual Studio Blog
Press any key to exit...

 

Vad händer om min databas ändras?

Guiden Koda först till databas är utformad för att generera en startpunktsuppsättning klasser som du sedan kan justera och ändra. Om databasschemat ändras kan du antingen redigera klasserna manuellt eller utföra en annan omvänd tekniker för att skriva över klasserna.

Använda Code First Migrations till en befintlig databas

Om du vill använda Code First Migrations med en befintlig databas kan du läsa Code First Migrations to an existing database (Koda första migreringar till en befintlig databas).

Sammanfattning

I den här genomgången tittade vi på Code First-utveckling med hjälp av en befintlig databas. Vi använde Entity Framework Tools för Visual Studio för att omvänt konstruera en uppsättning klasser som mappats till databasen och som kan användas för att lagra och hämta data.

  • Last updated on