Oktatóanyag: Első lépések EF Core egy ASP.NET MVC-webalkalmazásban

Tom Dykstra és Rick Anderson

Ez az oktatóanyag ASP.NET Core MVC-t és Entity Framework Core-t tanít vezérlőkkel és nézetekkel. Razor A Pages egy alternatív programozási modell. Az új fejlesztéshez javasoljuk Razor a Pages over MVC vezérlőkkel és nézetekkel való használatát. Tekintse meg az Razor oktatóanyag Pages-verzióját . Minden oktatóanyag tartalmaz néhány anyagot, a másik nem:

Néhány dolog, ami az MVC-oktatóanyagban található, de a Razor Pages-oktatóanyagban nem:

• Öröklés megvalósítása az adatmodellben
• Nyers SQL-lekérdezések végrehajtása
• A dinamikus LINQ használata a kód leegyszerűsítéséhez

Olyan dolgok, amelyeket a Razor Pages oktatóanyag tartalmaz, de ez nem:

• Kapcsolódó adatok betöltése a Select metódussal
• Ajánlott gyakorlatok az EF-hez.

A Contoso Egyetem minta webalkalmazása bemutatja, hogyan hozhat létre ASP.NET Core MVC-webalkalmazást az Entity Framework (EF) Core és a Visual Studio használatával.

A mintaalkalmazás egy kitalált Contoso Egyetem webhelye. Olyan funkciókat tartalmaz, mint a diákok felvétele, a kurzus létrehozása és az oktatói feladatok. Ez az első olyan oktatóanyag-sorozat, amely ismerteti a Contoso Egyetem mintaalkalmazásának összeállítását.

Prerequisites

• Ha még nem ismeri ASP.NET Core MVC-t, ennek megkezdése előtt tekintse át a ASP.NET Core MVC oktatóanyag-sorozat első lépéseit.

• Visual Studio 2022 az ASP.NET és webfejlesztési feladatokkal.
• .NET 6 SDK

Ez az oktatóanyag nem frissült a .NET 6-os vagy újabb ASP.NET Core-hoz. Az oktatóanyag utasításai nem fognak megfelelően működni, ha olyan projektet hoz létre, amely a .NET 6-os vagy újabb verziójában ASP.NET Core-t célozza. A .NET 6-os vagy újabb websablonokban a ASP.NET Core például a minimális üzemeltetési modellt használja, amely egyetlen Startup.cs fájlba egyesülProgram.cs.Program.cs

A .NET 6-ban bevezetett másik különbség az NRT (null értékű referenciatípusok) funkció. A projektsablonok alapértelmezés szerint engedélyezik ezt a funkciót. Problémák akkor fordulhatnak elő, ha az EF a .NET 6-ban kötelezőnek tekint egy tulajdonságot, amely a .NET 5-ben null értékű. A Diák létrehozása lap például csendesen meghiúsul, kivéve, ha a Enrollments tulajdonság null értékűvé teszik, vagy a asp-validation-summary segédcímke ModelOnly-ről All-re módosul.

Javasoljuk, hogy az oktatóanyaghoz telepítse és használja a .NET 5 SDK-t. Az oktatóanyag frissítéséig tekintse meg Razor az Entity Framework Core lapjait a ASP.NET Core-ban – 1/8. oktatóanyag az Entity Framework és ASP.NET Core használatáról a .NET 6-os vagy újabb verzióiban.

Database engines

A Visual Studio utasításai az SQL Server LocalDB-t, az SQL Server Express csak Windows rendszeren futó verzióját használják.

Problémák megoldása és hibaelhárítás

Ha olyan problémába ütközik, amelyet nem tud megoldani, általában úgy találja meg a megoldást, hogy összehasonlítja a kódot a befejezett projektel. A gyakori hibák listáját és azok megoldását a sorozat utolsó oktatóanyagának Hibaelhárítás szakaszában találja. Ha nem találja meg, amire szüksége van, feltehet egy kérdést a StackOverflow.com-ra ASP.NET Core-hoz vagy EF Core.

Tip

