Razor Az Entity Framework Core lapjai a ASP.NET Core-ban – 1. oktatóanyag a 8-ból

Tom Dykstra, Jeremy Likness és Jon P Smith

Ez az első olyan oktatóanyag-sorozat, amely bemutatja, hogyan használható az Entity Framework (EF) Core egy ASP.NET Core Razor Pages-alkalmazásban . Az oktatóanyagok egy kitalált Contoso Egyetem webhelyét készítik el. A webhely olyan funkciókat tartalmaz, mint a diákok felvétele, a kurzus létrehozása és az oktatói feladatok. Az oktatóanyag a kód első megközelítését használja. Az oktatóanyag adatbázis-alapú első megközelítéssel való követéséről a GitHub-probléma nyújt tájékoztatást.

Töltse le vagy tekintse meg a kész alkalmazást.Letöltési utasítások.

Prerequisites

• Ha még csak most ismerkedik a Razor Pages szolgáltatássalRazor, ennek megkezdése előtt tekintse át a Pages használatának első lépéseit ismertető oktatóanyag-sorozatot.

Visual Studio

• Visual Studio 2022 az ASP.NET és webfejlesztési feladatkörrel.

  

Adatbázismotorok

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.

Visual Studio Code

• Visual Studio Code
• C# for Visual Studio Code (legújabb verzió)
• .NET 6 SDK

A Visual Studio Code utasításai a .NET CLI-t használják ASP.NET alapvető fejlesztési függvényekhez, például a projekt létrehozásához. Ezeket az utasításokat macOS, Linux vagy Windows rendszeren és bármilyen kódszerkesztővel követheti. Kisebb módosításokra lehet szükség, ha nem a Visual Studio Code-ot használja.

Fontolja meg egy külső eszköz letöltését és telepítését az SQLite-adatbázisok kezeléséhez és megtekintéséhez, például a DB Browser for SQLite-hez.

Adatbázismotorok

A Visual Studio Code lapon az SQLite, egy platformfüggetlen adatbázismotor található.

Troubleshooting

Ha olyan problémába ütközik, amely nem oldható meg, hasonlítsa össze a kódot a befejezett projektel. Ha segítségre van szüksége, egy kérdést tehet fel a StackOverflow.com-on az ASP.NET Core címkével vagy a EF Core címkével.

A mintaalkalmazá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 az oktatóanyagban létrehozott képernyők közül.

A webhely felhasználói felületének stílusa a beépített projektsablonokon alapul. Az oktatóanyag középpontjában a ASP.NET Core használata EF Core áll, nem pedig a felhasználói felület testreszabása.

Nem kötelező: A mintaletöltés összeállítása

Ez a lépés nem kötelező. A kész alkalmazás létrehozása akkor ajánlott, ha olyan problémákat tapasztal, amelyeket nem tud megoldani. Ha olyan problémába ütközik, amely nem oldható meg, hasonlítsa össze a kódot a befejezett projektel. Letöltési utasítások.

Visual Studio

Válassza ki ContosoUniversity.csproj a projekt megnyitásához.

• Készítse el a projektet.

• A Package Manager-konzolon (PMC) futtassa a következő parancsot:

  Update-Database
  

Visual Studio Code

• Távolítsa el a megjegyzéseket a ContosoUniversity.csproj fájlból, hogy a SQLiteVersion definiálva legyen.

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
    <DefineConstants>TRACE;SQLiteVersion</DefineConstants>
  </PropertyGroup>
  

• Egy parancsablakban frissítse az adatbázist:

  dotnet tool install --global dotnet-ef
  dotnet ef database update
  
  

Note

Alapértelmezés szerint a telepíteni kívánt .NET bináris fájlok architektúrája a jelenleg futó operációsrendszer-architektúrát jelöli. Egy másik operációsrendszer-architektúra megadásához lásd: dotnet tool install , --arch option. További információ: GitHub-probléma dotnet/AspNetCore.Docs #29262.

Futtassa a projektet az adatbázis üzembe helyezése érdekében.

