Kurz: Začínáme s Entity Framework 6 Code First pomocí MVC 5Tutorial: Get Started with Entity Framework 6 Code First using MVC 5

Note

Pro nový vývoj doporučujeme ASP.NET Core Razor Pages přes zobrazení a kontrolery ASP.NET MVC.For new development, we recommend ASP.NET Core Razor Pages over ASP.NET MVC controllers and views. Pro řadu kurzů podobné následujícímu pomocí Razor Pages, naleznete v tématu kurzu: Začínáme se stránkami Razor v ASP.NET Core.For a tutorial series similar to this one using Razor Pages, see Tutorial: Get started with Razor Pages in ASP.NET Core. Nové kurzu:The new tutorial:

  • Je usnadňuje její sledování.Is easier to follow.
  • Poskytuje další EF Core osvědčené postupy.Provides more EF Core best practices.
  • Používá účinnější dotazy.Uses more efficient queries.
  • Je více aktuální pomocí nejnovější rozhraní API.Is more current with the latest API.
  • Zahrnuje další funkce.Covers more features.
  • Je upřednostňovaný způsob pro nový vývoj aplikací.Is the preferred approach for new application development.

V této sérii kurzů se dozvíte, jak sestavit aplikaci ASP.NET MVC 5, která pro přístup k datům používá Entity Framework 6.In this series of tutorials, you learn how to build an ASP.NET MVC 5 application that uses Entity Framework 6 for data access. Tento kurz používá Code First pracovního postupu.This tutorial uses the Code First workflow. Informace o tom, jak si vybrat mezi Code First, Database First a první Model, najdete v části vytvořit model.For information about how to choose between Code First, Database First, and Model First, see Create a model.

Tato série kurzů vysvětluje, jak vytvořit ukázková aplikace Contoso University.This tutorial series explains how to build the Contoso University sample application. Ukázková aplikace je jednoduchá university webu.The sample application is a simple university website. S ním můžete zobrazit a aktualizovat Všichni studenti, kurz a informace instruktorem.With it, you can view and update student, course, and instructor information. Tady jsou dvě obrazovky, kterou jste vytvořili:Here are two of the screens you create:

Students_Index_page

Upravit studenta

V tomto kurzu se naučíte:In this tutorial, you:

  • Vytvoření webové aplikace MVCCreate an MVC web app
  • Nastavit styl lokalitySet up the site style
  • Nainstalujte rozhraní Entity Framework 6Install Entity Framework 6
  • Vytvoření datového modeluCreate the data model
  • Vytvořte kontext databázeCreate the database context
  • Inicializace databáze s testovací dataInitialize DB with test data
  • Nastavení EF 6 pro použití LocalDBSet up EF 6 to use LocalDB
  • Vytvoření kontroleru a zobrazeníCreate controller and views
  • Zobrazení databázeView the database

PožadavkyPrerequisites

Vytvoření webové aplikace MVCCreate an MVC web app

  1. Otevřete Visual Studio a vytvořte C# webového projektu pomocí webová aplikace ASP.NET (.NET Framework) šablony.Open Visual Studio and create a C# web project using the ASP.NET Web Application (.NET Framework) template. Pojmenujte projekt ContosoUniversity a vyberte OK.Name the project ContosoUniversity and select OK.

    Dialogové okno Nový projekt v sadě Visual Studio

  2. V nová webová aplikace ASP.NET - ContosoUniversityvyberte MVC.In New ASP.NET Web Application - ContosoUniversity, select MVC.

    Webové aplikace dialogové okno Nový v sadě Visual Studio

    Note

    Ve výchozím nastavení ověřování je možnost nastavená na bez ověřování.By default, the Authentication option is set to No Authentication. Pro účely tohoto kurzu webové aplikace nevyžaduje, aby uživatelům umožní přihlásit.For this tutorial, the web app doesn't require users to sign in. Také nijak neomezuje přístup na základě, na který je přihlášen.Also, it doesn't restrict access based on who's signed in.

  3. Vyberte OK pro vytvoření projektu.Select OK to create the project.

Nastavit styl lokalitySet up the site style