Ez egy 10 oktatóanyagból álló sorozat, amelyek mindegyike a korábbi oktatóanyagokban leírtakra épül. Érdemes lehet menteni a projekt másolatát minden sikeres oktatóanyag befejezése után. Ezután, ha problémákba ütközik, az előző oktatóanyagtól kezdve kezdheti el ahelyett, hogy visszatér az egész sorozat elejére.

Contoso University webalkalmazás

Az oktatóanyagokban beépített alkalmazás egy alapszintű egyetemi webhely.

A felhasználók megtekinthetik és frissíthetik a diákok, a kurzusok és az oktatók adatait. Íme néhány képernyő az alkalmazásban:

Webalkalmazás létrehozása

1. Indítsa el a Visual Studiót, és válassza az Új projekt létrehozása lehetőséget.
2. Az Új projekt létrehozása párbeszédpanelen válassza a ASP.NET Core Web Application Next lehetőséget>.
3. Az új projekt konfigurálása párbeszédpanelen adja meg ContosoUniversity a Projekt nevét. Fontos, hogy pontosan ezt a nevet, beleértve a nagybetűsítést is, használja, így a kód másolásakor minden namespace egyezik.
4. Select Create.
5. Az Új ASP.NET Core-webalkalmazás létrehozása párbeszédpanelen válassza a következőt:
   1. .NET Core és ASP.NET Core 5.0 a legördülő menükben.
   2. ASP.NET Core Web App (Model-View-Controller).
   3. 

A webhelystílus beállítása

Néhány alapvető módosítás a webhely menüjét, elrendezését és kezdőlapját állítja be.

Nyissa meg Views/Shared/_Layout.cshtml, és végezze el a következő módosításokat:

• Cserélje le az összes ContosoUniversity előfordulást Contoso University-re. Három előfordulás van.
• Adja hozzá a Névjegy, Diákok, Kurzusok, Oktatók és Részlegek menüpontokat, és törölje a Privacy menübejegyzést.

Az előző módosítások a következő kódban vannak kiemelve:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>@ViewData["Title"] - Contoso University</title>
    <link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.css" />
    <link rel="stylesheet" href="~/css/site.css" />
</head>
<body>
    <header>
        <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
            <div class="container">
                <a class="navbar-brand" asp-area="" asp-controller="Home" asp-action="Index">Contoso University</a>
                <button class="navbar-toggler" type="button" data-toggle="collapse" data-target=".navbar-collapse" aria-controls="navbarSupportedContent"
                        aria-expanded="false" aria-label="Toggle navigation">
                    <span class="navbar-toggler-icon"></span>
                </button>
                <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
                    <ul class="navbar-nav flex-grow-1">
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="About">About</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Students" asp-action="Index">Students</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Courses" asp-action="Index">Courses</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Instructors" asp-action="Index">Instructors</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-controller="Departments" asp-action="Index">Departments</a>
                        </li>
                    </ul>
                </div>
            </div>
        </nav>
    </header>
    <div class="container">
        <main role="main" class="pb-3">
            @RenderBody()
        </main>
    </div>

    <footer class="border-top footer text-muted">
        <div class="container">
            &copy; 2020 - Contoso University - <a asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
        </div>
    </footer>
    <script src="~/lib/jquery/dist/jquery.js"></script>
    <script src="~/lib/bootstrap/dist/js/bootstrap.bundle.js"></script>
    <script src="~/js/site.js" asp-append-version="true"></script>
    @await RenderSectionAsync("Scripts", required: false)
</body>
</html>

A(z) Views/Home/Index.cshtml fájl tartalmát cserélje le a következő jelölésre:

@{
    ViewData["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 Core in an
            ASP.NET Core MVC 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 a series of tutorials.</p>
        <p><a class="btn btn-default" href="https://docs.asp.net/en/latest/data/ef-mvc/intro.html">See the tutorial &raquo;</a></p>
    </div>
    <div class="col-md-4">
        <h2>Download it</h2>
        <p>You can download the completed project from GitHub.</p>
        <p><a class="btn btn-default" href="https://github.com/dotnet/AspNetCore.Docs/tree/main/aspnetcore/data/ef-mvc/intro/samples/cu-final">See project source code &raquo;</a></p>
    </div>
</div>

A projekt futtatásához nyomja le a CTRL+F5 billentyűkombinációt, vagy válassza a Futtatás > Indítás hibakeresés nélkül parancsot a menüből. A kezdőlap az oktatóanyagban létrehozott oldalak füleivel jelenik meg.

EF Core NuGet-csomagok

Ez az oktatóanyag AZ SQL Servert használja, a szolgáltatói csomag pedig a Microsoft.EntityFrameworkCore.SqlServer.

Az EF SQL Server-csomag és függőségei, Microsoft.EntityFrameworkCore és Microsoft.EntityFrameworkCore.Relational, futtatási támogatást nyújtanak az EF-hez.

Adja hozzá a Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore NuGet csomagot. A Package Manager-konzolon (PMC) adja meg a következő parancsokat a NuGet-csomagok hozzáadásához:

Install-Package Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.SqlServer

A Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore NuGet-csomag ASP.NET Core köztes szoftvereket biztosít a hibalapokhoz EF Core . Ez a köztes szoftver segít észlelni és diagnosztizálni a migrálással kapcsolatos EF Core hibákat.

A többi elérhető adatbázis-szolgáltatóról EF Coretovábbi információt az Adatbázis-szolgáltatók című témakörben talál.

Az adatmodell létrehozása

Az alkalmazáshoz a következő entitásosztályok jönnek létre:

Az előző entitások a következő kapcsolatokkal rendelkeznek:

• Egy-a-többhöz való kapcsolat Student és Enrollment entitások között. A diákok tetszőleges számú kurzusra regisztrálhatók.
• Egy-a-többhöz való kapcsolat Course és Enrollment entitások között. Egy kurzuson tetszőleges számú hallgató regisztrálhat.

A következő szakaszokban minden entitáshoz létrehozunk egy osztályt.

A hallgató entitás

A Modellek mappában hozza létre az osztályt Student a következő kóddal:

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 ICollection<Enrollment> Enrollments { get; set; }
    }
}

A ID tulajdonság az ebbe az osztályba tartozó adatbázistábla elsődleges kulcs (PK) oszlopa. Alapértelmezés szerint az EF egy ID vagy classnameID nevű tulajdonságot elsődleges kulcsként értelmez. A PK neve lehet például StudentID, nem pedig ID.

A Enrollments tulajdonság egy navigációs tulajdonság. A navigációs tulajdonságok az entitáshoz kapcsolódó egyéb entitásokat is tartalmazzák. Egy EnrollmentsStudent entitás tulajdonsága:

• Az adott entitáshoz Enrollment kapcsolódó összes Student entitást tartalmazza.
• Ha az adatbázis egy adott Student sora két kapcsolódó sorból Enrollment áll:
  • Az Student entitás navigációs tulajdonsága Enrollments tartalmazza ezt a két Enrollment entitást.

Enrollment Sorok tartalmazzák a diák PK-értékét az StudentID idegen kulcs (FK) oszlopában.

Ha egy navigációs tulajdonság több entitást is tartalmazhat:

• A típusnak egy listának kell lennie, például ICollection<T>: , List<T>vagy HashSet<T>.
• Az entitások hozzáadhatók, törölhetők és frissíthetők.

A több-több és az egy-több navigációs kapcsolatok több entitást is tartalmazhatnak. Amikor a ICollection<T> használatban van, az EF alapértelmezés szerint létrehoz egy HashSet<T> gyűjteményt.

A Regisztrációs entitás

A Modellek mappában hozza létre az osztályt Enrollment a következő kóddal:

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 Course Course { get; set; }
        public Student Student { get; set; }
    }
}

A EnrollmentID tulajdonság a PK (primkulcs). Ez az entitás a classnameID mintát használja a ID helyett önmagában. Az Student entitás használta a ID mintát. Egyes fejlesztők inkább egy mintát használnak az adatmodellben. Ebben az oktatóanyagban a változat azt mutatja be, hogy bármelyik minta használható. Egy későbbi oktatóanyag bemutatja, hogyan könnyíti meg az öröklés implementálását az adatmodellben az osztálynév nélküli használat ID .

A Grade tulajdonság egy enum. A ? típusdeklaráció utáni Grade érték azt jelzi, hogy a Grade tulajdonság null értékű. Az olyan osztályzat, amely null, különbözik a nulla osztályzattól. null azt jelenti, hogy az osztályzat nem ismert vagy még nincs hozzárendelve.