A webalkalmazás-projekt létrehozása

Visual Studio

1. Indítsa el a Visual Studio 2022-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 App, majd a Tovább gombot.

   

3. Az új projekt konfigurálása párbeszédpanelen adja meg ContosoUniversity a Projekt nevét. Fontos a ContosoUniversity projekt neve, beleértve a nagybetűsítésnek való megfelelést is, így a névterek egyeznek a példakód másolása és beillesztése során.

4. Válassza a Következőlehetőséget.

5. A További információk párbeszédpanelen válassza a .NET 6.0 (Hosszú távú támogatás), majd a Létrehozás lehetőséget.

   

Visual Studio Code

• Egy terminálban lépjen arra a mappára, amelyben létre kell hozni a projektmappát.

• Futtassa az alábbi parancsokat egy Razor Pages-projekt létrehozásához és cd az új projektmappába:

  dotnet new webapp -o ContosoUniversity
  cd ContosoUniversity  
  

A webhelystílus beállítása

Másolja és illessze be a következő kódot a Pages/Shared/_Layout.cshtml fájlba:

<!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" asp-append-version="true" />
    <link rel="stylesheet" href="~/ContosoUniversity.styles.css" asp-append-version="true" />
</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-page="/Index">Contoso University</a>
                <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-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-page="/About">About</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-page="/Students/Index">Students</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-page="/Courses/Index">Courses</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-page="/Instructors/Index">Instructors</a>
                        </li>
                        <li class="nav-item">
                            <a class="nav-link text-dark" asp-area="" asp-page="/Departments/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; 2021 - Contoso University - <a asp-area="" asp-page="/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>

Az elrendezésfájl beállítja a webhely fejlécét, élőlábát és menüjét. Az előző kód a következő módosításokat hajtja végre:

• A "ContosoUniversity" minden előfordulását "Contoso Egyetem"-re változtatjuk. Három előfordulás van.
• A Home és Privacy menübejegyzések törlődnek.
• Az Névjegy, Diákok, Kurzusaok, Oktatók és Részlegek bejegyzései hozzá vannak adva.

Ebben Pages/Index.cshtmla fájlban cserélje le a fájl tartalmát a következő kódra:

@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
}

<div class="row mb-auto">
    <div class="col-md-4">
        <div class="row no-gutters border mb-4">
            <div class="col p-4 mb-4 ">
                <p class="card-text">
                    Contoso University is a sample application that
                    demonstrates how to use Entity Framework Core in an
                    ASP.NET Core Razor Pages web app.
                </p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="row no-gutters border mb-4">
            <div class="col p-4 d-flex flex-column position-static">
                <p class="card-text mb-auto">
                    You can build the application by following the steps in a series of tutorials.
                </p>
                <p>
@*                    <a href="https://docs.microsoft.com/aspnet/core/data/ef-rp/intro" class="stretched-link">See the tutorial</a>
*@                </p>
            </div>
        </div>
    </div>
    <div class="col-md-4">
        <div class="row no-gutters border mb-4">
            <div class="col p-4 d-flex flex-column">
                <p class="card-text mb-auto">
                    You can download the completed project from GitHub.
                </p>
                <p>
@*                    <a href="https://github.com/dotnet/AspNetCore.Docs/tree/main/aspnetcore/data/ef-rp/intro/samples" class="stretched-link">See project source code</a>
*@                </p>
            </div>
        </div>
    </div>
</div>

Az előző kód a ASP.NET Core szövegét az alkalmazás szövegére cseréli.

Futtassa az alkalmazást, hogy megbizonyosodjon a főoldal megjelenéséről.

Az adatmodell

A következő szakaszok létrehoznak egy adatmodellt:

A diákok tetszőleges számú kurzusra regisztrálhatnak, és a kurzusokon tetszőleges számú hallgató regisztrálhat.

A hallgató entitás

