Code First do nowej bazy danych

Ten film wideo i przewodnik krok po kroku zawierają wprowadzenie do tworzenia Code First przeznaczonych dla nowej bazy danych. Ten scenariusz obejmuje kierowanie do bazy danych, która nie istnieje i Code First, lub pustą bazę danych, Code First doda nowe tabele. Code First umożliwia definiowanie modelu przy użyciu języka C# lub VB.Net klas. Dodatkową konfigurację można opcjonalnie przeprowadzić przy użyciu atrybutów klas i właściwości lub przy użyciu interfejsu API Fluent.

Obejrzyj film

Ten klip wideo zawiera wprowadzenie do tworzenia Code First przeznaczonych dla nowej bazy danych. Ten scenariusz obejmuje kierowanie do bazy danych, która nie istnieje i Code First, lub pustą bazę danych, Code First doda nowe tabele. Code First umożliwia definiowanie modelu przy użyciu języka C# lub VB.Net klas. Dodatkową konfigurację można opcjonalnie przeprowadzić przy użyciu atrybutów klas i właściwości lub przy użyciu interfejsu API Fluent.

Prezentowany przez:Rowan Miller

Wideo:WMVMP4WMV (ZIP)

Wymagania wstępne

Aby ukończyć ten przewodnik, musisz mieć zainstalowany program Visual Studio 2010 lub Visual Studio 2012.

Jeśli używasz programu Visual Studio 2010, konieczne będzie również NuGet instalacji.

1. Tworzenie aplikacji

Aby zachować prostotę, zamierzamy utworzyć podstawową aplikację konsolą, która używa Code First do uzyskiwania dostępu do danych.

  • Otwórz program Visual Studio.
  • Plik — nowy > — Project...
  • Wybierz Windows z menu po lewej stronie i pozycję Aplikacja konsolowa
  • Wprowadź CodeFirstNewDatabaseSample jako nazwę
  • Wybierz przycisk OK.

2. Tworzenie modelu

Zdefiniujmy bardzo prosty model przy użyciu klas. Definiujemy je tylko w pliku Program.cs, ale w rzeczywistej aplikacji klasy można podzielić na oddzielne pliki i potencjalnie oddzielny projekt.

Poniżej definicji klasy Program w programie Program.cs dodaj następujące dwie klasy.

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

Zauważysz, że dwie właściwości nawigacji (Blog.Posts i Post.Blog) są wirtualne. Umożliwia to ładowanie z opóźnieniem funkcji Entity Framework. Ładowanie z opóźnieniem oznacza, że zawartość tych właściwości zostanie automatycznie załadowana z bazy danych podczas próby uzyskania do nich dostępu.

3. Tworzenie kontekstu

Teraz należy zdefiniować kontekst pochodny, który reprezentuje sesję z bazą danych, umożliwiając nam wykonywanie zapytań i zapisywanie danych. Definiujemy kontekst, który pochodzi od elementu System.Data.Entity.DbContext i uwidacznia typowany obiekt DbSet TEntity dla każdej klasy <> w naszym modelu.

Teraz zaczynamy używać typów z Entity Framework, więc musimy dodać pakiet NuGet EntityFramework.

  • Project — > zarządzanie NuGet pakietów... Uwaga: jeśli nie masz opcji Zarządzaj pakietami NuGet... , zainstaluj najnowszą wersję NuGet
  • Wybieranie karty Online
  • Wybieranie pakietu EntityFramework
  • Kliknij pozycję Zainstaluj.

Dodaj instrukcje using dla elementu System.Data.Entity w górnej części strony Program.cs.

using System.Data.Entity;

Poniżej klasy Post w programie Program.cs dodaj następujący kontekst pochodny.

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

Oto pełna lista tego, co powinien teraz zawierać program 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; }
    }
}

To wszystko, czego potrzebujemy, aby rozpocząć przechowywanie i pobieranie danych. Oczywiście sporo się dzieje w tle i przyjrzymy się temu za chwilę, ale najpierw zobaczymy to w działaniu.

4. & Odczytywanie danych zapisu

Zaim implementuj metodę Main w programie Program.cs, jak pokazano poniżej. Ten kod tworzy nowe wystąpienie naszego kontekstu, a następnie używa go do wstawiania nowego bloga. Następnie używa zapytania LINQ, aby pobrać wszystkie blogi z bazy danych uporządkowane alfabetycznie według tytułu.

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

Teraz możesz uruchomić aplikację i przetestować ją.

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