A StudentID tulajdonság egy idegen kulcs (FK), és a megfelelő navigációs tulajdonság a Student. Egy Enrollment entitás egyetlen Student entitáshoz van társítva, így a tulajdonság csak egyetlen Student entitást tartalmazhat. Ez eltér a Student.Enrollments navigációs tulajdonságtól, amely több Enrollment entitást is tartalmazhat.

A CourseID tulajdonság egy FK, és a megfelelő navigációs tulajdonság a Course. Egy Enrollment entitás egy Course entitáshoz van társítva.

Az Entity Framework egy tulajdonságot FK-tulajdonságként értelmez, ha az elsődleges kulcstulajdonság neve <navigációs tulajdonságnév><>. Például a StudentID a Student navigációs tulajdonság esetében, mivel az Student entitás PK-ja ID. Az FK-tulajdonságok az elsődleges kulcs tulajdonságának is< nevezhetők>. Például CourseID azért, mert az Course entitás PK-ja CourseID.

A Kurzus entitás

A Modellek mappában hozza létre az osztályt Course a következő kóddal:

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 ICollection<Enrollment> Enrollments { get; set; }
    }
}

A Enrollments tulajdonság egy navigációs tulajdonság. Az Course entitások tetszőleges számú Enrollment entitáshoz kapcsolódhatnak.

A DatabaseGenerated attribútumot egy későbbi oktatóanyag ismerteti. Ez az attribútum lehetővé teszi a kurzus PK-jának megadását az adatbázis létrehozása helyett.

Az adatbázis-környezet létrehozása

Az adott adatmodell EF-funkcióit koordináló fő osztály az DbContext adatbázis környezeti osztálya. Ez az osztály az osztályból Microsoft.EntityFrameworkCore.DbContext származtatva jön létre. A DbContext származtatott osztály határozza meg, hogy mely entitások szerepelnek az adatmodellben. Egyes EF-viselkedések testre szabhatók. Ebben a projektben az osztály neve SchoolContext.

A projektmappában hozzon létre egy mappát Data.

Az Adatok mappában hozzon létre egy osztályt SchoolContext a következő kóddal:

using ContosoUniversity.Models;
using Microsoft.EntityFrameworkCore;

namespace ContosoUniversity.Data
{
    public class SchoolContext : DbContext
    {
        public SchoolContext(DbContextOptions<SchoolContext> options) : base(options)
        {
        }

        public DbSet<Course> Courses { get; set; }
        public DbSet<Enrollment> Enrollments { get; set; }
        public DbSet<Student> Students { get; set; }
    }
}

Az előző kód minden entitáskészlethez létrehoz egy DbSet tulajdonságot. Ef terminológiában:

• Az entitáskészletek általában egy adatbázistáblának felelnek meg.
• Egy entitás egy táblázati sorának felel meg.

Az DbSet<Enrollment> és DbSet<Course> az utasítások kihagyhatók, és ugyanúgy működnek. Az EF implicit módon tartalmazza őket, mert:

• Az Student entitás az entitásra Enrollment hivatkozik.
• Az Enrollment entitás az entitásra Course hivatkozik.

Az adatbázis létrehozásakor az EF olyan táblákat hoz létre, amelyek neve megegyezik a DbSet tulajdonságnevekkel. A gyűjtemények tulajdonnévei általában többes számúak. Például Studentshelyett Student. A fejlesztők nem értik, hogy a táblaneveket pluralizálni kell-e vagy sem. Az oktatóanyagokban az alapértelmezett viselkedés felülírásra kerül egyedi táblanevek megadásával a DbContext. Ehhez adja hozzá az alábbi kiemelt kódot az utolsó DbSet tulajdonság után.

using ContosoUniversity.Models;
using Microsoft.EntityFrameworkCore;

namespace ContosoUniversity.Data
{
    public class SchoolContext : DbContext
    {
        public SchoolContext(DbContextOptions<SchoolContext> options) : base(options)
        {
        }

        public DbSet<Course> Courses { get; set; }
        public DbSet<Enrollment> Enrollments { get; set; }
        public DbSet<Student> Students { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Course>().ToTable("Course");
            modelBuilder.Entity<Enrollment>().ToTable("Enrollment");
            modelBuilder.Entity<Student>().ToTable("Student");
        }
    }
}