• Hozzon létre egy Models mappát a projektmappában.
• Hozzon létre Models/Student.cs a következő kóddal:

  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 lesz az osztálynak megfelelő adatbázistábla elsődleges kulcsoszlopa. Alapértelmezés szerint a EF Core a ID vagy classnameID nevű tulajdonságot elsődleges kulcsként értelmezi. Tehát az Student osztály elsődleges kulcsának automatikusan felismert neve a StudentID. További információ: EF Core - Kulcsok.

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. Ebben az esetben egy EnrollmentsStudent entitás tulajdonsága tartalmazza az Enrollment adott Tanulóhoz kapcsolódó összes entitást. Ha például az adatbázisban egy Tanuló sor két kapcsolódó regisztrációs sortal rendelkezik, a navigációs tulajdonság tartalmazza ezt a Enrollments két regisztrációs entitást.

Az adatbázisban egy regisztrációs sor egy Tanuló sorhoz kapcsolódik, ha az StudentID oszlopa tartalmazza a tanuló azonosítójának értékét. Tegyük fel például, hogy egy Tanuló sor azonosítója=1. A kapcsolódó regisztrációs sorok StudentID egyenlők lesznek 1. StudentID egy idegen kulcs a Regisztrációs táblában.

A Enrollments tulajdonság azért van meghatározva ICollection<Enrollment>, mert több kapcsolódó beiratkozási entitás is lehet. Más gyűjteménytípusok is használhatók, például List<Enrollment> vagy HashSet<Enrollment>. Ha ICollection<Enrollment> van használatban, EF Core alapértelmezés szerint létrehoz egy HashSet<Enrollment> gyűjteményt.

A Regisztrációs entitás

Hozzon létre Models/Enrollment.cs a következő kóddal:

using System.ComponentModel.DataAnnotations;

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; }
        [DisplayFormat(NullDisplayText = "No grade")]
        public Grade? Grade { get; set; }

        public Course Course { get; set; }
        public Student Student { get; set; }
    }
}

A EnrollmentID tulajdonság az elsődleges kulcs; ez az entitás az classnameID mintát használja a ID helyett. Egy éles adatmodell esetében sok fejlesztő választ egy mintát, és következetesen használja azt. Ez az oktatóanyag csak azért használja mindkettőt, hogy szemléltesse, hogy mindkettő működik. A ID nélküli classname használata megkönnyíti az adatmodellek bizonyos módosításainak implementálását.

A Grade tulajdonság egy enum. A típusdeklaráció utáni Grade kérdőjel azt jelzi, hogy a Grade tulajdonság null értékű. A null értékű osztályzat eltér a nulla osztálytól – a null azt jelenti, hogy az osztályzat nem ismert vagy még nincs hozzárendelve.

A StudentID tulajdonság egy idegen kulcs, és a megfelelő navigációs tulajdonság a(z) Student. Egy Enrollment entitás egyetlen Student entitáshoz van társítva, így a tulajdonság egyetlen Student entitást tartalmaz.

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

EF Core a tulajdonságot idegen kulcsként értelmezi, ha el van nevezve <navigation property name><primary key property name>. Például a StudentID idegen kulcsa a Student navigációs tulajdonságnak, mivel az Student entitás elsődleges kulcsa ID. Az idegen kulcs tulajdonságai is elnevezhetők <primary key property name>. Például, mivel az CourseID entitás elsődleges kulcsa Course, ezért CourseID.

A Kurzus entitás

Hozzon létre Models/Course.cs a következő kóddal:

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.

Az DatabaseGenerated attribútum lehetővé teszi, hogy az alkalmazás az adatbázis létrehozása helyett az elsődleges kulcsot adja meg.

Hozza létre az alkalmazást. A fordítóprogram számos figyelmeztetést generál az értékek kezelésének módjáról null . További információkért tekintse meg ezt a GitHub-problémát, a null értékű referenciatípusokat és az oktatóanyagot: A tervezési szándék egyértelműbb kifejezése null értékű és nem null értékű hivatkozástípusokkal .

A null értékű hivatkozástípusok figyelmeztetéseinek eltávolításához távolítsa el a következő sort a ContosoUniversity.csproj fájlból:

<Nullable>enable</Nullable>