Gdzie są moje dane?

Według konwencji aplikacja DbContext utworzyła dla Ciebie bazę danych.

  • Jeśli lokalne wystąpienie SQL Express jest dostępne (instalowane domyślnie z programem Visual Studio 2010), Code First utworzył bazę danych w tym wystąpieniu
  • Jeśli SQL Express nie jest dostępny, program Code First spróbuje użyć bazy danych LocalDB (zainstalowanej domyślnie z programem Visual Studio 2012)
  • Nazwa bazy danych pochodzi od w pełni kwalifikowanej nazwy kontekstu pochodnego. W naszym przypadku jest to CodeFirstNewDatabaseSample.BlogContext

Są to tylko konwencje domyślne. Istnieją różne sposoby zmiany bazy danych używanej przez program Code First. Więcej informacji można znaleźć w temacie How DbContext Discovers the Model and Database Connection (Jak dbContext odnajduje model i połączenie bazy danych). Możesz połączyć się z tą bazą danych przy użyciu Eksplorator serwera w Visual Studio

  • Widok — Eksplorator serwera

  • Kliknij prawym przyciskiem myszy pozycję Połączenia danych i wybierz polecenie Dodaj połączenie...

  • Jeśli nie nałączono połączenia z bazą danych z Eksplorator serwera, musisz wybrać Microsoft SQL Server jako źródło danych

    Wybieranie źródła danych

  • Połączenie z bazą danych LocalDB lub SQL Express, w zależności od tego, która z nich jest zainstalowana

Teraz możemy sprawdzić schemat, który Code First utworzony.

Początkowy schemat

DbContext opracowywuje klasy do dołączyć do modelu, patrząc na właściwości DbSet, które zdefiniowaliśmy. Następnie używa domyślnego zestawu konwencji Code First do określania nazw tabel i kolumn, określania typów danych, znajdowanie kluczy podstawowych itp. W dalszej części tego przewodnika przyjrzymy się, jak można zastąpić te konwencje.

5. Radzenie sobie ze zmianami modelu

Teraz nasłanie pewnych zmian w modelu. Po wymuśniu tych zmian musimy również zaktualizować schemat bazy danych. W tym celu użyjemy funkcji o nazwie Migracje Code First lub w skrócie migracji.

Migracje umożliwiają nam uporządkowanie zestawu kroków opisujących sposób uaktualniania (i obniżania) schematu bazy danych. Każdy z tych kroków, nazywany migracją, zawiera kod opisujący zmiany, które mają zostać zastosowane. 

Pierwszym krokiem jest włączenie Migracje Code First dla naszego tematu BlogContext.

  • Narzędzia — biblioteka Menedżer pakietów — Menedżer pakietów > konsoli

  • Uruchom polecenie Enable-Migrations w Menedżer pakietów Console

  • Do naszego projektu dodano nowy folder Migrations zawierający dwa elementy:

    • Configuration.cs — ten plik zawiera ustawienia, których migracja będzie używać do migrowania aplikacji BlogContext. Nie musimy niczego zmieniać w tym przewodniku, ale tutaj możesz określić dane iniekcjały, zarejestrować dostawców dla innych baz danych, zmienić przestrzeń nazw, w której są generowane migracje itp.
    • timestamp > _InitialCreate.cs — jest to twoja pierwsza migracja. Reprezentuje ona zmiany, które zostały już zastosowane do bazy danych, aby nie była pustą bazą danych, do tej, która zawiera tabele Blogi i Wpisy. Mimo że Code First automatycznie tworzyć te tabele, teraz, gdy wybraliśmy opcję Migracje, zostały one przekonwertowane na migrację. Code First została również zanotowana w lokalnej bazie danych, że ta migracja została już zastosowana. Sygnatura czasowa nazwy pliku służy do zamawiania.

    Teraz dokonajmy zmiany w naszym modelu i dodajmy właściwość Url do klasy Blog:

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; }
}
  • Uruchom polecenie Add-Migration AddUrl w Menedżer pakietów Konsoli. Polecenie Add-Migration sprawdza zmiany od czasu ostatniej migracji i szkieletuje nową migrację ze znalezionymi zmianami. Możemy nadać migracji nazwę. w tym przypadku jest wywoływana migracja "AddUrl". Szkielet kodu mówi, że musimy dodać kolumnę Adresu URL, która może przechowywać dane ciągu, do pliku dbo. Tabela blogów. W razie potrzeby możemy edytować kod z szkieletem, ale nie jest to wymagane w tym przypadku.
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");
        }
    }
}
  • Uruchom polecenie Update-Database w Menedżer pakietów Console. To polecenie spowoduje zastosowanie wszelkich oczekujących migracji do bazy danych. Nasza migracja InitialCreate została już zastosowana, więc migracje będą po prostu stosować nową migrację AddUrl. Porada: Możesz użyć przełącznika –Verbose podczas wywoływania Update-Database, aby zobaczyć SQL, który jest wykonywany względem bazy danych.

