Kód elsőként egy új adatbázishoz

Ez a videó és részletes útmutató bemutatja a Code First új adatbázist célzó fejlesztését. Ez a forgatókönyv magában foglalja egy nem létező adatbázis megcélzását, és a Code First létrehoz egy üres adatbázist, amelyhez a Code First új táblákat ad hozzá. A Code First segítségével C# vagy VB.Net osztályokkal definiálhatja a modellt. További konfigurációkat igény szerint az osztályok és tulajdonságok attribútumai vagy egy fluent API használatával is végrehajthat.

A videó megtekintése

Ez a videó bemutatja a Code First új adatbázist célzó fejlesztését. Ez a forgatókönyv magában foglalja egy nem létező adatbázis megcélzását, és a Code First létrehoz egy üres adatbázist, amelyhez a Code First új táblákat ad hozzá. A Code First segítségével C# vagy VB.Net osztályokkal definiálhatja a modellt. További konfigurációkat igény szerint az osztályok és tulajdonságok attribútumai vagy egy fluent API használatával is végrehajthat.

Készítette: Rowan Miller

Videó: WMV | MP4 | WMV (ZIP)

Előfeltételek

Az útmutató elvégzéséhez legalább a Visual Studio 2010-et vagy a Visual Studio 2012-t kell telepítenie.

Ha Visual Studio 2010-et használ, a NuGetet is telepítenie kell.

1. Az alkalmazás létrehozása

Az egyszerűség érdekében létrehozunk egy alapszintű konzolalkalmazást, amely a Code First használatával végzi el az adathozzáférést.

• A Visual Studio megnyitása
• Fájl –> Új –> Projekt...
• Válassza a Windows lehetőséget a bal oldali menüből és a konzolalkalmazásból
• Adja meg a CodeFirstNewDatabaseSample nevet
• Válassza az OK gombot

2. A modell létrehozása

Definiáljunk egy nagyon egyszerű modellt osztályok használatával. Csak definiáljuk őket a Program.cs fájlban, de egy valós alkalmazásban külön fájlokra osztaná fel az osztályokat, és akár külön projektre is.

A programosztály definíciója alatt Program.cs adja hozzá a következő két osztályt.

public class Blog
{
    public int BlogId { get; set; }
    public string Name { get; set; }

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

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }

    public int BlogId { get; set; }
    public virtual Blog Blog { get; set; }
}

Megfigyelheti, hogy a két navigációs tulajdonságot (Blog.Posts és Post.Blog) virtuálissá tesszük. Ez lehetővé teszi az Entity Framework Lazy Loading funkcióját. A lusta betöltés azt jelenti, hogy amikor megpróbálja elérni ezeket a tulajdonságokat, azok tartalma automatikusan betöltődik az adatbázisból.

3. Környezet létrehozása

Most itt az ideje, hogy definiáljunk egy származtatott környezetet, amely egy munkamenetet jelöl az adatbázissal, lehetővé téve az adatok lekérdezését és mentését. Meghatározunk egy olyan környezetet, amely a System.Data.Entity.DbContextből származik, és egy beírt DbSet<TEntity-t> tesz elérhetővé a modell minden osztályához.

Most kezdünk típusokat használni az Entity Frameworkből, ezért hozzá kell adnunk az EntityFramework NuGet-csomagot.

• Project –> NuGet-csomagok kezelése... Megjegyzés: Ha nem rendelkezik a NuGet-csomagok kezelése lehetőséggel, telepítse a NuGet legújabb verzióját
• Az Online lap kiválasztása
• Az EntityFramework csomag kiválasztása
• Kattintson a Telepítés gombra

Adjon hozzá egy felhasználói utasítást a System.Data.Entity elemhez a Program.cs tetején.

using System.Data.Entity;

A Program.cs-ben a Post osztály alá adja hozzá a következő származtatott kontextust.

public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
}

Íme egy teljes lista arról, hogy mit kell tartalmaznia a Program.cs.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.Entity;

namespace CodeFirstNewDatabaseSample
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }

    public class Blog
    {
        public int BlogId { get; set; }
        public string Name { get; set; }

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

    public class Post
    {
        public int PostId { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }

        public int BlogId { get; set; }
        public virtual Blog Blog { get; set; }
    }

    public class BloggingContext : DbContext
    {
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }
    }
}

Ennyi kódra van szükségünk az adatok tárolásának és beolvasásának megkezdéséhez. Nyilvánvaló, hogy a színfalak mögött sok minden történik, és ezt hamarosan meg fogjuk vizsgálni; azonban először nézzük meg, hogyan működik.

4. Adatok olvasása és írása

Implementálja a Main metódust a Program.cs fájlban, ahogy az alább látható. Ez a kód létrehoz egy új példányt a környezetünkben, majd egy új blog beszúrására használja. Ezután egy LINQ-lekérdezéssel lekéri az összes blogot az adatbázisból, cím szerint betűrendbe rendezve.

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

