Code First do nové databáze

Toto video a podrobný návod poskytují úvod do vývoje Code First, který cílí na novou databázi. Tento scénář zahrnuje cílení na databázi, která neexistuje, a Code First vytvoří nebo prázdnou databázi, do které Code First přidá nové tabulky. Code First umožňuje definovat model pomocí C# nebo VB.Net tříd. Další konfiguraci můžete volitelně provést pomocí atributů ve třídách a vlastnostech nebo pomocí rozhraní API fluent.

Přehrát video

Toto video obsahuje úvod do vývoje Code First zaměřeného na novou databázi. Tento scénář zahrnuje cílení na databázi, která neexistuje, a Code First vytvoří nebo prázdnou databázi, do které Code First přidá nové tabulky. Code First umožňuje definovat model pomocí C# nebo VB.Net tříd. Další konfiguraci můžete volitelně provést pomocí atributů ve třídách a vlastnostech nebo pomocí rozhraní API fluent.

Autor: Rowan Miller

Video: WMV | MP4 | WMV (ZIP)

Předpoklady

K dokončení tohoto návodu budete muset mít nainstalovanou alespoň sadu Visual Studio 2010 nebo Visual Studio 2012.

Pokud používáte Visual Studio 2010, budete také muset mít nainstalovaný NuGet .

1. Vytvoření aplikace

Abychom měli všechno jednoduché, vytvoříme základní konzolovou aplikaci, která k provádění přístupu k datům používá Code First.

• Otevřete sadu Visual Studio.
• Soubor -> Nový -> Projekt...
• V nabídce vlevo vyberte Windows a konzolovou aplikaci.
• Jako název zadejte CodeFirstNewDatabaseSample .
• Vyberte OK.

2. Vytvoření modelu

Pojďme definovat velmi jednoduchý model pomocí tříd. Právě je definujeme v souboru Program.cs, ale v reálné aplikaci byste třídy rozdělili do samostatných souborů a potenciálně samostatný projekt.

Pod definici třídy Program v souboru Program.cs přidejte následující dvě třídy.

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

Všimněte si, že vytváříme dvě navigační vlastnosti (Blog.Posts a Post.Blog). To umožňuje funkci Opožděné načítání entity Framework. Opožděné načítání znamená, že obsah těchto vlastností se při pokusu o přístup k nim automaticky načte z databáze.

3. Vytvoření kontextu

Teď je čas definovat odvozený kontext, který představuje relaci s databází, což nám umožňuje dotazovat a ukládat data. Definujeme kontext, který je odvozen od System.Data.Entity.DbContext a zveřejňuje typed DbSet<TEntity> pro každou třídu v našem modelu.

Teď začínáme používat typy z Entity Frameworku, takže potřebujeme přidat balíček NuGet EntityFramework.

• Projekt –> Správa balíčků NuGet... Poznámka: Pokud nemáte možnost Spravovat balíčky NuGet... měli byste nainstalovat nejnovější verzi NuGetu.
• Výběr karty Online
• Výběr balíčku EntityFramework
• Klikněte na Nainstalovat.

Přidejte příkaz using pro System.Data.Entity v horní části souboru Program.cs.

using System.Data.Entity;

Pod třídu Post v Souboru.cs přidejte následující odvozený kontext.

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

Tady je úplný seznam toho, co by teď program.cs měl obsahovat.

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

To je veškerý kód, který potřebujeme začít ukládat a načítat data. Samozřejmě, že se děje na pozadí docela trochu a my se na to podíváme za chvíli, ale nejprve se podíváme na to v akci.

4. Čtení a zápis dat

Implementujte metodu Main v souboru Program.cs, jak je znázorněno níže. Tento kód vytvoří novou instanci našeho kontextu a pak ji použije k vložení nového blogu. Potom pomocí dotazu LINQ načte všechny blogy z databáze seřazené abecedně podle názvu.

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

Teď můžete aplikaci spustit a otestovat ji.

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

Kde jsou moje data?

Podle konvence DbContext pro vás vytvořila databázi.

• Pokud je k dispozici místní instance SQL Express (ve výchozím nastavení se sadou Visual Studio 2010), služba Code First vytvořila databázi v této instanci.
• Pokud SQL Express není k dispozici, code First se pokusí použít LocalDB (ve výchozím nastavení se sadou Visual Studio 2012)
• Databáze je pojmenována za plně kvalifikovaný název odvozeného kontextu, v našem případě codeFirstNewDatabaseSample.BloggingContext

Toto jsou pouze výchozí konvence a existují různé způsoby, jak změnit databázi, kterou Code First používá, další informace jsou k dispozici v tématu How DbContext Discovers the Model and Database Připojení ion. K této databázi se můžete připojit pomocí Průzkumníka serveru v sadě Visual Studio.

• Zobrazení –> Průzkumník serveru

• Klikněte pravým tlačítkem na Připojení dat a vyberte Přidat Připojení ion...

• Pokud jste se ještě nepřipojili k databázi z Průzkumníka serveru, musíte jako zdroj dat vybrat Microsoft SQL Server.

  

• Připojení k LocalDB nebo SQL Expressu v závislosti na tom, který z nich jste nainstalovali

Teď můžeme zkontrolovat schéma, které code First vytvořil.

DbContext pracoval na třídách, které se mají zahrnout do modelu, a to tak, že se podíváte na vlastnosti DbSet, které jsme definovali. Pak použije výchozí sadu konvencí Code First k určení názvů tabulek a sloupců, určení datových typů, vyhledání primárních klíčů atd. Později v tomto názorném postupu se podíváme, jak můžete tyto konvence přepsat.