Regisztrálja a SchoolContext

ASP.NET Core függőséginjektálást tartalmaz. A szolgáltatások, például az EF-adatbázis környezete, függőséginjektálással vannak regisztrálva az alkalmazás indításakor. Ezeket a szolgáltatásokat igénylő összetevőket, például az MVC-vezérlőket konstruktorparamétereken keresztül biztosítjuk. Az oktatóanyag későbbi részében megjelenik a környezetpéldányt lekérő vezérlőkonstruktorkód.

A SchoolContext szolgáltatásként való regisztrálásához nyissa meg a Startup.cs, és adja hozzá a kiemelt sorokat a ConfigureServices metódushoz.

using ContosoUniversity.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace ContosoUniversity
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext<SchoolContext>(options =>
                options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

            services.AddControllersWithViews();
        }

A kapcsolati sztring nevét a rendszer egy metódus meghívásával továbbítja a környezetnek egy DbContextOptionsBuilder objektumon. A helyi fejlesztéshez a ASP.NET Core konfigurációs rendszer beolvassa a kapcsolati sztringet a appsettings.json fájlból.

Nyissa meg a appsettings.json fájlt, és adjon hozzá egy kapcsolati sztringet az alábbi korrektúra szerint:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=ContosoUniversity1;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}

Az adatbázis kivételszűrőjének hozzáadása

Adja hozzá a AddDatabaseDeveloperPageExceptionFilter elemet a ConfigureServices részhez a következő kódban látható módon:

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<SchoolContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    services.AddDatabaseDeveloperPageExceptionFilter();

    services.AddControllersWithViews();
}

Ez AddDatabaseDeveloperPageExceptionFilter hasznos hibainformációkat nyújt a fejlesztési környezetben.

SQL Server Express LocalDB (helyi adatbáziskezelő szoftver)

A kapcsolati sztring az SQL Server LocalDB-t adja meg. A LocalDB az SQL Server Express Database Engine egyszerűsített verziója, és alkalmazásfejlesztésre, nem éles használatra készült. A LocalDB igény szerint indul el, és felhasználói módban fut, így nincs összetett konfiguráció. Alapértelmezés szerint a LocalDB .mdf DB-fájlokat hoz létre a C:/Users/<user> címtárban.

Adatbázis inicializálása tesztadatokkal

Az EF létrehoz egy üres adatbázist. Ebben a szakaszban hozzáadunk egy metódust, amelyet az adatbázis létrehozása után hívunk meg, hogy tesztadatokkal tölthessünk fel.

A EnsureCreated metódus az adatbázis automatikus létrehozására szolgál. Egy későbbi oktatóanyagban megtudhatja, hogyan kezelheti a modell módosításait a Code First Migrations használatával az adatbázisséma módosításához az adatbázis elvetése és újbóli létrehozása helyett.

Az Adatok mappában hozzon létre egy új osztályt DbInitializer a következő kóddal:

using ContosoUniversity.Models;
using System;
using System.Linq;

namespace ContosoUniversity.Data
{
    public static class DbInitializer
    {
        public static void Initialize(SchoolContext context)
        {
            context.Database.EnsureCreated();

            // Look for any students.
            if (context.Students.Any())
            {
                return;   // DB has been seeded
            }

            var students = new 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")}
            };
            foreach (Student s in students)
            {
                context.Students.Add(s);
            }
            context.SaveChanges();

            var courses = new 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}
            };
            foreach (Course c in courses)
            {
                context.Courses.Add(c);
            }
            context.SaveChanges();

            var enrollments = new 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},
            };
            foreach (Enrollment e in enrollments)
            {
                context.Enrollments.Add(e);
            }
            context.SaveChanges();
        }
    }
}

Az előző kód ellenőrzi, hogy létezik-e az adatbázis:

• Ha az adatbázis nem található;
  • A rendszer létrehozza és betölti a tesztadatokat. A teljesítmény optimalizálása érdekében gyűjtemények helyett List<T> tömbökbe tölti be a tesztadatokat.
• Ha az adatbázis megtalálható, az nem hajt végre műveletet.