Most már futtathatja az alkalmazást, és tesztelheti.

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

Hol találhatók a Saját adatok?

Konvenció szerint a DbContext létrehozott önnek egy adatbázist.

• Ha elérhető egy helyi SQL Express-példány (alapértelmezés szerint telepítve a Visual Studio 2010-ben), akkor a Code First létrehozta az adatbázist a példányon
• Ha az SQL Express nem érhető el, akkor a Code First megpróbálja használni a LocalDB-t (alapértelmezés szerint telepítve a Visual Studio 2012-ben)
• Az adatbázis neve a származtatott környezet teljes neve után van elnevezve, esetünkben ez a CodeFirstNewDatabaseSample.BloggingContext.

Ezek csak az alapértelmezett konvenciók, és különböző módokon módosíthatja az adatbázist, amelyet a Code First használ. További információt a DbContext a modell és az adatbázis-kapcsolat felderítésének témakörében talál. Ehhez az adatbázishoz a Server Explorerrel csatlakozhat a Visual Studióban

• Nézet –> Kiszolgálókezelő

• Kattintson a jobb gombbal az adatkapcsolatokra, és válassza a Kapcsolat hozzáadása lehetőséget...

• Ha még nem csatlakozott adatbázishoz a Server Explorerből, mielőtt a Microsoft SQL Servert kellene adatforrásként választania

  

• Csatlakozzon a LocalDB-hez vagy az SQL Expresshez attól függően, hogy melyiket telepítette

Most már megvizsgálhatjuk a Code First által létrehozott sémát.

A DbContext az általunk definiált DbSet-tulajdonságok alapján alakította ki, hogy mely osztályokat vegye fel a modellbe. Ezután a Code First konvenciók alapértelmezett készletét használja a tábla- és oszlopnevek meghatározásához, az adattípusok meghatározásához, az elsődleges kulcsok kereséséhez stb. Az útmutató későbbi részében áttekintjük, hogyan bírálhatja felül ezeket az egyezményeket.

5. Modellváltozások kezelése

Itt az ideje, hogy módosítsuk a modellünket, amikor ezeket a módosításokat hajtjuk végre, az adatbázissémát is frissíteni kell. Ehhez egy Code First Migrations vagy Migrations nevű funkciót fogunk használni rövid ideig.

A migrálások lehetővé teszik, hogy az adatbázisséma frissítését (és leminősítését) leíró lépések rendezett készletével rendelkezzünk. Ezek a lépések, más néven migrálások, tartalmaznak néhány kódot, amelyek az alkalmazandó módosításokat ismertetik. 

Az első lépés a Code First Migrations engedélyezése a BloggingContexthez.

• Eszközök –> Könyvtárcsomag-kezelő –> Csomagkezelő konzol

• Az Enable-Migrations parancs futtatása a Package Manager konzolon

• A projekthez hozzáadtunk egy új Migrálások mappát, amely két elemet tartalmaz:

  • Configuration.cs – Ez a fájl tartalmazza azokat a beállításokat, amelyeket a migrálások a BloggingContext migrálásához fognak használni. Ehhez az útmutatóhoz semmit nem kell módosítanunk, de itt adhatja meg az alapadatokat, regisztrálhat más adatbázisokhoz szolgáltatókat, módosíthatja a migrációk által létrehozott névteret stb.
  • <időbélyeg>_InitialCreate.cs – Ez az első migráció, amely az adatbázisra már alkalmazott módosításokat jelöli, hogy az üres adatbázisból olyan adatbázissá alakítsa át, amely tartalmazza a Blogok és Bejegyzések táblákat. Bár hagytuk, hogy a Code First automatikusan létrehozza ezeket a táblákat számunkra, most, hogy a migrációt választottuk, ezek átalakultak migrációs folyamattá. A Code First azt is rögzítette a helyi adatbázisunkban, hogy ezt a migrálást már alkalmazták. A fájlnév időbélyege rendelési célokra szolgál.

  Most módosítsuk a modellünket, és adjunk hozzá egy URL-tulajdonságot a blogosztályhoz:

public class Blog
{
    public int BlogId { get; set; }
    public string Name { get; set; }
    public string Url { get; set; }

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

• Futtassa az Add-Migration AddUrl parancsot a Package Manager konzolon. A Add-Migration parancs a legutóbbi migrálás óta ellenőrzi a módosításokat, és új migrálást végez a talált módosításokkal. Nevet adhatunk a migrálásoknak; ebben az esetben az "AddUrl" migrálást hívjuk meg. A sablonozott kód azt mondja, hogy hozzá kell adnunk egy URL oszlopot, amely képes sztringadatokat tárolni a dbo.Blogs táblához. Szükség esetén szerkesztheti a keretrendszer alapján készített kódot, de erre nincs szükség ebben az esetben.

namespace CodeFirstNewDatabaseSample.Migrations
{
    using System;
    using System.Data.Entity.Migrations;