5. Práce se změnami modelu

Teď je čas provést nějaké změny modelu, když provedeme tyto změny, potřebujeme také aktualizovat schéma databáze. K tomu použijeme funkci s názvem Migrace Code First nebo krátké migrace.

Migrace nám umožňují uspořádat sadu kroků, které popisují, jak upgradovat (a downgradovat) schéma databáze. Každý z těchto kroků, označovaný jako migrace, obsahuje kód, který popisuje změny, které se mají použít. 

Prvním krokem je povolit Migrace Code First pro náš BloggingContext.

• Nástroje –> Správce balíčků knihovny –> konzola Správce balíčků

• Spusťte příkaz Enable-Migrations v konzole Správce balíčků

• Do našeho projektu byla přidána nová složka Migrace, která obsahuje dvě položky:

  • Configuration.cs – Tento soubor obsahuje nastavení, která budou migrace používat pro migraci BloggingContext. Pro tento názorný postup nemusíme nic měnit, ale tady můžete zadat počáteční data, zaregistrovat zprostředkovatele pro jiné databáze, změnit obor názvů, ve kterém se migrace generují atd.
  • <timestamp>_InitialCreate.cs – toto je vaše první migrace, představuje změny, které už byly použity v databázi, aby byla prázdná databáze na databázi, která obsahuje tabulky Blogy a Příspěvky. I když necháme Code First automaticky vytvářet tyto tabulky, teď, když jsme se přihlásili k migracím, které byly převedeny na migraci. Code First se také zaznamenal v naší místní databázi, že tato migrace už byla použita. Časové razítko názvu souboru se používá pro účely řazení.

  Teď provedeme změnu našeho modelu a přidáme do třídy Blog vlastnost Url:

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

• Spusťte příkaz Add-Migration AddUrl v konzole Správce balíčků. Příkaz Add-Migration kontroluje změny od poslední migrace a vygeneruje novou migraci se všemi nalezenými změnami. Migraci můžeme pojmenovat; v tomto případě voláme migraci AddUrl. Vygenerovaný kód říká, že do dbo potřebujeme přidat sloupec Adresy URL, který může obsahovat řetězcová data. Tabulka blogů V případě potřeby bychom mohli upravit vygenerovaný kód, ale v tomto případě to není nutné.

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

• Spusťte příkaz Update-Database v konzole Správce balíčků. Tento příkaz použije všechny čekající migrace do databáze. Naše migrace InitialCreate už byla použita, takže migrace budou používat pouze naši novou migraci AddUrl. Tip: Při volání update-Database můžete použít přepínač -Podrobné zobrazení SQL, který se spouští v databázi.

Nový sloupec Url se teď přidá do tabulky Blogs v databázi:

6. Datové poznámky

Zatím jsme právě nechali EF zjistit model pomocí výchozích konvencí, ale existují časy, kdy naše třídy nedodržují konvence a musíme být schopni provést další konfiguraci. Existují dvě možnosti; V této části se podíváme na datové poznámky a pak na fluent api v další části.

• Pojďme do našeho modelu přidat třídu User.

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

• Musíme také přidat sadu do našeho odvozeného kontextu.

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

• Pokud bychom se pokusili přidat migraci, zobrazila by se chyba typu EntityType User nemá definovaný žádný klíč. Definujte klíč pro tento typ EntityType. protože EF nemá žádný způsob, jak zjistit, že uživatelské jméno by mělo být primárním klíčem uživatele.
• Teď použijeme datové poznámky, takže musíme přidat příkaz using v horní části souboru Program.cs.

using System.ComponentModel.DataAnnotations;

• Teď anotujte vlastnost Uživatelské jméno a zjistěte, že se jedná o primární klíč.

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

• Pomocí příkazu Add-Migration AddUser vygenerujte migraci, aby se tyto změny použily v databázi.
• Spuštěním příkazu Update-Database použijte novou migraci do databáze.

Nová tabulka se teď přidá do databáze:

Úplný seznam poznámek podporovaných efem je:

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

7. Rozhraní FLUENT API

V předchozí části jsme se podívali na použití datových poznámek k doplnění nebo přepsání toho, co bylo zjištěno konvencí. Druhý způsob konfigurace modelu je prostřednictvím rozhraní API code First fluent.

Většinu konfigurace modelu je možné provést pomocí jednoduchých datových poznámek. Rozhraní API fluent je pokročilejší způsob zadávání konfigurace modelu, který pokrývá vše, co datové poznámky můžou dělat, kromě některých pokročilejších konfigurací není možné s datovými poznámkami. Datové poznámky a fluentské rozhraní API je možné používat společně.

Pokud chcete získat přístup k fluent rozhraní API, přepíšete metodu OnModelCreating v DbContext. Řekněme, že jsme chtěli přejmenovat sloupec, ve kterém je user.DisplayName uložený na display_name.

• Přepsání metody OnModelCreating v BloggingContext následujícím kódem

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

• Pomocí příkazu Add-Migration ChangeDisplayName vygenerujte migraci, aby se tyto změny použily v databázi.
• Spuštěním příkazu Update-Database použijte novou migraci do databáze.

Sloupec DisplayName se teď přejmenuje na display_name:

Shrnutí

V tomto názorném postupu jsme se podívali na vývoj code First pomocí nové databáze. Model jsme definovali pomocí tříd, které pak tento model použili k vytvoření databáze a ukládání a načítání dat. Po vytvoření databáze jsme použili Migrace Code First ke změně schématu při vývoji našeho modelu. Také jsme viděli, jak nakonfigurovat model pomocí datových poznámek a rozhraní Fluent API.