Několik jednoduchých změn se nastavit v nabídce webu, rozložení a domovské stránky.A few simple changes will set up the site menu, layout, and home page.

  1. Otevřít Views\Shared\_Layout.cshtmla proveďte následující změny:Open Views\Shared\_Layout.cshtml, and make the following changes:

    • Změňte všechny výskyty "My ASP.NET Application" a "Název aplikace" na "University společnosti Contoso".Change each occurrence of "My ASP.NET Application" and "Application name" to "Contoso University".
    • Přidání položek nabídky pro studenty, kurzy, vyučující a oddělení a odstraňte záznam kontaktu.Add menu entries for Students, Courses, Instructors, and Departments, and delete the Contact entry.

    Změny jsou vyznačené na následující fragment kódu:The changes are highlighted in the following code snippet:

    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>@ViewBag.Title - Contoso University</title>
        @Styles.Render("~/Content/css")
        @Scripts.Render("~/bundles/modernizr")
    </head>
    <body>
        <div class="navbar navbar-inverse navbar-fixed-top">
            <div class="navbar-inner">
                <div class="container">
                    <button type="button" class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse">
                        <span class="icon-bar"></span>
                        <span class="icon-bar"></span>
                        <span class="icon-bar"></span>
                    </button>
                    @Html.ActionLink("Contoso University", "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })
                    <div class="nav-collapse collapse">
                        <ul class="nav">
                            <li>@Html.ActionLink("Home", "Index", "Home")</li>
                            <li>@Html.ActionLink("About", "About", "Home")</li>
                            <li>@Html.ActionLink("Students", "Index", "Student")</li>
                            <li>@Html.ActionLink("Courses", "Index", "Course")</li>
                            <li>@Html.ActionLink("Instructors", "Index", "Instructor")</li>
                            <li>@Html.ActionLink("Departments", "Index", "Department")</li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    
        <div class="container">
            @RenderBody()
            <hr />
            <footer>
                <p>&copy; @DateTime.Now.Year - Contoso University</p>
            </footer>
        </div>
    
        @Scripts.Render("~/bundles/jquery")
        @Scripts.Render("~/bundles/bootstrap")
        @RenderSection("scripts", required: false)
    </body>
    </html>
    
  2. V Views\Home\Index.cshtml, nahraďte obsah souboru následující kód, který nahradí text o ASP.NET a MVC o této aplikaci:In Views\Home\Index.cshtml, replace the contents of the file with the following code to replace the text about ASP.NET and MVC with text about this application:

    @{
        ViewBag.Title = "Home Page";
    }
    
    <div class="jumbotron">
        <h1>Contoso University</h1>
    </div>
    <div class="row">
        <div class="col-md-4">
            <h2>Welcome to Contoso University</h2>
            <p>Contoso University is a sample application that
            demonstrates how to use Entity Framework 6 in an 
            ASP.NET MVC 5 web application.</p>
        </div>
        <div class="col-md-4">
            <h2>Build it from scratch</h2>
            <p>You can build the application by following the steps in the tutorial series on the ASP.NET site.</p>
            <p><a class="btn btn-default" href="http://www.asp.net/mvc/tutorials/getting-started-with-ef-using-mvc/">See the tutorial &raquo;</a></p>
        </div>
        <div class="col-md-4">
            <h2>Download it</h2>
            <p>You can download the completed project.</p>
            <p><a class="btn btn-default" href="https://webpifeed.blob.core.windows.net/webpifeed/Partners/ASP.NET%20MVC%20Application%20Using%20Entity%20Framework%20Code%20First.zip">Download &raquo;</a></p>
        </div>
    </div>
    
  3. Stiskněte Ctrl + F5 ke spuštění webové stránky.Press Ctrl+F5 to run the web site. Zobrazí domovská stránka s hlavní nabídky.You see the home page with the main menu.

Nainstalujte rozhraní Entity Framework 6Install Entity Framework 6

  1. Z nástroje nabídky, zvolte Správce balíčků NuGeta pak zvolte konzoly Správce balíčků.From the Tools menu, choose NuGet Package Manager, and then choose Package Manager Console.

  2. V Konzola správce balíčků okno, zadejte následující příkaz:In the Package Manager Console window, enter the following command:

    Install-Package EntityFramework
    

Tento krok je jedním z několika kroků, obsahující tento kurz můžete provést ručně, ale že by byly provedeny automaticky funkcí generování uživatelského rozhraní technologie ASP.NET MVC.This step is one of a few steps that this tutorial has you do manually, but that could have been done automatically by the ASP.NET MVC scaffolding feature. Provádíte je ručně, aby mohli zobrazit kroky potřebné k použití Entity Framework (EF).You're doing them manually so that you can see the steps required to use Entity Framework (EF). Později budete používat generování uživatelského rozhraní pro vytvoření kontroleru MVC a zobrazení.You'll use scaffolding later to create the MVC controller and views. Alternativou je umožnit generování uživatelského rozhraní automaticky nainstalovat balíček EF NuGet, vytvořit třídy kontextu databáze a vytvořit připojovací řetězec.An alternative is to let scaffolding automatically install the EF NuGet package, create the database context class, and create the connection string. Jakmile budete připraveni to udělat tak, je vše, co musíte udělat Přeskočit tyto kroky a generování uživatelského rozhraní řadiče MVC po vytvoření tříd entit.When you're ready to do it that way, all you have to do is skip those steps and scaffold your MVC controller after you create your entity classes.

Vytvoření datového modeluCreate the data model

Dále vytvoříte tříd entit pro aplikaci Contoso University.Next you'll create entity classes for the Contoso University application. Začnete s následující tři entity:You'll start with the following three entities:

Kurz <-> registrace <-> studentaCourse <-> Enrollment <-> Student

EntityEntities RelaceRelationship
Kurz k registraciCourse to Enrollment Jeden mnohoOne-to-many
Student k registraciStudent to Enrollment Jeden mnohoOne-to-many

Existuje vztah jeden mnoho mezi Student a Enrollment entity, a existuje vztah jeden mnoho mezi Course a Enrollment entity.There's a one-to-many relationship between Student and Enrollment entities, and there's a one-to-many relationship between Course and Enrollment entities. Jinými slovy student možné zaregistrovat libovolný počet kurzy a kurzu může mít libovolný počet studentů zaregistrovaná do něj.In other words, a student can be enrolled in any number of courses, and a course can have any number of students enrolled in it.

V následujících částech vytvoříte třídu pro každou z těchto entit.In the following sections, you'll create a class for each one of these entities.

Note

Pokud se pokusíte ke kompilaci projektu před dokončením vytvoření všech těchto tříd entit, získáte chyby kompilátoru.If you try to compile the project before you finish creating all of these entity classes, you'll get compiler errors.

Entita studentaThe Student entity

  • V modely složku, vytvořte soubor třídy s názvem Student.cs klepnutím pravým tlačítkem myši na složku v Průzkumník řešení a volba přidat > Třídy.In the Models folder, create a class file named Student.cs by right-clicking on the folder in Solution Explorer and choosing Add > Class. Nahraďte kód šablony následujícím kódem:Replace the template code with the following code:

    using System;
    using System.Collections.Generic;
    
    namespace ContosoUniversity.Models
    {
        public class Student
        {
            public int ID { get; set; }
            public string LastName { get; set; }
            public string FirstMidName { get; set; }
            public DateTime EnrollmentDate { get; set; }
            
            public virtual ICollection<Enrollment> Enrollments { get; set; }
        }
    }
    

ID Vlastnost se stane sloupec primárního klíče tabulky databáze, která odpovídá této třídy.The ID property will become the primary key column of the database table that corresponds to this class. Ve výchozím nastavení Entity Framework interpretuje vlastnost s názvem ID nebo název třídy ID jako primární klíč.By default, Entity Framework interprets a property that's named ID or classname ID as the primary key.

Enrollments Je vlastnost navigační vlastnost.The Enrollments property is a navigation property. Vlastnosti navigace podržte dalšími subjekty, které se vztahují k této entity.Navigation properties hold other entities that are related to this entity. V takovém případě Enrollments vlastnost Student entita bude obsahovat všechny Enrollment entity, které se vztahují k, které Student entity.In this case, the Enrollments property of a Student entity will hold all of the Enrollment entities that are related to that Student entity. Jinými slovy Pokud daný Student řádků v databázi má dva související Enrollment řádky (hodnota řádky, které obsahují student získal primární klíč v jejich StudentID sloupec cizího klíče), který Student entity Enrollments navigační vlastnost bude obsahovat tyto dvě Enrollment entity.In other words, if a given Student row in the database has two related Enrollment rows (rows that contain that student's primary key value in their StudentID foreign key column), that Student entity's Enrollments navigation property will contain those two Enrollment entities.

Navigační vlastnosti se obvykle definují jako virtual tak, aby se můžete využít některé funkce Entity Framework, jako opožděné načtení.Navigation properties are typically defined as virtual so that they can take advantage of certain Entity Framework functionality such as lazy loading. (Opožděné načtení budou vysvětlena dále v čtení souvisejících dat později v této sérii kurzů.)(Lazy loading will be explained later, in the Reading Related Data tutorial later in this series.)

Pokud vlastnost navigace může obsahovat více entit (jako v relace m: n nebo 1 n), jeho typ musí být seznam, ve kterém položky lze přidávat, odstranit a aktualizovat, například ICollection.If a navigation property can hold multiple entities (as in many-to-many or one-to-many relationships), its type must be a list in which entries can be added, deleted, and updated, such as ICollection.

Registrace entityThe Enrollment entity

  • V modely složku, vytvořte Enrollment.cs a nahraďte existující kód následujícím kódem:In the Models folder, create Enrollment.cs and replace the existing code with the following code:

    namespace ContosoUniversity.Models
    {
        public enum Grade
        {
            A, B, C, D, F
        }
    
        public class Enrollment
        {
            public int EnrollmentID { get; set; }
            public int CourseID { get; set; }
            public int StudentID { get; set; }
            public Grade? Grade { get; set; }
            
            public virtual Course Course { get; set; }
            public virtual Student Student { get; set; }
        }
    }
    

EnrollmentID Bude mít vlastnost primárního klíče; tato entita používá classname ID vzorku místo ID samostatně jako jste viděli v Student entity.The EnrollmentID property will be the primary key; this entity uses the classname ID pattern instead of ID by itself as you saw in the Student entity. Obvykle by zvolte jeden model a použít ho v rámci datového modelu.Ordinarily you would choose one pattern and use it throughout your data model. Tady variantu ukazuje, které můžete použít buď vzor.Here, the variation illustrates that you can use either pattern. V pozdějších kurzech, zobrazí se vám jak pomocí ID bez classname usnadňuje implementaci dědičnosti v datovém modelu.In a later tutorial, you'll see how using ID without classname makes it easier to implement inheritance in the data model.

Grade Vlastnost je výčtu.The Grade property is an enum. Otazník po Grade deklarace typu znamená, že Grade vlastnost s možnou hodnotou Null.The question mark after the Grade type declaration indicates that the Grade property is nullable. Se liší od nulovou na podnikové úrovni na podnikové úrovni, který má hodnotu null – hodnota null znamená známku vyjádřenou není znám nebo ještě nebyly přiřazeny.A grade that's null is different from a zero grade — null means a grade isn't known or hasn't been assigned yet.

StudentID Vlastnost je cizí klíč a odpovídající navigační vlastnost je Student.The StudentID property is a foreign key, and the corresponding navigation property is Student. Enrollment Entita je přidružený nejméně k jednomu Student entity, tak vlastnost může obsahovat pouze jeden Student entity (na rozdíl od Student.Enrollments navigační vlastnost předchozímu příkladu, který může obsahovat více Enrollment entity).An Enrollment entity is associated with one Student entity, so the property can only hold a single Student entity (unlike the Student.Enrollments navigation property you saw earlier, which can hold multiple Enrollment entities).

CourseID Vlastnost je cizí klíč a odpovídající navigační vlastnost je Course.The CourseID property is a foreign key, and the corresponding navigation property is Course. Enrollment Entita je přidružený nejméně k jednomu Course entity.An Enrollment entity is associated with one Course entity.

Nastavení interpretuje Entity Framework vlastnost jako vlastnost cizího klíče Pokud je název <název navigační vlastnosti><vlastnost primárního klíče název> (například StudentIDpro Student navigační vlastnost, protože Student je primární klíč entity ID).Entity Framework interprets a property as a foreign key property if it's named <navigation property name><primary key property name> (for example, StudentID for the Student navigation property since the Student entity's primary key is ID). Vlastnosti cizího klíče může také být pojmenován stejně jednoduše <vlastnost primárního klíče název> (například CourseID od Course je primární klíč entity CourseID).Foreign key properties can also be named the same simply <primary key property name> (for example, CourseID since the Course entity's primary key is CourseID).

Kurz entityThe Course entity

  • V modely složku, vytvořte Course.cs, nahraďte kód šablony následujícím kódem:In the Models folder, create Course.cs, replacing the template code with the following code:

    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations.Schema;
    
    namespace ContosoUniversity.Models
    {
        public class Course
        {
            [DatabaseGenerated(DatabaseGeneratedOption.None)]
            public int CourseID { get; set; }
            public string Title { get; set; }
            public int Credits { get; set; }
            
            public virtual ICollection<Enrollment> Enrollments { get; set; }
        }
    }
    

Enrollments Je navigační vlastnost.The Enrollments property is a navigation property. A Course entit může souviset s libovolným počtem Enrollment entity.A Course entity can be related to any number of Enrollment entities.

Budete říkáme více o DatabaseGeneratedAttribute atribut v pozdějších kurzech této řady.We'll say more about the DatabaseGeneratedAttribute attribute in a later tutorial in this series. V podstatě tento atribut umožňuje zadat primární klíč pro kurz namísto nutnosti databáze jeho vygenerování.Basically, this attribute lets you enter the primary key for the course rather than having the database generate it.

Vytvořte kontext databázeCreate the database context

Hlavní třída, která koordinuje funkce Entity Framework pro daný datový model je kontext databáze třídy.The main class that coordinates Entity Framework functionality for a given data model is the database context class. Vytvoření této třídy odvozené z System.Data.Entity.DbContext třídy.You create this class by deriving from the System.Data.Entity.DbContext class. Ve svém kódu určit entit, které jsou součástí datového modelu.In your code, you specify which entities are included in the data model. Můžete také přizpůsobit chování určité Entity Framework.You can also customize certain Entity Framework behavior. V tomto projektu je s názvem třídy SchoolContext.In this project, the class is named SchoolContext.

  • K vytvoření složky v projektu ContosoUniversity, klikněte pravým tlačítkem na projekt v Průzkumníka řešení a klikněte na tlačítko přidata potom klikněte na tlačítko novou složku.To create a folder in the ContosoUniversity project, right-click the project in Solution Explorer and click Add, and then click New Folder. Název nové složky DAL (pro Data Access Layer).Name the new folder DAL (for Data Access Layer). V této složce, vytvořte nový soubor třídy SchoolContext.csa nahraďte kód šablony následujícím kódem:In that folder, create a new class file named SchoolContext.cs, and replace the template code with the following code:

    using ContosoUniversity.Models;
    using System.Data.Entity;
    using System.Data.Entity.ModelConfiguration.Conventions;
    
    namespace ContosoUniversity.DAL
    {
        public class SchoolContext : DbContext
        {
        
            public SchoolContext() : base("SchoolContext")
            {
            }
            
            public DbSet<Student> Students { get; set; }
            public DbSet<Enrollment> Enrollments { get; set; }
            public DbSet<Course> Courses { get; set; }
    
            protected override void OnModelCreating(DbModelBuilder modelBuilder)
            {
                modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
            }
        }
    }
    

Určení sady entitSpecify entity sets

Tento kód vytvoří DbSet vlastností pro každou sadu entit.This code creates a DbSet property for each entity set. V terminologii Entity Framework sadu entit obvykle odpovídá tabulku databáze a entity odpovídající řádek v tabulce.In Entity Framework terminology, an entity set typically corresponds to a database table, and an entity corresponds to a row in the table.

Note

Můžete vynechat DbSet<Enrollment> a DbSet<Course> příkazy a bude fungovat stejně.You can omit the DbSet<Enrollment> and DbSet<Course> statements and it would work the same. Entity Framework bude zahrnovat je implicitně protože Student odkazy na entity Enrollment entity a Enrollment odkazy na entity Course entity.Entity Framework would include them implicitly because the Student entity references the Enrollment entity and the Enrollment entity references the Course entity.

Zadejte připojovací řetězecSpecify the connection string

Název připojovacího řetězce (které přidáte do souboru Web.config později) je předáno konstruktoru.The name of the connection string (which you'll add to the Web.config file later) is passed in to the constructor.

public SchoolContext() : base("SchoolContext")
{
}

Můžete také předat samotný připojovací řetězec ne název jednoho, který je uložen v souboru Web.config.You could also pass in the connection string itself instead of the name of one that is stored in the Web.config file. Další informace o možnosti pro určení databáze, které se mají použít, najdete v části připojovací řetězce a modely.For more information about options for specifying the database to use, see Connection strings and models.

Pokud nechcete explicitně zadat připojovací řetězec nebo název jednoho, Entity Framework předpokládá, že název připojovacího řetězce je stejný jako název třídy.If you don't specify a connection string or the name of one explicitly, Entity Framework assumes that the connection string name is the same as the class name. Výchozí název připojovacího řetězce v tomto příkladu by pak SchoolContext, stejně jako co zadáváte explicitně.The default connection string name in this example would then be SchoolContext, the same as what you're specifying explicitly.

Zadejte názvy singulární tabulekSpecify singular table names

modelBuilder.Conventions.Remove Výroky OnModelCreating metoda zabraňuje se pluralized názvy tabulek.The modelBuilder.Conventions.Remove statement in the OnModelCreating method prevents table names from being pluralized. Pokud jste to neudělali, by se pojmenoval generované tabulky v databázi Students, Courses, a Enrollments.If you didn't do this, the generated tables in the database would be named Students, Courses, and Enrollments. Místo toho budou názvy tabulek Student, Course, a Enrollment.Instead, the table names will be Student, Course, and Enrollment. Vývojáři Nesouhlasím o tom, jestli by měl názvy tabulek pluralized nebo ne.Developers disagree about whether table names should be pluralized or not. Tento kurz používá jednotný tvar, ale důležité je, že můžete vybrat libovolný formulář dáváte přednost zahrnutím nebo vynechání tento řádek kódu.This tutorial uses the singular form, but the important point is that you can select whichever form you prefer by including or omitting this line of code.

Inicializace databáze s testovací dataInitialize DB with test data

Entity Framework můžete automaticky vytvořit (nebo vyřadit a znovu vytvořit) databáze za vás při spuštění aplikace.Entity Framework can automatically create (or drop and re-create) a database for you when the application runs. Můžete určit, že to by mělo být provedeno pokaždé, když vaše aplikace spuštěná, nebo jenom v případě modelu je synchronizovaný s existující databází.You can specify that this should be done every time your application runs or only when the model is out of sync with the existing database. Můžete je zapsat také Seed metody tohoto rozhraní Entity Framework automaticky volá po vytvoření databáze, aby bylo možné naplnit ho daty testu.You can also write a Seed method that Entity Framework automatically calls after creating the database in order to populate it with test data.

Výchozí chování je vytvořit databázi jenom v případě, že ho neexistuje (a vyvolání výjimky, pokud došlo ke změně modelu a databáze již existuje).The default behavior is to create a database only if it doesn't exist (and throw an exception if the model has changed and the database already exists). V této části zadáte, že by měl být databázi vyřadit a znovu vytvořit při každé změně modelu.In this section, you'll specify that the database should be dropped and re-created whenever the model changes. Vyřazení databáze způsobí ztrátu všechna vaše data.Dropping the database causes the loss of all your data. Toto je obvykle dobře během vývoje, protože Seed metody se spustí, jakmile se znovu vytvoří databázi a znovu vytvoříte testovací data.This is generally okay during development, because the Seed method will run when the database is re-created and will re-create your test data. Ale v produkčním prostředí budete obvykle nechcete ztratit všechna vaše data pokaždé, když je třeba změnit schéma databáze.But in production you generally don't want to lose all your data every time you need to change the database schema. Později uvidíte, jak zpracovat změny modelu pomocí migrace Code First pro změnu schématu databáze místo vyřadit a znovu vytvořit databázi.Later you'll see how to handle model changes by using Code First Migrations to change the database schema instead of dropping and re-creating the database.

  1. Ve složce DAL, vytvořte nový soubor třídy s názvem SchoolInitializer.cs a nahraďte kód šablony následujícím kódem, což způsobí, že databáze má být vytvořen v případě potřeby a načte testovací data do nové databáze.In the DAL folder, create a new class file named SchoolInitializer.cs and replace the template code with the following code, which causes a database to be created when needed and loads test data into the new database.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web;
    using System.Data.Entity;
    using ContosoUniversity.Models;
    
    namespace ContosoUniversity.DAL
    {
        public class SchoolInitializer : System.Data.Entity. DropCreateDatabaseIfModelChanges<SchoolContext>
        {
            protected override void Seed(SchoolContext context)
            {
                var students = new List<Student>
                {
                new Student{FirstMidName="Carson",LastName="Alexander",EnrollmentDate=DateTime.Parse("2005-09-01")},
                new Student{FirstMidName="Meredith",LastName="Alonso",EnrollmentDate=DateTime.Parse("2002-09-01")},
                new Student{FirstMidName="Arturo",LastName="Anand",EnrollmentDate=DateTime.Parse("2003-09-01")},
                new Student{FirstMidName="Gytis",LastName="Barzdukas",EnrollmentDate=DateTime.Parse("2002-09-01")},
                new Student{FirstMidName="Yan",LastName="Li",EnrollmentDate=DateTime.Parse("2002-09-01")},
                new Student{FirstMidName="Peggy",LastName="Justice",EnrollmentDate=DateTime.Parse("2001-09-01")},
                new Student{FirstMidName="Laura",LastName="Norman",EnrollmentDate=DateTime.Parse("2003-09-01")},
                new Student{FirstMidName="Nino",LastName="Olivetto",EnrollmentDate=DateTime.Parse("2005-09-01")}
                };
    
                students.ForEach(s => context.Students.Add(s));
                context.SaveChanges();
                var courses = new List<Course>
                {
                new Course{CourseID=1050,Title="Chemistry",Credits=3,},
                new Course{CourseID=4022,Title="Microeconomics",Credits=3,},
                new Course{CourseID=4041,Title="Macroeconomics",Credits=3,},
                new Course{CourseID=1045,Title="Calculus",Credits=4,},
                new Course{CourseID=3141,Title="Trigonometry",Credits=4,},
                new Course{CourseID=2021,Title="Composition",Credits=3,},
                new Course{CourseID=2042,Title="Literature",Credits=4,}
                };
                courses.ForEach(s => context.Courses.Add(s));
                context.SaveChanges();
                var enrollments = new List<Enrollment>
                {
                new Enrollment{StudentID=1,CourseID=1050,Grade=Grade.A},
                new Enrollment{StudentID=1,CourseID=4022,Grade=Grade.C},
                new Enrollment{StudentID=1,CourseID=4041,Grade=Grade.B},
                new Enrollment{StudentID=2,CourseID=1045,Grade=Grade.B},
                new Enrollment{StudentID=2,CourseID=3141,Grade=Grade.F},
                new Enrollment{StudentID=2,CourseID=2021,Grade=Grade.F},
                new Enrollment{StudentID=3,CourseID=1050},
                new Enrollment{StudentID=4,CourseID=1050,},
                new Enrollment{StudentID=4,CourseID=4022,Grade=Grade.F},
                new Enrollment{StudentID=5,CourseID=4041,Grade=Grade.C},
                new Enrollment{StudentID=6,CourseID=1045},
                new Enrollment{StudentID=7,CourseID=3141,Grade=Grade.A},
                };
                enrollments.ForEach(s => context.Enrollments.Add(s));
                context.SaveChanges();
            }
        }
    }
    

    Seed Metoda přijímá jako vstupní parametr objekt kontextu databáze, a kód v metodě používá tento objekt k přidání nové entity do databáze.The Seed method takes the database context object as an input parameter, and the code in the method uses that object to add new entities to the database. Pro každý typ entity kód vytvoří kolekci nové entity, se přidají do příslušné DbSet vlastnost a uloží změny do databáze.For each entity type, the code creates a collection of new entities, adds them to the appropriate DbSet property, and then saves the changes to the database. Není nutné volat SaveChanges metoda po každé skupiny entit, jako se zde provádí, ale způsobem, který pomáhá při hledání příčiny problému, pokud dojde k výjimce, zatímco kód zapisuje do databáze.It isn't necessary to call the SaveChanges method after each group of entities, as is done here, but doing that helps you locate the source of a problem if an exception occurs while the code is writing to the database.

  2. Zjistit Entity Framework pomocí vaší inicializátor třídy, přidejte element, který má entityFramework v aplikaci prvku Web.config souboru (je v kořenové složce projektu), jak je znázorněno v následujícím příkladu:To tell Entity Framework to use your initializer class, add an element to the entityFramework element in the application Web.config file (the one in the root project folder), as shown in the following example:

    <entityFramework>
      <contexts>
        <context type="ContosoUniversity.DAL.SchoolContext, ContosoUniversity">
          <databaseInitializer type="ContosoUniversity.DAL.SchoolInitializer, ContosoUniversity" />
        </context>
      </contexts>
      <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
        <parameters>
          <parameter value="v11.0" />
        </parameters>
      </defaultConnectionFactory>
      <providers>
        <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
      </providers>
    </entityFramework>
    

    context type Určuje kontext plně kvalifikovaný název třídy a sestavení probíhá, a databaseinitializer type Určuje plně kvalifikovaný název inicializátor třídy a je v sestavení.The context type specifies the fully qualified context class name and the assembly it's in, and the databaseinitializer type specifies the fully qualified name of the initializer class and the assembly it's in. (Pokud nechcete, aby EF použití inicializátoru, můžete nastavit atribut na context element: disableDatabaseInitialization="true".) Další informace najdete v tématu nastavení konfiguračního souboru.(When you don't want EF to use the initializer, you can set an attribute on the context element: disableDatabaseInitialization="true".) For more information, see Configuration File Settings.

    Alternativa k nastavení inicializátoru Web.config souboru se to udělat v kódu tak, že přidáte Database.SetInitializer příkazu Application_Start metoda ve Global.asax.cs souboru.An alternative to setting the initializer in the Web.config file is to do it in code by adding a Database.SetInitializer statement to the Application_Start method in the Global.asax.cs file. Další informace najdete v tématu Principy inicializátory databáze v Entity Framework Code First.For more information, see Understanding Database Initializers in Entity Framework Code First.

Aplikace je nyní nastavit tak, aby při přístupu k databázi v daném běhu aplikace poprvé, Entity Framework porovnává databáze do modelu (vaše SchoolContext a tříd entit).The application is now set up so that when you access the database for the first time in a given run of the application, Entity Framework compares the database to the model (your SchoolContext and entity classes). Pokud rozdíl aplikace zahodí a znovu vytvoří databázi.If there's a difference, the application drops and re-creates the database.

Note

Při nasazení aplikace do produkčního prostředí webového serveru, musíte odebrat nebo zakázat kód, který se zahodí a znovu vytvoří databázi.When you deploy an application to a production web server, you must remove or disable code that drops and re-creates the database. Můžete to udělat v pozdějších kurzech v této sérii.You'll do that in a later tutorial in this series.

Nastavení EF 6 pro použití LocalDBSet up EF 6 to use LocalDB

LocalDB je Odlehčená verze databázového stroje systému SQL Server Express.LocalDB is a lightweight version of the SQL Server Express database engine. Snadno nainstalujte a nakonfigurujte, spustí na vyžádání a běží v uživatelském režimu.It's easy to install and configure, starts on demand, and runs in user mode. LocalDB běží v ve speciálním režimu provádění SQL Server Express, která umožňuje pracovat s databází jako .mdf soubory.LocalDB runs in a special execution mode of SQL Server Express that enables you to work with databases as .mdf files. Můžete umístit soubory databáze LocalDB aplikace_Data složce webového projektu, pokud chcete zkopírovat databázi s projektem.You can put LocalDB database files in the App_Data folder of a web project if you want to be able to copy the database with the project. Funkce instance uživatele v SQL serveru Express také umožňuje pracovat s .mdf soubory, ale uživatelské instance funkce je zastaralá možnost; proto se doporučuje LocalDB pro práci s .mdf soubory.The user instance feature in SQL Server Express also enables you to work with .mdf files, but the user instance feature is deprecated; therefore, LocalDB is recommended for working with .mdf files. LocalDB je nainstalovaný ve výchozím nastavení se sadou Visual Studio.LocalDB is installed by default with Visual Studio.

Obvykle SQL Server Express se nepoužívá pro produkční webové aplikace.Typically, SQL Server Express is not used for production web applications. LocalDB zejména se nedoporučuje pro produkční použití s webovou aplikací vzhledem k tomu, že má nejsou určeny pro práci se službou IIS.LocalDB in particular is not recommended for production use with a web application because it's not designed to work with IIS.

  • V tomto kurzu budete pracovat s LocalDB.In this tutorial, you'll work with LocalDB. Otevřete aplikaci Web.config a přidejte connectionStrings předchozí element appSettings elementu, jak je znázorněno v následujícím příkladu.Open the application Web.config file and add a connectionStrings element preceding the appSettings element, as shown in the following example. (Nezapomeňte aktualizovat Web.config soubor v kořenové složce projektu.(Make sure you update the Web.config file in the root project folder. K dispozici je také Web.config soubor zobrazení podsložky, která není nutné aktualizovat.)There's also a Web.config file in the Views subfolder that you don't need to update.)

    <connectionStrings>
        <add name="SchoolContext" connectionString="Data Source=(LocalDb)\MSSQLLocalDB;Initial Catalog=ContosoUniversity1;Integrated Security=SSPI;" providerName="System.Data.SqlClient"/>
    </connectionStrings>
    <appSettings>
      <add key="webpages:Version" value="3.0.0.0" />
      <add key="webpages:Enabled" value="false" />
      <add key="ClientValidationEnabled" value="true" />
      <add key="UnobtrusiveJavaScriptEnabled" value="true" />
    </appSettings>
    

Určuje připojovací řetězec, který jste přidali, Entity Framework použijete databázi LocalDB s názvem ContosoUniversity1.mdf.The connection string you've added specifies that Entity Framework will use a LocalDB database named ContosoUniversity1.mdf. (Databáze ještě neexistuje ale EF ji vytvoří.) Pokud chcete vytvořit databázi v vaše aplikace_Data složky, můžete přidat AttachDBFilename=|DataDirectory|\ContosoUniversity1.mdf na připojovací řetězec.(The database doesn't exist yet but EF will create it.) If you want to create the database in your App_Data folder, you could add AttachDBFilename=|DataDirectory|\ContosoUniversity1.mdf to the connection string. Další informace o připojovacích řetězcích najdete v tématu připojovací řetězce SQL serveru pro webové aplikace ASP.NET.For more information about connection strings, see SQL Server Connection Strings for ASP.NET Web Applications.

Doopravdy nepotřebujete připojovacího řetězce v Web.config souboru.You don't actually need a connection string in the Web.config file. Pokud nezadáte připojovací řetězec, Entity Framework používá výchozí propojovací řetězec založené na třídě kontextu.If you don't supply a connection string, Entity Framework uses a default connection string based on your context class. Další informace najdete v tématu Code First pro novou databázi.For more information, see Code First to a New Database.

Vytvoření kontroleru a zobrazeníCreate controller and views

Teď vytvoříte webovou stránku zobrazit data.Now you'll create a web page to display data. Proces žádosti o data automaticky aktivuje vytváření databáze.The process of requesting the data automatically triggers the creation of the database. Zobrazí za přibližně tak, že vytvoříte nový kontroler.You'll begin by creating a new controller. Ale předtím, než to uděláte, sestavte projekt a zpřístupnit třídy modelu a kontextu pro generování uživatelského rozhraní řadiče MVC.But before you do that, build the project to make the model and context classes available to MVC controller scaffolding.

  1. Klikněte pravým tlačítkem na řadiče složky v Průzkumníka řešenívyberte přidata potom klikněte na tlačítko novou vygenerovanou položku.Right-click the Controllers folder in Solution Explorer, select Add, and then click New Scaffolded Item.

  2. V přidat vygenerované uživatelské rozhraní dialogu kontroler MVC 5 se zobrazeními, používá nástroj Entity Frameworka klikněte na tlačítko přidat.In the Add Scaffold dialog box, select MVC 5 Controller with views, using Entity Framework, and then choose Add.

    Přidat dialog vygenerované uživatelské rozhraní v sadě Visual Studio

  3. V přidat kontroler dialogové okno, proveďte následující výběr a klikněte na tlačítko přidat:In the Add Controller dialog box, make the following selections, and then choose Add:

    • Třída modelu: Student (ContosoUniversity.Models).Model class: Student (ContosoUniversity.Models). (Pokud se tato možnost v rozevíracím seznamu nezobrazí, sestavte projekt a zkuste to znovu.)(If you don't see this option in the drop-down list, build the project and try again.)

    • Třída kontextu dat: SchoolContext (ContosoUniversity.DAL).Data context class: SchoolContext (ContosoUniversity.DAL).

    • Název kontroleru: StudentController (ne StudentsController).Controller name: StudentController (not StudentsController).

    • Ponechte výchozí hodnoty pro ostatní pole.Leave the default values for the other fields.

      Po kliknutí na přidat, vytvoří scaffolder StudentController.cs souboru a nastavte zobrazení (.cshtml soubory), které fungují s kontrolerem.When you click Add, the scaffolder creates a StudentController.cs file and a set of views (.cshtml files) that work with the controller. V budoucnu při vytváření projektů, které využívají Entity Framework, můžete taky využít výhod některé další funkce scaffolder: vytvoření vaší první třídy modelu, nevytvářejte připojovací řetězec a pak přidat kontroler pole zadejte nový kontext dat. tak, že vyberete + vedle třída kontextu dat.In the future when you create projects that use Entity Framework, you can also take advantage of some additional functionality of the scaffolder: create your first model class, don't create a connection string, and then in the Add Controller box specify New data context by selecting the + button next to Data context class. Vytvoří scaffolder vaše DbContext třídy a připojení řetězec a také kontroler a zobrazení.The scaffolder will create your DbContext class and your connection string as well as the controller and views.

  4. Visual Studio otevře Controllers\StudentController.cs souboru.Visual Studio opens the Controllers\StudentController.cs file. Uvidíte, že proměnné třídy se vytvořil, který vytvoří instanci objektu kontextu databáze:You see that a class variable has been created that instantiates a database context object:

    private SchoolContext db = new SchoolContext();
    

    Index Metody akce získá seznam studenti z studenty načtením sadu entit Students vlastnost instance kontextu databáze:The Index action method gets a list of students from the Students entity set by reading the Students property of the database context instance:

    public ViewResult Index()
    {
        return View(db.Students.ToList());
    }
    

    Student\Index.cshtml zobrazení seznamu v tabulce:The Student\Index.cshtml view displays this list in a table:

    <table>
        <tr>
            <th>
                @Html.DisplayNameFor(model => model.LastName)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.FirstMidName)
            </th>
            <th>
                @Html.DisplayNameFor(model => model.EnrollmentDate)
            </th>
            <th></th>
        </tr>
    
    @foreach (var item in Model) {
        <tr>
            <td>
                @Html.DisplayFor(modelItem => item.LastName)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.FirstMidName)
            </td>
            <td>
                @Html.DisplayFor(modelItem => item.EnrollmentDate)
            </td>
            <td>
                @Html.ActionLink("Edit", "Edit", new { id=item.ID }) |
                @Html.ActionLink("Details", "Details", new { id=item.ID }) |
                @Html.ActionLink("Delete", "Delete", new { id=item.ID })
            </td>
        </tr>
    }
    
  5. Stiskněte kombinaci kláves Ctrl + F5 ke spuštění projektu.Press Ctrl+F5 to run the project. (Pokud dojde k chybě "Nejde vytvořit stínovou kopii" zavřete prohlížeč a zkuste to znovu.)(If you get a "Cannot create Shadow Copy" error, close the browser and try again.)

    Klikněte na tlačítko studenty kartu pro zobrazení testovacích dat, který Seed metoda vložen.Click the Students tab to see the test data that the Seed method inserted. V závislosti na tom, jak úzké okno prohlížeče, je, uvidíte odkaz karta studenta nejvyšší adresního řádku nebo budete muset klikněte na tlačítko pravém horním rohu na odkaz.Depending on how narrow your browser window is, you'll see the Student tab link in the top address bar or you'll have to click the upper right corner to see the link.

    Tlačítko nabídky

Zobrazení databázeView the database

Když jste spustili na stránce studenty a pokusu o přístup k databázi aplikace, zjistí EF, existuje se žádná databáze a jste jej vytvořili.When you ran the Students page and the application tried to access the database, EF discovered that there was no database and created one. EF pak jste spustili seed – metoda k naplnění databáze s daty.EF then ran the seed method to populate the database with data.

Můžete použít buď Průzkumníka serveru nebo Průzkumník objektů systému SQL Server (SSOX) Chcete-li zobrazit databáze v sadě Visual Studio.You can use either Server Explorer or SQL Server Object Explorer (SSOX) to view the database in Visual Studio. Pro účely tohoto kurzu budete používat Průzkumníka serveru.For this tutorial, you'll use Server Explorer.

  1. Zavřete prohlížeč.Close the browser.

  2. V Průzkumníka serveru, rozbalte datová připojení (budete muset nejprve vyberte tlačítko pro aktualizaci), rozbalte školním kontextu (ContosoUniversity) a potom rozbalte Tabulky zobrazíte tabulek v nové databázi.In Server Explorer, expand Data Connections (you may need to select the refresh button first), expand School Context (ContosoUniversity), and then expand Tables to see the tables in your new database.

  3. Klikněte pravým tlačítkem na Student tabulky a klikněte na tlačítko zobrazit Data tabulky zobrazit sloupce, které byly vytvořeny a řádky, které byly vloženy do tabulky.Right-click the Student table and click Show Table Data to see the columns that were created and the rows that were inserted into the table.

  4. Zavřít Průzkumníka serveru připojení.Close the Server Explorer connection.

ContosoUniversity1.mdf a .ldf databázové soubory jsou v % USERPROFILE % složky.The ContosoUniversity1.mdf and .ldf database files are in the %USERPROFILE% folder.

Vzhledem k tomu, že používáte DropCreateDatabaseIfModelChanges inicializátor, může teď provedete změnu Student třídy, spusťte aplikaci znovu spustit a databáze bude automaticky znovu vytvořit tak, aby odpovídaly změny.Because you're using the DropCreateDatabaseIfModelChanges initializer, you could now make a change to the Student class, run the application again, and the database would automatically be re-created to match your change. Například, pokud chcete přidat EmailAddress vlastnost Student třídy, znovu spusťte stránce studenty a pak pohled na tabulku znovu, zobrazí se vám nový EmailAddress sloupce.For example, if you add an EmailAddress property to the Student class, run the Students page again, and then look at the table again, you'll see a new EmailAddress column.

KonvenceConventions

Množství kódu, které jste měli pro zápis v pořadí pro Entity Framework umožnit vytvoření kompletní databáze je minimální z důvodu konvence, nebo předpokladů, které díky rozhraní Entity Framework.The amount of code you had to write in order for Entity Framework to be able to create a complete database for you is minimal because of conventions, or assumptions that Entity Framework makes. Některé z nich už bylo uvedeno nebo byly použity bez vašeho vědomí:Some of them have already been noted or were used without your being aware of them:

  • Pluralized formy názvy tříd entit se používají jako názvy tabulek.The pluralized forms of entity class names are used as table names.
  • Názvy vlastností entity se používají pro názvy sloupců.Entity property names are used for column names.
  • Vlastnosti entity, které jsou pojmenovány ID nebo classname ID jsou rozpoznány jako vlastnosti primárního klíče.Entity properties that are named ID or classname ID are recognized as primary key properties.
  • Vlastnost je interpretován jako vlastnost cizího klíče, pokud je název <název navigační vlastnosti><vlastnost primárního klíče název> (například StudentID pro Student navigační vlastnost, protože Student je primární klíč entity ID).A property is interpreted as a foreign key property if it's named <navigation property name><primary key property name> (for example, StudentID for the Student navigation property since the Student entity's primary key is ID). Vlastnosti cizího klíče může také být pojmenován stejně jednoduše <vlastnost primárního klíče název> (například EnrollmentID od Enrollment je primární klíč entity EnrollmentID).Foreign key properties can also be named the same simply <primary key property name> (for example, EnrollmentID since the Enrollment entity's primary key is EnrollmentID).

Už víte, že konvence lze přepsat.You've seen that conventions can be overridden. Například jste zadali, že by neměla být pluralized názvy tabulek a později uvidíte, jak lze explicitně označit vlastnost jako vlastnost cizího klíče.For example, you specified that table names shouldn't be pluralized, and you'll see later how to explicitly mark a property as a foreign key property.

Získat kódGet the code

Stáhnout dokončený projektDownload Completed Project

Další zdrojeAdditional resources

Další informace o EF 6 najdete v těchto článcích:For more about EF 6, see these articles:

Další krokyNext steps

V tomto kurzu se naučíte:In this tutorial, you:

  • Vytvoření webové aplikace MVCCreated an MVC web app
  • Nastavit styl lokalitySet up the site style
  • Nainstalované Entity Framework 6Installed Entity Framework 6
  • Vytvoření datového modeluCreated the data model
  • Vytvoří kontext databázeCreated the database context
  • Inicializované databáze se testovací dataInitialized DB with test data
  • Nastavení EF 6 pro použití LocalDBSet up EF 6 to use LocalDB
  • Vytvořený kontroler a zobrazeníCreated controller and views
  • Zobrazení databázeViewed the database

Přejděte k dalším článku se naučíte, jak zkontrolovat a upravit vytvořit, číst, aktualizovat, odstranění (CRUD) kódu v kontrolerů a zobrazení.Advance to the next article to learn how to review and customize the create, read, update, delete (CRUD) code in your controllers and views.