    public partial class AddUrl : DbMigration
    {
        public override void Up()
        {
            AddColumn("dbo.Blogs", "Url", c => c.String());
        }

        public override void Down()
        {
            DropColumn("dbo.Blogs", "Url");
        }
    }
}

• Futtassa az Update-Database parancsot a Package Manager konzolon. Ez a parancs minden függőben lévő migrálást alkalmaz az adatbázisra. Az InitialCreate migrációja már megtörtént, így a migrációk csak az új AddUrl migrációt fogják alkalmazni. Tipp: Az Update-Database parancs –Verbose kapcsolóját használhatja, hogy megtekintse az adatbázison végrehajtott SQL-lekérdezéseket.

Az új URL-oszlop mostantól hozzáadódik az adatbázis Blogok táblához:

6. Adatjegyzetek

Eddig csak lehetővé tettük, hogy az EF felderítse a modellt az alapértelmezett konvenciói alapján, de lesznek olyan időszakok, amikor az osztályaink nem követik az egyezményeket, és további konfigurációt kell végrehajtanunk. Ennek két lehetősége van; Ebben a szakaszban az Adatjegyzeteket, majd a következő szakaszban a fluent API-t tekintjük meg.

• Adjunk hozzá egy felhasználói osztályt a modellhez

public class User
{
    public string Username { get; set; }
    public string DisplayName { get; set; }
}

• Egy halmazt is hozzá kell adnunk a származtatott környezethez

public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
    public DbSet<User> Users { get; set; }
}

• Ha migrálást próbálunk hozzáadni, hibaüzenet jelenik meg, amely szerint az "EntityType "User" nincs meghatározva. Adja meg az EntityType kulcsát." mivel az EF nem tudja, hogy a felhasználónév legyen a felhasználó elsődleges kulcsa.
• Most a Data Annotations-t fogjuk használni, ezért hozzá kell adnunk egy using utasítást a Program.cs-hez.

using System.ComponentModel.DataAnnotations;

• A Felhasználónév tulajdonság megjegyzésével állapítsa meg, hogy ez az elsődleges kulcs

public class User
{
    [Key]
    public string Username { get; set; }
    public string DisplayName { get; set; }
}

• Használja a Add-Migration AddUser parancsot, hogy előkészítsen egy migrációt a módosítások adatbázisra való alkalmazásához.
• Futtassa az Update-Database parancsot az új migrálás adatbázisra való alkalmazásához

A rendszer hozzáadja az új táblát az adatbázishoz:

Az EF által támogatott széljegyzetek teljes listája a következő:

• KeyAttribute
• StringLengthAttribute
• MaxLengthAttribute
• ConcurrencyCheckAttribute
• RequiredAttribute
• TimestampAttribute
• ComplexTypeAttribute
• ColumnAttribute
• TableAttribute
• InversePropertyAttribute
• ForeignKeyAttribute
• DatabaseGeneratedAttribute
• NotMappedAttribute

7. Fluent API

Az előző szakaszban adatjegyzeteket használtunk a konvenció által észlelt adatok kiegészítésére vagy felülbírálására. A modell konfigurálásának másik módja a Code First fluent API.

A legtöbb modellkonfiguráció egyszerű adatjegyzetekkel végezhető el. A fluent API egy fejlettebb módszer a modellkonfiguráció megadására, amely mindent lefed, amit az adatjegyzetek tudnak, valamint lehetőséget nyújt az adatjegyzetekkel nem megoldható speciálisabb konfigurációk elvégzésére is. Az adatjegyzetek és a fluent API együtt használhatók.

A fluent API eléréséhez felül kell bírálnia az OnModelCreating metódust a DbContextben. Tegyük fel, hogy át akarjuk nevezni azt az oszlopot, amelyben a User.DisplayName van tárolva, display_name-re.

• Bírálja felül az OnModelCreating metódust a BloggingContextben az alábbi kóddal

public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
    public DbSet<User> Users { get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<User>()
            .Property(u => u.DisplayName)
            .HasColumnName("display_name");
    }
}

• A Add-Migration ChangeDisplayName paranccsal migrálást hozhat létre a módosítások adatbázisra való alkalmazásához.
• Futtassa az Update-Database parancsot az új migrálás adatbázisra való alkalmazásához.

A DisplayName oszlopot mostantól display_name-re nevezték át.

Összefoglalás

Ebben az útmutatóban a Code First új adatbázissal történő fejlesztését tekintettük át. Definiáltunk egy modellt osztályok használatával, majd ezt a modellt használtuk adatbázis létrehozásához, valamint adatok tárolásához és lekéréséhez. Az adatbázis létrehozása után a Code First Migrations használatával módosítottuk a sémát a modell fejlődésével. Azt is láttuk, hogyan konfigurálhat egy modellt adatjegyzetek és a Fluent API használatával.