Frissítse Program.cs a következő kóddal:

using ContosoUniversity.Data;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;

namespace ContosoUniversity
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var host = CreateHostBuilder(args).Build();

            CreateDbIfNotExists(host);

            host.Run();
        }

        private static void CreateDbIfNotExists(IHost host)
        {
            using (var scope = host.Services.CreateScope())
            {
                var services = scope.ServiceProvider;
                try
                {
                    var context = services.GetRequiredService<SchoolContext>();
                    DbInitializer.Initialize(context);
                }
                catch (Exception ex)
                {
                    var logger = services.GetRequiredService<ILogger<Program>>();
                    logger.LogError(ex, "An error occurred creating the DB.");
                }
            }
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });
    }
}

Program.cs az alkalmazás indításakor a következőket hajtja végre:

• Adatbázis-környezetpéldány lekérése a függőséginjektálási tárolóból.
• Hívja meg a DbInitializer.Initialize metódust.
• Ha a metódus befejeződik, Initialize a következő kódban látható módon dobja el a környezetet:

public static void Main(string[] args)
{
     var host = CreateWebHostBuilder(args).Build();

    using (var scope = host.Services.CreateScope())
    {
        var services = scope.ServiceProvider;
        try
        {
            var context = services.GetRequiredService<SchoolContext>();
            DbInitializer.Initialize(context);
        }
        catch (Exception ex)
        {
            var logger = services.GetRequiredService<ILogger<Program>>();
            logger.LogError(ex, "An error occurred while seeding the database.");
        }
    }

    host.Run();
}

Az alkalmazás első futtatásakor a rendszer létrehozza és betölti az adatbázist tesztadatokkal. Amikor az adatmodell megváltozik:

• Törölje az adatbázist.
• Frissítse a kezdő metódust, és kezdjen újra egy új adatbázissal.

A későbbi oktatóanyagokban az adatbázis az adatmodell módosításakor módosul, törlés és újbóli létrehozás nélkül. Az adatmodell változásakor nem vesznek el adatok.

Vezérlő és nézetek létrehozása

A Visual Studióban a sablonmotor segítségével vegyen fel MVC-vezérlőt és nézeteket, amelyek az EF-et használják az adatok lekérdezésére és mentésére.

A CRUD műveleti metódusok és nézetek automatikus létrehozását állványzatnak nevezzük.

• A Megoldáskezelőben kattintson a jobb gombbal a Controllers mappára, és válassza az Új állványozott elem hozzáadása > lehetőséget.
• Az Állványzat hozzáadása párbeszédpanelen:
  • Válassza ki a nézetekkel rendelkező MVC-vezérlőt az Entity Framework használatával.
  • Click Add. Megjelenik az MVC-vezérlő hozzáadása nézetekkel az Entity Framework használatával párbeszédpanel:
  • A Modell osztályban válassza a Student (Tanuló) lehetőséget.
  • Az Adatkörnyezet osztályban válassza a SchoolContext lehetőséget.
  • Fogadja el az alapértelmezett StudentsController nevet.
  • Click Add.

A Visual Studio állványozási motorja létrehoz egy StudentsController.cs fájlt és egy nézeteket (*.cshtml fájlokat), amelyek együttműködnek a vezérlővel.

Figyelje meg, hogy a vezérlő konstruktorparamétert használ SchoolContext .

namespace ContosoUniversity.Controllers
{
    public class StudentsController : Controller
    {
        private readonly SchoolContext _context;