Az állványzat generálásához használt motor jelenleg nem támogatja a null értékű referenciatípusokat, ezért a generálás során használt modellek sem.

Távolítsa el a ? nullázható hivatkozástípus annotációját public string? RequestId { get; set; }-ből Pages/Error.cshtml.cs-ben, hogy a projekt fordítói figyelmeztetések nélkül kompilálódjon.

Tanulói oldalak felépítése

Ebben a szakaszban a ASP.NET Core állványozó eszközt használjuk a következő létrehozásához:

• Egy EF CoreDbContext osztály. A környezet az a fő osztály, amely egy adott adatmodell Entity Framework-funkcióit koordinálja. Az Microsoft.EntityFrameworkCore.DbContext osztályból származik.
• Razor lapok, amelyek kezelik az entitás létrehozási, olvasási, frissítési és törlési (CRUD) műveleteit Student.

Visual Studio

• Hozzon létre egy Pages/Students mappát.
• A Megoldáskezelőben kattintson a jobb gombbal a Pages/Students mappára, és válassza azÚj állványozott elem> lehetőséget.
• Az Új állványelem hozzáadása párbeszédpanelen:
  • A bal oldali lapon válassza a Telepített > közös >Razor lapok lehetőséget
  • Válassza ki Razor az Entity Framework (CRUD)>ADD parancsot használó oldalakat.
• Az Razor párbeszédpanelen:
  • A Modellosztály legördülő listában válassza a Student (ContosoUniversity.Models) lehetőséget.
  • Az Adatkörnyezet osztály sorában válassza ki a + (plusz) jelet.
    • Módosítsa az adatkörnyezet nevét úgy, hogy az SchoolContext-ra végződjön, ne pedig ContosoUniversityContext-re. A frissített környezet neve: ContosoUniversity.Data.SchoolContext
    • Válassza a Hozzáadás lehetőséget az adatkörnyezeti osztály hozzáadásának befejezéséhez.
    • Válassza a Hozzáadás lehetőséget a Lapok hozzáadása Razor párbeszédpanel befejezéséhez.

A rendszer automatikusan telepíti a következő csomagokat:

• Microsoft.EntityFrameworkCore.SqlServer
• Microsoft.EntityFrameworkCore.Tools
• Microsoft.VisualStudio.Web.CodeGeneration.Design

Visual Studio Code

• Futtassa a következő .NET CLI-parancsokat a szükséges NuGet-csomagok telepítéséhez:

  dotnet add package Microsoft.EntityFrameworkCore.SQLite
  dotnet add package Microsoft.EntityFrameworkCore.SqlServer
  dotnet add package Microsoft.EntityFrameworkCore.Design
  dotnet add package Microsoft.EntityFrameworkCore.Tools
  dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design
  dotnet add package Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore
  

  A Microsoft.VisualStudio.Web.CodeGeneration.Design csomag az állványzathoz szükséges. Bár az alkalmazás nem használja az SQL Servert, az állványozó eszköznek szüksége van az SQL Server-csomagra.

• Hozzon létre egy Pages/Students mappát.

• Futtassa az alábbi parancsot az aspnet-codegenerator állványozó eszköz telepítéséhez.

  dotnet tool install --global dotnet-aspnet-codegenerator
  
  

• Futtassa a következő parancsot a diákoldalak felállításához.

  Windows rendszeren

  dotnet aspnet-codegenerator razorpage -m Student -dc ContosoUniversity.Data.SchoolContext -udl -outDir Pages\Students --referenceScriptLibraries -sqlite  
  

  MacOS vagy Linux rendszeren

  dotnet aspnet-codegenerator razorpage -m Student -dc ContosoUniversity.Data.SchoolContext -udl -outDir Pages/Students --referenceScriptLibraries -dbProvider sqlite
  

Ha az előző lépés meghiúsul, hozza létre a projektet, és próbálkozzon újra az állványzat lépésével.

Az állványozási folyamat:

• Lapokat hoz létre Razor a Pages/Students mappában:
  • Create.cshtml és Create.cshtml.cs
  • Delete.cshtml és Delete.cshtml.cs
  • Details.cshtml és Details.cshtml.cs
  • Edit.cshtml és Edit.cshtml.cs
  • Index.cshtml és Index.cshtml.cs
• Létrehozza Data/SchoolContext.csa .
• Hozzáadja a környezetet a függőséginjektáláshoz a Program.cs-ben.
• Adatbázis-kapcsolati sztring hozzáadása a fájlhoz appsettings.json.

Adatbázis-kapcsolati karakterlánc

Az állványzatkezelő eszköz létrehoz egy kapcsolati sztringet a appsettings.json fájlban.

Visual Studio

A kapcsolati sztring az SQL Server LocalDB-t adja meg:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "SchoolContext": "Server=(localdb)\\mssqllocaldb;Database=SchoolContext-0e9;Trusted_Connection=True;MultipleActiveResultSets=true"
  }
}

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 alapértelmezés szerint .mdf fájlokat hoz létre a C:/Users/<user> címtárban.

Visual Studio Code

Nevezze át a kapcsolati sztringkulcsot a következőre SchoolContextSQLite , és rövidítse az értéket a következőre CU.db:

{
  "DetailedErrors": true,
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "ConnectionStrings": {
    "SchoolContextSQLite": "Data Source=CU.db"
  },
  "MyMaxModelBindingCollectionSize": "3"
}

Ne módosítsa a könyvtárat anélkül, hogy ellenőrizné annak érvényességét.

A kapcsolati sztringkulcs SchoolContextSQLite átnevezésével a szerzőnek segít fenntartani egy olyan mintát, amely támogatja mind az SQLite-ot, mind az SQL Servert.

Az adatbázis környezeti osztályának frissítése

Az adott adatmodell funkcióit koordináló EF Core fő osztály az adatbázis környezeti osztálya. Az összefüggés a(z) Microsoft.EntityFrameworkCore.DbContext-ból/ből származik. A környezet meghatározza, hogy mely entitások szerepelnek az adatmodellben. Ebben a projektben az osztály neve SchoolContext.

Frissítse Data/SchoolContext.cs a következő kóddal:

using Microsoft.EntityFrameworkCore;
using ContosoUniversity.Models;

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

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

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

Az előző kód az egyes DbSet<Student> Student számról a többes számra DbSet<Student> Students változik. Ha azt szeretné, hogy a Razor Pages-kód egyezzen az új DBSet névvel, végezze el a következő globális módosítást: _context.Student. hoz: _context.Students.

8 előfordulás van.

Mivel egy entitáskészlet több entitást tartalmaz, sok fejlesztő előnyben részesíti a DBSet többes számú tulajdonságneveket.

A kiemelt kód:

• Minden entitáskészlethez létrehoz egy DbSet<TEntity> tulajdonságot. Terminológiában EF Core :
  • Az entitáskészletek általában egy adatbázistáblának felelnek meg.
  • Egy entitás egy táblázati sorának felel meg.
• Hívások OnModelCreating. OnModelCreating:
  • Amikor SchoolContext inicializálva van, de a modell biztonságossá tétele előtt és a környezet inicializálására való használat előtt van meghívva.
  • Erre azért van szükség, mert az oktatóanyag későbbi részében az Student entitás hivatkozásokkal fog rendelkezni a többi entitásra.

Reméljük, hogy egy későbbi kiadásban kijavítjuk ezt a problémát .

Program.cs

ASP.NET Core függőséginjektálással készült. Az olyan szolgáltatások, mint a SchoolContext függőséginjektálással regisztrálva vannak az alkalmazás indításakor. Azoknak az összetevőknek, amelyek ezeket a szolgáltatásokat igénylik, például Razor oldalak, a szolgáltatásokat konstruktorparamétereken keresztül biztosítjuk. Az adatbázis-környezetpéldányt lekérő konstruktorkód később jelenik meg az oktatóanyagban.

Az állványzat-kezelő eszköz automatikusan regisztrálta a környezeti osztályt a függőséginjektálási tárolóval.