Nowa kolumna Adres URL jest teraz dodawana do tabeli Blogi w bazie danych:

Schemat z adresem URL

6. Adnotacje danych

Do tej pory umożliwialiśmy programowi EF odnajdywanie modelu przy użyciu jego domyślnych konwencji, ale czasami nasze klasy nie są zgodne z konwencjami i musimy mieć możliwość przeprowadzenia dalszej konfiguracji. Dostępne są dwie opcje: W tej sekcji przyjrzymy się adnotacjom danych, a następnie fluent API w następnej sekcji.

  • Dodajmy klasę User do naszego modelu
public class User
{
    public string Username { get; set; }
    public string DisplayName { get; set; }
}
  • Musimy również dodać zestaw do naszego kontekstu pochodnego
public class BloggingContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }
    public DbSet<Post> Posts { get; set; }
    public DbSet<User> Users { get; set; }
}
  • Jeśli próbujemy dodać migrację, otrzymamy komunikat o błędzie"EntityType 'User' has no key defined(Typ jednostki 'Użytkownik' nie ma zdefiniowanego klucza). Zdefiniuj klucz dla tego typu jednostki". ponieważ program EF nie może wiedzieć, że nazwa użytkownika powinna być kluczem podstawowym dla użytkownika.
  • Teraz użyjemy adnotacji danych, więc musimy dodać instrukcje using w górnej części strony Program.cs
using System.ComponentModel.DataAnnotations;
  • Teraz do właściwości Username do adnotacji doszukaj, że jest to klucz podstawowy
public class User
{
    [Key]
    public string Username { get; set; }
    public string DisplayName { get; set; }
}
  • Użyj polecenia Add-Migration AddUser, aby s szkielet migracji zastosować te zmiany do bazy danych
  • Uruchom polecenie Update-Database, aby zastosować nową migrację do bazy danych

Nowa tabela jest teraz dodawana do bazy danych:

Schemat z użytkownikami

Pełna lista adnotacji obsługiwanych przez program EF jest:

7. Fluent API

W poprzedniej sekcji przyjrzeliśmy się używaniu adnotacji danych w celu uzupełnienia lub zastąpienia tego, co zostało wykryte zgodnie z konwencją. Innym sposobem skonfigurowania modelu jest interfejs API Code First fluent.

Większość konfiguracji modelu można wykonać przy użyciu prostych adnotacji danych. Interfejs API Fluent to bardziej zaawansowany sposób określania konfiguracji modelu, który obejmuje wszystko, co adnotacje danych może wykonać oprócz bardziej zaawansowanej konfiguracji, która nie jest możliwa przy użyciu adnotacji danych. Adnotacje danych i fluent API mogą być używane razem.

Aby uzyskać dostęp do fluent API, należy zastąpić metodę OnModelCreating w metodzie DbContext. Załóżmy, że chcemy zmienić nazwę kolumny, w której jest przechowywana nazwa User.DisplayName, display_name.

  • Zastąp metodę OnModelCreating w aplikacji BlogContext następującym kodem
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");
    }
}
  • Użyj polecenia Add-Migration ChangeDisplayName, aby s szkielet migracji zastosować te zmiany do bazy danych.
  • Uruchom polecenie Update-Database, aby zastosować nową migrację do bazy danych.

Nazwa kolumny DisplayName została teraz zmieniona na display_name:

Schemat ze zmienioną nazwą wyświetlaną

Podsumowanie

W tym przewodniku przyjrzeliśmy się Code First przy użyciu nowej bazy danych. Zdefiniowałyśmy model przy użyciu klas, a następnie ujmowały ten model w celu utworzenia bazy danych oraz przechowywania i pobierania danych. Po utworzeniu bazy danych umyliśmy Migracje Code First zmiany schematu w ramach rozwoju naszego modelu. Zobaczyliśmy również, jak skonfigurować model przy użyciu adnotacji danych i interfejsu API Fluent API.