        public StudentsController(SchoolContext context)
        {
            _context = context;
        }

Az ASP.NET Core függőséginjektálás gondoskodik arról, hogy a SchoolContext példányt a vezérlőbe juttassa. Az Startup osztályban konfigurálta ezt.

A vezérlő egy műveletmetódust Index tartalmaz, amely az adatbázisban lévő összes tanulót megjeleníti. A metódus az adatbázis-környezetpéldány tulajdonságának beolvasásával Students lekéri a diákok listáját a Diákok entitásból:

public async Task<IActionResult> Index()
{
    return View(await _context.Students.ToListAsync());
}

A kód aszinkron programozási elemeit az oktatóanyag későbbi részében ismertetjük.

A Views/Students/Index.cshtml nézetben ez a lista egy táblázatban jelenik meg:

@model IEnumerable<ContosoUniversity.Models.Student>

@{
    ViewData["Title"] = "Index";
}

<h2>Index</h2>

<p>
    <a asp-action="Create">Create New</a>
</p>
<table class="table">
    <thead>
        <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>
    </thead>
    <tbody>
@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>
                <a asp-action="Edit" asp-route-id="@item.ID">Edit</a> |
                <a asp-action="Details" asp-route-id="@item.ID">Details</a> |
                <a asp-action="Delete" asp-route-id="@item.ID">Delete</a>
            </td>
        </tr>
}
    </tbody>
</table>

A projekt futtatásához nyomja le a CTRL+F5 billentyűkombinációt, vagy válassza a Futtatás > Indítás hibakeresés nélkül parancsot a menüből.

A Diákok fülre kattintva megtekintheti a metódus által beszúrt tesztadatokat DbInitializer.Initialize . Attól függően, hogy milyen keskeny a böngészőablak, a lap tetején megjelenik a Students lap hivatkozása, vagy a jobb felső sarokban lévő navigációs ikonra kell kattintania a hivatkozás megjelenítéséhez.

Az adatbázis megtekintése

Az alkalmazás indításakor a DbInitializer.Initialize metódus meghívja a EnsureCreated metódust. Az EF látta, hogy nincs adatbázis:

• Ezért létrehozott egy adatbázist.
• A Initialize metóduskód adatokkal tölti fel az adatbázist.

Az SQL Server Object Explorer (SSOX) használatával megtekintheti az adatbázist a Visual Studióban:

• Válassza az SQL Server Object Explorert a Visual Studio Nézet menüjében.
• Az SSOX-ban válassza a (localdb)\MSSQLLocalDB-adatbázisok > lehetőséget.
• Válassza ki a ContosoUniversity1 bejegyzést az adatbázisnévhez, amely a appsettings.json fájl kapcsolati sztringjében található.
• Bontsa ki a Táblák csomópontot az adatbázis tábláinak megtekintéséhez.

Kattintson a jobb gombbal a Diák táblára, majd az Adatok megtekintése parancsra a táblázat adatainak megtekintéséhez.

Az *.mdf és *.ldf az adatbázisfájlok a C:\Users\<username> mappában találhatók.

Mivel EnsureCreated az alkalmazás indításakor futó inicializáló metódus meghívja, a következőt teheti:

• Módosítsa a Student osztályt.
• Törölje az adatbázist.
• Állítsa le, majd indítsa el az alkalmazást. Az adatbázis automatikusan újra létrejön a módosításnak megfelelően.

Ha például egy EmailAddress tulajdonságot ad hozzá az Student osztályhoz, az újra létrehozott tábla új EmailAddress oszlopa. A nézet nem jeleníti meg az új EmailAddress tulajdonságot.

Conventions

Az EF által a teljes adatbázis létrehozásához írt kód mennyisége minimális az EF által használt konvenciók miatt:

• A tulajdonságok nevei DbSet táblanevekként használatosak. A tulajdonság által DbSet nem hivatkozott entitások esetében az entitásosztálynevek táblanevekként használatosak.
• Az entitástulajdonságok nevei az oszlopnevekhez használatosak.
• Azokat az entitástulajdonságokat, amelyek neve ID vagy classnameID, PK-tulajdonságként ismerik fel.
• A tulajdonság FK tulajdonságként kerül értelmezésre, ha a neve <navigációs tulajdonság neve><PK tulajdonság neve> alakú. Például a StudentID a Student navigációs tulajdonság esetében, mivel az Student entitás PK-ja ID. Az FK-tulajdonságok az elsődleges kulcs tulajdonságának is< nevezhetők>. Például, mivel a EnrollmentID az Enrollment entitás PK-je EnrollmentID.

A hagyományos viselkedés felülírható. Például a táblázatnevek explicit módon megadhatók, ahogyan az oktatóanyag korábbi részében is látható. Az oszlopnevek és bármely tulajdonság beállítható PK-ként vagy FK-ként.

Asynchronous code

Az aszinkron programozás az alapértelmezett mód az ASP.NET Core és EF Core esetében.

A webkiszolgálókon korlátozott számú szál érhető el, és nagy terhelés esetén az összes elérhető szál használatban lehet. Ha ez történik, a kiszolgáló nem tudja feldolgozni az új kéréseket, amíg a szálak fel nem szabadulnak. Szinkron kód esetén előfordulhat, hogy sok szál meg van kötve, miközben valójában nem végeznek semmilyen munkát, mert az I/O befejezésére várnak. Aszinkron kód esetén, amikor egy folyamat az I/O befejezésére vár, a szál felszabadul, hogy a kiszolgáló más kérések feldolgozására használhassa. Ennek eredményeképpen az aszinkron kód lehetővé teszi a kiszolgálói erőforrások hatékonyabb használatát, és a kiszolgáló lehetővé teszi a nagyobb forgalom késleltetés nélküli kezelését.

Az aszinkron kód futásidőben kis mennyiségű többletterhelést okoz, de alacsony forgalmú helyzetekben a teljesítménycsökkenés elhanyagolható, míg a nagy forgalmú helyzetekben a teljesítmény potenciális javulása jelentős lehet.

A következő kódban async, Task<T>, await, és ToListAsync a kódot aszinkron módon hajtják végre.

public async Task<IActionResult> Index()
{
    return View(await _context.Students.ToListAsync());
}

• A async kulcsszó arra utasítja a fordítót, hogy hozzon létre visszahívásokat a metódus törzsének egyes részeihez, és automatikusan hozza létre a Task<IActionResult> visszaadott objektumot.
• A visszatérési típus Task<IActionResult> a folyamatban lévő munkát jelöli a típus IActionResulteredményével.
• A await kulcsszó miatt a fordító két részre osztja a metódust. Az első rész az aszinkron módon elindított művelettel végződik. A második rész egy visszahívási metódusba kerül, amelyet a művelet befejezésekor hívunk meg.
• ToListAsync a bővítménymetódus aszinkron verziója ToList .

Az EF-t használó aszinkron kód írásakor figyelembe kell venni néhány dolgot:

• A rendszer csak azokat az utasításokat hajtja végre aszinkron módon, amelyek lekérdezéseket vagy parancsokat küldenek az adatbázisba. Ebbe beletartozik például a ToListAsync, SingleOrDefaultAsyncés SaveChangesAsynca . Nem tartalmaz például olyan állításokat, amelyek csak módosítanak egy IQueryable, például var students = context.Students.Where(s => s.LastName == "Davolio").
• Az EF-környezetek nem biztonságosak a szálon: ne próbáljanak több műveletet párhuzamosan végrehajtani. Ha bármilyen aszinkron EF-metódust hív meg, mindig használja a kulcsszót await .
• Az aszinkron kód teljesítménybeli előnyeinek kihasználásához győződjön meg arról, hogy a használt kódtárcsomagok aszinkront is használnak, ha meghívnak olyan EF-metódusokat, amelyek lekérdezéseket küldenek az adatbázisba.

A .NET aszinkron programozásával kapcsolatos további információkért lásd: Aszinkron áttekintés.

Beolvasott entitások korlátozása

A lekérdezésből visszaadott entitások számának korlátozásával kapcsolatos információkért tekintse meg a teljesítményre vonatkozó szempontokat .

Az SQL-naplózás az Entity Framework Core-ban

A naplózási konfigurációt általában a Logging fájlok appsettings.{Environment}.json szakasza biztosítja. SQL-utasítások naplózásához adja hozzá "Microsoft.EntityFrameworkCore.Database.Command": "Information" a appsettings.Development.json fájlhoz:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=MyDB-2;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
     ,"Microsoft.EntityFrameworkCore.Database.Command": "Information"
    }
  },
  "AllowedHosts": "*"
}

Az előző JSON esetén az SQL-utasítások megjelennek a parancssorban és a Visual Studio kimeneti ablakában.

További információ: Naplózás a .NET-ben és ASP.NET Core-ban , valamint ez a GitHub-probléma.

Lépjen tovább a következő oktatóanyagra, amelyből megtudhatja, hogyan hajthat végre alapszintű CRUD-műveleteket (létrehozás, olvasás, frissítés, törlés).

Alapszintű CRUD-funkciók implementálása