Visual Studio

Az állványzat a következő kiemelt vonalakat adta hozzá:

using ContosoUniversity.Data;
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

builder.Services.AddDbContext<SchoolContext>(options =>
  options.UseSqlServer(builder.Configuration.GetConnectionString("SchoolContext")));

Visual Studio Code

Ellenőrizze a scaffolder-hívások UseSqliteáltal hozzáadott kódot.

using Microsoft.EntityFrameworkCore;
using ContosoUniversity.Data;
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

builder.Services.AddDbContext<SchoolContext>(options =>
    options.UseSqlite(builder.Configuration.GetConnectionString("SchoolContextSQLite")));

Az éles adatbázis használatával kapcsolatos információkért lásd: SQLite használata fejlesztéshez, SQL Server éles környezetben .

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

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

Adja hozzá a AddDatabaseDeveloperPageExceptionFilter és UseMigrationsEndPoint címkéket a következő kódban látható módon:

Visual Studio

using ContosoUniversity.Data;
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

builder.Services.AddDbContext<SchoolContext>(options =>
  options.UseSqlServer(builder.Configuration.GetConnectionString("SchoolContext")));

builder.Services.AddDatabaseDeveloperPageExceptionFilter();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}
else
{
    app.UseDeveloperExceptionPage();
    app.UseMigrationsEndPoint();
}

Adja hozzá a Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore NuGet csomagot.

A Csomagkezelő konzolon adja meg a következőket a NuGet-csomag hozzáadásához:

Install-Package Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore

Visual Studio Code

using Microsoft.EntityFrameworkCore;
using ContosoUniversity.Data;
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

builder.Services.AddDbContext<SchoolContext>(options =>
    options.UseSqlite(builder.Configuration.GetConnectionString("SchoolContextSQLite")));

builder.Services.AddDatabaseDeveloperPageExceptionFilter();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}
else
{
    app.UseDeveloperExceptionPage();
    app.UseMigrationsEndPoint();
}

A Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore NuGet-csomag ASP.NET Core köztes szoftvereket biztosít az Entity Framework Core hibaoldalaihoz. Ez a köztes szoftver segít az Entity Framework Core migrálásával kapcsolatos hibák észlelésében és diagnosztizálásában.

Az AddDatabaseDeveloperPageExceptionFilter megadja a hasznos hibainformációkat az EF-migrálási hibákhoz a fejlesztési környezetben.

Az adatbázis létrehozása

Frissítse Program.cs, hogy létrehozza az adatbázist, ha az nem létezik.

Visual Studio

using ContosoUniversity.Data;
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

builder.Services.AddDbContext<SchoolContext>(options =>
  options.UseSqlServer(builder.Configuration.GetConnectionString("SchoolContext")));

builder.Services.AddDatabaseDeveloperPageExceptionFilter();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}
else
{
    app.UseDeveloperExceptionPage();
    app.UseMigrationsEndPoint();
}

using (var scope = app.Services.CreateScope())
{
    var services = scope.ServiceProvider;

    var context = services.GetRequiredService<SchoolContext>();
    context.Database.EnsureCreated();
    // DbInitializer.Initialize(context);
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();

Visual Studio Code

using Microsoft.EntityFrameworkCore;
using ContosoUniversity.Data;
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

builder.Services.AddDbContext<SchoolContext>(options =>
    options.UseSqlite(builder.Configuration.GetConnectionString("SchoolContextSQLite")));

builder.Services.AddDatabaseDeveloperPageExceptionFilter();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}
else
{
    app.UseDeveloperExceptionPage();
    app.UseMigrationsEndPoint();
}

