Code First k nové databázi

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.

Podívejte se na 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 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 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 děláme z dvou navigačních vlastností (Blog.Posts a Post.Blog) virtuální. To umožňuje funkci lazy loading v 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.
  • Vyberte kartu Online
  • Výběr balíčku EntityFramework
  • Klikněte na Nainstalovat.

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

using System.Data.Entity;

Pod třídu Post v Program.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ělo 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 k zahájení ukládání a načítání dat. Samozřejmě se toho děje v zákulisí docela dost a za chvíli se na to podíváme, ale nejprve to uvidíme v akci.

4. Čtení a zápis dat

Implementujte metodu Main v 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 podle plně kvalifikovaného názvu 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 Jak DbContext zjistí model a připojení k databázi . K této databázi se můžete připojit pomocí Průzkumníka serveru v sadě Visual Studio.

  • View –> Průzkumník serveru

  • Klikněte pravým tlačítkem na Datová připojení a vyberte Přidat připojení...

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

    Výběr zdroje dat

  • 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.

Počáteční schéma

DbContext určil, které třídy zahrnout do modelu, na základě vlastností 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 průvodci 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, zkráceně 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 povolení migrace Code First pro náš BloggingContext.

  • Nástroje –> Správce balíčků knihoven –> Konzola Správce balíčků

  • Spuštění příkazu 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.
    • <časové razítko>_InitialCreate.cs – Jedná se o vaši první migraci, představuje změny, které už byly použity v databázi, čímž se prázdná databáze změnila na databázi zahrnující tabulky Blogy a Příspěvky. I když necháváme Code First automaticky vytvářet tyto tabulky, teď, když jsme aktivovali migrace, byly převedeny na migrace. Code First také zaznamenal v naší místní databázi, že tato migrace byla již 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; }
}
  • V konzole Správce balíčků spusťte příkaz Add-Migration AddUrl . Příkaz Add-Migration zkontroluje 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 uvádí, že potřebujeme přidat sloupec Url, který může obsahovat řetězcová data, do tabulky dbo.Blogs. Pokud je to nutné, mohli bychom upravit scaffoldovaný kód, ale v tomto případě to není potřeba.
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. Rada: Při volání Update-Database můžete použít přepínač –Verbose, abyste viděli SQL, který se spouští v databázi.

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

Schéma s adresou URL

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 do našeho odvozeného kontextu také přidat množinu.
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 na začátek 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 aplikujte novou migraci do databáze.

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

Schéma s uživateli

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

7. 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í fluent API je pokročilejší způsob zadávání konfigurace modelu, který pokrývá vše, co mohou dělat datové anotace, a navíc umožňuje některé pokročilé konfigurace, které s datovými anotacemi nejsou možné. Datové poznámky a fluentské rozhraní API je možné používat společně.

Pokud chcete získat přístup k fluent API, je třeba přepsat 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řepište metodu 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 aplikujte novou migraci na databázi.

Sloupec DisplayName se teď přejmenuje na display_name:

Schéma s přejmenovaným názvem

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.

  • Last updated on