using (var scope = app.Services.CreateScope())
{
    var services = scope.ServiceProvider;

    var context = services.GetRequiredService<SchoolContext>();
    context.Database.EnsureCreated();
    // DbInitializer.Initialize(context);
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();

app.Run();

A EnsureCreated metódus nem hajt végre semmilyen műveletet, ha létezik adatbázis a környezethez. Ha nincs adatbázis, létrehozza az adatbázist és a sémát. EnsureCreated lehetővé teszi a következő munkafolyamatot az adatmodell-módosítások kezeléséhez:

• Törölje az adatbázist. A meglévő adatok elvesznek.
• Módosítsa az adatmodellt. Például vegyen fel egy EmailAddress mezőt.
• Nyisd meg az alkalmazást.
• EnsureCreated létrehoz egy adatbázist az új sémával.

Ez a munkafolyamat a fejlesztés korai szakaszában működik, amikor a séma gyorsan fejlődik, feltéve, hogy az adatokat nem kell megőrizni. A helyzet más, ha az adatbázisba beírt adatokat meg kell őrizni. Ilyen esetben használjon migrálást.

Az oktatóanyag-sorozat későbbi részében törlésre kerül az adatbázis, amelyet EnsureCreated hozott létre, és a migrációk kerülnek alkalmazásra. A létrehozott EnsureCreated adatbázisok áttelepítéssel nem frissíthetők.

Az alkalmazás tesztelése

• Nyisd meg az alkalmazást.
• Válassza a Diákok hivatkozást, majd az Új létrehozása lehetőséget.
• Tesztelje a Szerkesztés, a Részletek és a Törlés hivatkozásokat.

Az adatbázis üzembe helyezése

A EnsureCreated metódus üres adatbázist hoz létre. Ez a szakasz olyan kódot ad hozzá, amely tesztadatokkal tölti fel az adatbázist.

Hozzon létre Data/DbInitializer.cs a következő kóddal:

using ContosoUniversity.Models;

namespace ContosoUniversity.Data
{
    public static class DbInitializer
    {
        public static void Initialize(SchoolContext context)
        {
            // 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("2019-09-01")},
                new Student{FirstMidName="Meredith",LastName="Alonso",EnrollmentDate=DateTime.Parse("2017-09-01")},
                new Student{FirstMidName="Arturo",LastName="Anand",EnrollmentDate=DateTime.Parse("2018-09-01")},
                new Student{FirstMidName="Gytis",LastName="Barzdukas",EnrollmentDate=DateTime.Parse("2017-09-01")},
                new Student{FirstMidName="Yan",LastName="Li",EnrollmentDate=DateTime.Parse("2017-09-01")},
                new Student{FirstMidName="Peggy",LastName="Justice",EnrollmentDate=DateTime.Parse("2016-09-01")},
                new Student{FirstMidName="Laura",LastName="Norman",EnrollmentDate=DateTime.Parse("2018-09-01")},
                new Student{FirstMidName="Nino",LastName="Olivetto",EnrollmentDate=DateTime.Parse("2019-09-01")}
            };

            context.Students.AddRange(students);
            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}
            };

            context.Courses.AddRange(courses);
            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},
            };

            context.Enrollments.AddRange(enrollments);
            context.SaveChanges();
        }
    }
}

A kód ellenőrzi, hogy vannak-e diákok az adatbázisban. Ha nincsenek diákok, tesztadatokat ad hozzá az adatbázishoz. A teljesítmény optimalizálása érdekében gyűjtemények helyett List<T> tömbökben hozza létre a tesztadatokat.

• A Program.cs-ban távolítsa el a // a DbInitializer.Initialize sorból.

using (var scope = app.Services.CreateScope())
{
    var services = scope.ServiceProvider;

    var context = services.GetRequiredService<SchoolContext>();
    context.Database.EnsureCreated();
    DbInitializer.Initialize(context);
}

Visual Studio

• Állítsa le az alkalmazást, ha fut, és futtassa a következő parancsot a Package Manager-konzolon (PMC):

  Drop-Database -Confirm
  
  

• A Y megadásával válaszoljon az adatbázis törlésére.

Visual Studio Code

• Állítsa le az alkalmazást, ha fut, és törölje a CU.db fájlt.

• Indítsa újra az alkalmazást.
• Válassza a Diákok lapot a beválogatott adatok megtekintéséhez.

Az adatbázis megtekintése

Visual Studio

• Nyissa meg az SQL Server Object Explorert (SSOX) a Visual Studio Nézet menüjében.
• Az SSOX-ban válassza a (localdb)\MSSQLLocalDB > Databases > SchoolContext-{GUID} lehetőséget. Az adatbázis neve a korábban megadott környezetnévből, valamint egy kötőjelből és egy GUID-ból jön létre.
• Bontsa ki a Táblák csomópontot.
• Kattintson a jobb gombbal a Student táblára, és kattintson az Adatok megtekintése parancsra a létrehozott oszlopok és a táblázatba beszúrt sorok megtekintéséhez.
• Kattintson a jobb gombbal a Student táblára, és kattintson a Kód megtekintése parancsra annak megtekintéséhez, hogy a Student modell hogyan képezi le a Student táblázatsémát.

Visual Studio Code

SQLite-eszközzel megtekintheti az adatbázissémát és a beszúrt adatokat. Az adatbázisfájl neve CU.db a projektmappában található.

Aszinkron EF-metódusok ASP.NET Core-webalkalmazásokban

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 nem dolgoznak, 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ó késedelem nélkül képes több forgalmat kezelni.

Az aszinkron kód futásidőben kis mennyiségű többletterhelést vezet be. Alacsony forgalmú helyzetekben a teljesítménycsökkenés elhanyagolható, míg nagy forgalmú helyzetekben jelentős mértékben javulhat a teljesítmény.

Az alábbi kódban az aszinkron kulcsszó, Task a visszatérési érték, await a kulcsszó és ToListAsync a metódus aszinkron módon hajtja végre a kódot.

public async Task OnGetAsync()
{
    Students = await _context.Students.ToListAsync();
}

• A async kulcsszó az alábbiakra utasítja a fordítót:
  • Visszahívási funkciók létrehozása a metódustörzs különböző részeihez.
  • Hozza létre a visszaadott feladatobjektumot .
• A Task visszatérési típus a folyamatban lévő munkát jelöli.
• 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 .

Aszinkron kód írásakor figyelembe kell venni néhány dolgot, amelyek a következőt használják EF Core:

• 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. Ez magában foglalja ToListAsynca , SingleOrDefaultAsync, FirstOrDefaultAsyncés SaveChangesAsync. Nem tartalmaz olyan utasításokat, amelyek csak módosítanak egy olyan utasítást IQueryable, mint például var students = context.Students.Where(s => s.LastName == "Davolio").
• A EF Core környezetek nem biztonságosak a szálon: ne próbálkozzon több művelettel párhuzamosan.
• Az aszinkron kód teljesítménybeli előnyeinek kihasználásához ellenőrizze, hogy a kódtárcsomagok (például a lapozás) aszinkront használnak-e, ha lekérdezéseket küldő metódusokat hívnak EF Core az adatbázisba.

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

Warning

A Microsoft.Data.SqlClient aszinkron implementációjának ismert problémái vannak (#593, #601 és mások). Ha váratlan teljesítménnyel kapcsolatos problémákat tapasztal, próbálkozzon inkább a szinkronizálási parancs végrehajtásával, különösen nagy szöveges vagy bináris értékek kezelésekor.

Teljesítménnyel kapcsolatos szempontok

Általánosságban elmondható, hogy egy weblapnak nem szabad tetszőleges számú sort betöltenie. Egy lekérdezésnek lapozást vagy korlátozási módszert kell használnia. Az előző lekérdezés például a visszaadott sorok korlátozására használható Take :

public async Task OnGetAsync()
{
    Student = await _context.Students.Take(10).ToListAsync();
}

Egy nagy tábla nézetben való enumerálása részben létrehozott HTTP 200 válaszhoz vezethet, ha az adatbázis-kivétel az enumerálás közben bekövetkezik.

A lapozásról az oktatóanyag későbbi részében lesz szó.

További információkért tekintse meg a teljesítményre vonatkozó szempontokat (EF).

Következő lépések

Használja az SQLite-ot fejlesztéshez, az SQL Servert pedig éles környezetben

Következő oktatóanyag