Razor Páginas com Entity Framework Core no ASP.NET Core - Tutorial 1 de 8

Por Tom Dykstra, Jeremy Likness e Jon P Smith

Este é o primeiro de uma série de tutoriais que mostram como usar o Entity Framework (EF) Core em um aplicativo ASP.NET Core Razor Pages . Os tutoriais criam um site para uma Universidade Contoso fictícia. O site inclui funcionalidades como admissão de alunos, criação de cursos e tarefas de instrutores. O tutorial utiliza a abordagem code first, que prioriza o código. Para obter informações sobre como seguir este tutorial usando a primeira abordagem do banco de dados, consulte este problema do Github.

Transfira ou veja a aplicação concluída.Instruções para download.

Prerequisites

• Se você é novo no Razor Pages, consulte a série de tutoriais Introdução ao Razor Pages antes de iniciar esta.

Estúdio Visual

• Visual Studio 2022 com a carga de trabalho de ASP.NET e desenvolvimento web .

  

Mecanismos de banco de dados

As instruções do Visual Studio usam SQL Server LocalDB, uma versão do SQL Server Express que é executada somente no Windows.

Código do Visual Studio

• Código do Visual Studio
• C# para Visual Studio Code (versão mais recente)
• SDK do .NET 6

As instruções do Visual Studio Code usam a CLI do .NET para ASP.NET funções de desenvolvimento principais, como a criação de projetos. Você pode seguir estas instruções no macOS, Linux ou Windows e com qualquer editor de código. Pequenas alterações podem ser necessárias se você usar algo diferente do Visual Studio Code.

Considere baixar e instalar uma ferramenta de terceiros para gerenciar e exibir um banco de dados SQLite, como o DB Browser for SQLite.

Mecanismos de banco de dados

A guia Código do Visual Studio usa SQLite, um mecanismo de banco de dados de plataforma cruzada.

Troubleshooting

Se você encontrar um problema que não pode resolver, compare seu código com o projeto concluído. Uma boa maneira de obter ajuda é postando uma pergunta para StackOverflow.com, usando a tag ASP.NET Core ou a EF Core tag .

O aplicativo de exemplo

O aplicativo construído nesses tutoriais é um site básico da universidade. Os usuários podem visualizar e atualizar informações de alunos, cursos e instrutores. Aqui estão algumas das telas criadas no tutorial.

Página

O estilo da interface do usuário deste site é baseado nos modelos de projeto internos. O foco do tutorial está em como usar EF Core com o ASP.NET Core, não em como personalizar a interface do usuário.

Opcional: criar o download de exemplo

Esta etapa é opcional. A criação do aplicativo concluído é recomendada quando você tem problemas que não consegue resolver. Se você encontrar um problema que não pode resolver, compare seu código com o projeto concluído. Instruções para download.

Estúdio Visual

Selecione ContosoUniversity.csproj para abrir o projeto.

• Construa o projeto.

• No Console do Gerenciador de Pacotes (PMC), execute o seguinte comando:

  Update-Database
  

Código do Visual Studio

• Remova os comentários do arquivo ContosoUniversity.csproj para que SQLiteVersion seja definido.

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

• Em uma janela de comando, atualize o banco de dados:

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

Note

Por padrão, a arquitetura dos binários do .NET a serem instalados representa a arquitetura do sistema operacional em execução no momento. Para especificar uma arquitetura de sistema operativo diferente, consulte dotnet tool install, opção --arch. Para obter mais informações, consulte o issue do GitHub dotnet/AspNetCore.Docs #29262.

Execute o projeto para semear o banco de dados.

Criar o projeto de aplicativo Web

Estúdio Visual

1. Inicie o Visual Studio 2022 e selecione Criar um novo projeto.

   

2. Na caixa de diálogo Criar um novo projeto , selecione ASP.NET Core Web Appe, em seguida, selecione Seguinte.

   

3. Na caixa de diálogo Configurar o novo projeto, digite ContosoUniversity para nome do projeto. É importante nomear o projeto ContosoUniversity, incluindo a capitalização correspondente, para que os namespaces correspondam quando se copiar e colar código de exemplo.

4. Selecione Avançar.

5. Na caixa de diálogo Informações adicionais, selecione .NET 6.0 (Suporte de longo prazo) e, em seguida, selecione Criar.

   

Código do Visual Studio

• Em um terminal, navegue até a pasta na qual a pasta do projeto deve ser criada.

• Execute os seguintes comandos para criar um Razor projeto Pages e cd na nova pasta do projeto:

  dotnet new webapp -o ContosoUniversity
  cd ContosoUniversity  
  

Configurar o estilo do site

Copie e cole o seguinte código no Pages/Shared/_Layout.cshtml arquivo:

<!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>

O arquivo de layout define o cabeçalho, o rodapé e o menu do site. O código anterior faz as seguintes alterações:

• Substitua cada ocorrência de "ContosoUniversity" por "Contoso University". Há três ocorrências.
• As entradas de menu Home e Privacy são eliminadas.
• As inscrições são adicionadas para Sobre, Alunos, Cursos, Instrutores e Departamentos.

No Pages/Index.cshtml, substitua o conteúdo do arquivo pelo seguinte código:

@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>

O código anterior substitui o texto sobre ASP.NET Core por texto sobre este aplicativo.

Execute o aplicativo para verificar se a página inicial aparece.

O modelo de dados

As seções a seguir criam um modelo de dados:

Um aluno pode se inscrever em qualquer número de cursos, e um curso pode ter qualquer número de alunos matriculados nele.

A entidade estudantil

• Crie uma pasta Modelos na pasta do projeto.
• Crie Models/Student.cs com o seguinte código:

  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 propriedade se torna a coluna de chave primária da tabela de banco de dados que corresponde a essa classe. Por padrão, EF Core interpreta uma propriedade nomeada ID ou classnameID como a chave primária. Portanto, o nome alternativo reconhecido automaticamente para a chave primária da Student classe é StudentID. Para mais informações, consulte EF Core - Chaves.

A propriedade Enrollments é uma propriedade de navegação . As propriedades de navegação mantêm outras entidades que estão associadas a esta entidade. Neste caso, a Enrollments propriedade de uma Student entidade detém todas as Enrollment entidades que estão relacionadas com esse Aluno. Por exemplo, se uma linha Estudante no banco de dados tiver duas linhas de Inscrição relacionadas, a Enrollments propriedade de navegação conterá essas duas entidades de Inscrição.

No banco de dados, uma linha Inscrição estará relacionada a uma linha Aluno se sua StudentID coluna contiver o valor de ID do aluno. Por exemplo, suponha que uma linha Student tenha ID=1. As linhas de inscrição relacionadas terão StudentID = 1. StudentID é uma chave estrangeira na tabela Inscrição.

A Enrollments propriedade é definida como ICollection<Enrollment> porque pode haver várias entidades de Registro relacionadas. Outros tipos de coleção podem ser usados, como List<Enrollment> ou HashSet<Enrollment>. Quando ICollection<Enrollment> é usado, EF Core cria uma HashSet<Enrollment> coleção por padrão.

A entidade de Inscrição

Crie Models/Enrollment.cs com o seguinte código:

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 propriedade é a chave primária, esta entidade usa o classnameID padrão em vez de ID por si só. Para um modelo de dados de produção, muitos desenvolvedores escolhem um padrão e o usam de forma consistente. Este tutorial usa ambos apenas para ilustrar que ambos funcionam. O uso ID sem classname facilita a implementação de alguns tipos de alterações no modelo de dados.

A propriedade Grade é um enum. O ponto de interrogação após a declaração de Grade tipo indica que a Grade propriedade é anulável. Uma nota nula é diferente de uma nota zero — nula significa que uma nota não é conhecida ou ainda não foi atribuída.

A propriedade StudentID é uma chave estrangeira e a propriedade de navegação correspondente é Student. Uma Enrollment entidade está associada a uma Student entidade, portanto, a propriedade contém uma única Student entidade.

A propriedade CourseID é uma chave estrangeira e a propriedade de navegação correspondente é Course. Uma entidade Enrollment está associada a uma entidade Course.

EF Core interpreta uma propriedade como uma chave estrangeira se ela for nomeada <navigation property name><primary key property name>. Por exemplo,StudentID é a chave estrangeira para Student propriedade de navegação, visto que a chave primária da entidade Student é ID. As propriedades da chave estrangeira também podem ser nomeadas <primary key property name>. Por exemplo, CourseID desde que a Course chave primária da entidade seja CourseID.

A entidade do Curso

Crie Models/Course.cs com o seguinte código:

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 propriedade Enrollments é uma propriedade de navegação. Uma entidade Course pode estar relacionada com qualquer número de entidades Enrollment.

O DatabaseGenerated atributo permite que o aplicativo especifique a chave primária em vez de fazer com que o banco de dados a gere.

Crie o aplicativo. O compilador gera vários avisos sobre como null valores são tratados. Consulte este problema do GitHub, Tipos de referência anuláveis e Tutorial: Expresse sua intenção de design mais claramente com tipos de referência anuláveis e não anuláveis para obter mais informações.

Para eliminar os avisos de tipos de referência anuláveis, remova a seguinte linha do arquivo ContosoUniversity.csproj:

<Nullable>enable</Nullable>

O motor de andaimes atualmente não suporta tipos de referência anuláveis, portanto, os modelos usados em andaimes também não podem.

Remova a anotação de tipo de referência anulável de ? em public string? RequestId { get; set; } para que o projeto seja compilado sem avisos do compilador.

Páginas de apoio ao estudante

Nesta seção, a ferramenta de andaime ASP.NET Core é usada para gerar:

• Uma EF CoreDbContext aula. O contexto é a classe principal que coordena a funcionalidade do Entity Framework para um determinado modelo de dados. Deriva da Microsoft.EntityFrameworkCore.DbContext classe.
• Razor páginas que executam operações de Criar, Ler, Atualizar e Excluir (CRUD) para entidade Student.

Estúdio Visual

• Crie uma pasta Páginas/Alunos .
• No Gerenciador de Soluções, clique com o botão direito do mouse na pasta Páginas/Alunos e selecione Adicionar>Novo Item de Andaime.
• Na caixa de diálogo Adicionar Novo Item de Andaime :
  • Na guia à esquerda, selecione Páginas comuns >> instaladas Razor
  • Selecione Razor Páginas usando o Entity Framework (CRUD)>ADD.
• Na caixa de diálogo Adicionar Razor páginas usando o Entity Framework (CRUD):
  • Na lista suspensa Classe modelo, selecione Estudante (ContosoUniversity.Models).
  • Na linha da classe de contexto de dados, selecione o sinal de + (mais).
    • Altere o nome do contexto de dados para terminar em SchoolContext vez de ContosoUniversityContext. O nome de contexto atualizado: ContosoUniversity.Data.SchoolContext
    • Selecione Adicionar para concluir a adição da classe de contexto de dados.
    • Selecione Adicionar para concluir a caixa de diálogo Adicionar Razor páginas .

Os seguintes pacotes são instalados automaticamente:

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

Código do Visual Studio

• Execute os seguintes comandos da CLI do .NET para instalar os pacotes NuGet necessários:

  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 embalagem é necessária para andaimes. Embora o aplicativo não use o SQL Server, a ferramenta de andaime precisa do pacote do SQL Server.

• Crie uma pasta Páginas/Alunos .

• Execute o seguinte comando para instalar a ferramenta de geração de código aspnet-codegenerator.

  dotnet tool install --global dotnet-aspnet-codegenerator
  
  

• Execute o seguinte comando para gerar estrutura nas páginas dos estudantes.

  No Windows

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

  No macOS ou Linux

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

Se a etapa anterior falhar, construa o projeto e tente novamente a etapa do andaime.

O processo de andaime:

• Cria Razor páginas na pasta Páginas/Alunos :
  • Create.cshtml e Create.cshtml.cs
  • Delete.cshtml e Delete.cshtml.cs
  • Details.cshtml e Details.cshtml.cs
  • Edit.cshtml e Edit.cshtml.cs
  • Index.cshtml e Index.cshtml.cs
• Cria Data/SchoolContext.cs.
• Adiciona o contexto à injeção de dependência no Program.cs.
• Adiciona uma cadeia de conexão de banco de dados ao appsettings.json.

Cadeia de conexão de banco de dados

A ferramenta de andaime gera uma cadeia de conexão no appsettings.json arquivo.

Estúdio Visual

A cadeia de conexão especifica o SQL Server LocalDB:

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

O LocalDB é uma versão leve do Mecanismo de Banco de Dados do SQL Server Express e destina-se ao desenvolvimento de aplicativos, não ao uso em produção. Por padrão, o LocalDB cria .mdf arquivos no C:/Users/<user> diretório.

Código do Visual Studio

Renomeie a chave da cadeia de conexão para SchoolContextSQLite e reduza o valor para CU.db:

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

Não altere o diretório sem se certificar de que é válido.

Renomear a chave da cadeia de conexão para SchoolContextSQLite ajudar o autor a manter um exemplo que ofereça suporte ao SQLlite e ao SQL Server.

Atualizar a classe de contexto do banco de dados

A classe principal que coordena a EF Core funcionalidade para um determinado modelo de dados é a classe de contexto do banco de dados. O contexto é derivado de Microsoft.EntityFrameworkCore.DbContext. O contexto especifica quais entidades são incluídas no modelo de dados. Neste projeto, a classe é chamada SchoolContext.

Atualize Data/SchoolContext.cs com o seguinte código:

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

O código anterior muda do singular DbSet<Student> Student para o plural DbSet<Student> Students. Para fazer com que o código das Razor Páginas corresponda ao novo DBSet nome, faça uma alteração global a partir de: _context.Student. Para: _context.Students.

São 8 ocorrências.

Como um conjunto de entidades contém várias entidades, muitos desenvolvedores preferem que os nomes de propriedade DBSet sejam plurais.

O código destacado:

• Cria uma DbSet<TEntity> propriedade para cada conjunto de entidades. Na EF Core terminologia:
  • Um conjunto de entidades normalmente corresponde a uma tabela de banco de dados.
  • Uma entidade corresponde a uma linha na tabela.
• Chamadas OnModelCreating. OnModelCreating:
  • É chamado quando SchoolContext foi inicializado, mas antes que o modelo tenha sido protegido e usado para inicializar o contexto.
  • É obrigatório porque posteriormente no tutorial a Student entidade terá referências às outras entidades.

Esperamos corrigir esse problema em uma versão futura.

Program.cs

ASP.NET Core é construído com injeção de dependência. Serviços como o SchoolContext são registados com injeção de dependência durante a inicialização da aplicação. Os componentes que requerem esses serviços, como as Razor páginas, têm esses serviços disponibilizados através de parâmetros do construtor. O código do construtor que obtém uma instância de contexto de banco de dados é mostrado posteriormente no tutorial.

A ferramenta de andaime registrou automaticamente a classe de contexto com o contêiner de injeção de dependência.

Estúdio Visual

O andaime adicionou as seguintes linhas destacadas:

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")));

Código do Visual Studio

Verifique o código adicionado pelo gerador de estrutura chamadas UseSqlite.

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")));

Consulte Usar SQLite para desenvolvimento, SQL Server para produção para obter informações sobre como usar um banco de dados de produção.

O nome da cadeia de conexão é passado para o contexto chamando um método em um objeto DbContextOptions. Para o desenvolvimento local, o sistema de configuração ASP.NET Core lê a cadeia de conexão do arquivo appsettings.json ou do arquivo appsettings.Development.json.

Adicionar o filtro de exceção do banco de dados

Adicionar AddDatabaseDeveloperPageExceptionFilter e UseMigrationsEndPoint como mostrado no código a seguir:

Estúdio Visual

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

Adicione o pacote NuGet Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.

No Console do Gerenciador de Pacotes, digite o seguinte para adicionar o pacote NuGet:

Install-Package Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore

Código do Visual Studio

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

O Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore pacote NuGet fornece middleware ASP.NET Core para páginas de erro do Entity Framework Core. Esse middleware ajuda a detetar e diagnosticar erros com migrações do Entity Framework Core.

O AddDatabaseDeveloperPageExceptionFilter fornece informações úteis sobre erros no ambiente de desenvolvimento para erros de migrações do Entity Framework.

Criar a base de dados

Atualize Program.cs para criar o banco de dados se ele não existir:

Estúdio Visual

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

Código do Visual Studio

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

O EnsureCreated método não executa nenhuma ação se existir um banco de dados para o contexto. Se nenhum banco de dados existir, ele criará o banco de dados e o esquema. EnsureCreated Permite o seguinte fluxo de trabalho para lidar com alterações de modelo de dados:

• Exclua o banco de dados. Todos os dados existentes são perdidos.
• Altere o modelo de dados. Por exemplo, adicione um EmailAddress campo.
• Execute o aplicativo.
• EnsureCreated Cria um banco de dados com o novo esquema.

Esse fluxo de trabalho funciona no início do desenvolvimento, quando o esquema está evoluindo rapidamente, desde que os dados não precisem ser preservados. A situação é diferente quando os dados introduzidos na base de dados têm de ser preservados. Quando for esse o caso, use migrações.

Mais tarde na série de tutoriais, o banco de dados criado por EnsureCreated é excluído e utilizam-se migrações. Um banco de dados criado por EnsureCreated não pode ser atualizado usando migrações.

Testar a aplicação

• Execute o aplicativo.
• Selecione o link Alunos e, em seguida, Criar novo.
• Teste os links Editar, Detalhes e Excluir.

Semear o banco de dados

O EnsureCreated método cria um banco de dados vazio. Esta seção adiciona código que preenche o banco de dados com dados de teste.

Crie Data/DbInitializer.cs com o seguinte código:

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

O código verifica se há algum aluno no banco de dados. Se não houver alunos, adiciona dados de teste ao banco de dados. Ele cria os dados de teste em matrizes em vez de List<T> coleções para otimizar o desempenho.

• No Program.cs, remova // da DbInitializer.Initialize linha:

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

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

Estúdio Visual

• Pare o aplicativo se ele estiver em execução e execute o seguinte comando no Console do Gerenciador de Pacotes (PMC):

  Drop-Database -Confirm
  
  

• Responda com Y para excluir o banco de dados.

Código do Visual Studio

• Pare o aplicativo se ele estiver em execução e exclua o CU.db arquivo.

• Reinicie o aplicativo.
• Selecione a página Alunos para ver os dados pré-definidos.

Ver a base de dados

Estúdio Visual

• Abra o Pesquisador de Objetos do SQL Server (SSOX) no menu Exibir no Visual Studio.
• Em SSOX, selecione (localdb)\MSSQLLocalDB > Databases > SchoolContext-{GUID}. O nome do banco de dados é gerado a partir do nome de contexto fornecido anteriormente, além de um traço e um GUID.
• Expanda o nó Tabelas .
• Clique com o botão direito do mouse na tabela Aluno e clique em Exibir Dados para ver as colunas criadas e as linhas inseridas na tabela.
• Clique com o botão direito do rato na tabela Student e clique em Ver Código para ver como o modelo se mapeia Student para o esquema da Student tabela.

Código do Visual Studio

Utilize uma ferramenta SQLite para visualizar o esquema de banco de dados e os dados inseridos. O arquivo de banco de dados é nomeado CU.db e está localizado na pasta do projeto.

Métodos EF assíncronos em aplicativos Web ASP.NET Core

A programação assíncrona é o modo padrão para ASP.NET Core e EF Core.

Um servidor Web tem um número limitado de threads disponíveis e, em situações de alta carga, todos os threads disponíveis podem estar em uso. Quando isso acontece, o servidor não pode processar novas solicitações até que os threads sejam liberados. Com o código síncrono, muitos threads podem ficar presos enquanto não estão fazendo trabalho porque estão aguardando a conclusão da E/S. Com o código assíncrono, quando um processo está aguardando a conclusão da E/S, seu thread é liberado para o servidor usar para processar outras solicitações. Como resultado, o código assíncrono permite que os recursos do servidor sejam usados de forma mais eficiente e o servidor pode lidar com mais tráfego sem atrasos.

O código assíncrono introduz uma pequena quantidade de sobrecarga em tempo de execução. Para situações de baixo tráfego, o impacto no desempenho é insignificante, enquanto para situações de tráfego elevado, a melhoria potencial do desempenho é substancial.

No código a seguir, a palavra-chave assíncrona , Task o valor de retorno, await a palavra-chave e ToListAsync o método fazem com que o código seja executado de forma assíncrona.

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

• A async palavra-chave diz ao compilador para:
  • Gere callbacks para partes do corpo do método.
  • Crie o objeto Task que é retornado.
• O Task tipo de retorno representa o trabalho em andamento.
• A palavra-chave await faz com que o compilador divida o método em duas partes. A primeira parte termina com a operação iniciada de forma assíncrona. A segunda parte é usada numa função de retorno que é chamada quando a operação é concluída.
• ToListAsync é a versão assíncrona do método de extensão ToList.

Algumas coisas a ter em conta ao escrever código assíncrono que utiliza EF Core:

• Somente instruções que fazem com que consultas ou comandos sejam enviados ao banco de dados são executadas de forma assíncrona. Isso inclui ToListAsync, SingleOrDefaultAsync, FirstOrDefaultAsync, e SaveChangesAsync. Ele não inclui declarações que apenas alteram um IQueryable, como var students = context.Students.Where(s => s.LastName == "Davolio").
• Um EF Core contexto não é seguro para execução simultânea: não execute várias operações em paralelo.
• Para aproveitar os benefícios de desempenho do código assíncrono, verifique se os pacotes de biblioteca (como para paginação) usam async se chamarem EF Core métodos que enviam consultas para o banco de dados.

Para obter mais informações sobre programação assíncrona no .NET, consulte Visão geral assíncrona e Programação assíncrona com async e await.

Warning

A implementação assíncrona de Microsoft.Data.SqlClient tem alguns problemas conhecidos (#593, #601 e outros). Se você estiver vendo problemas de desempenho inesperados, tente usar a execução de comando de sincronização, especialmente ao lidar com texto grande ou valores binários.

Considerações sobre desempenho

Em geral, uma página da Web não deve carregar um número arbitrário de linhas. Uma consulta deve usar paginação ou uma abordagem limitante. Por exemplo, a consulta anterior pode ser usada Take para limitar as linhas retornadas:

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

Enumerar uma tabela extensa numa visualização pode retornar uma resposta HTTP 200 parcialmente construída se uma exceção de base de dados ocorrer a meio do processo de enumeração.

A paginação é abordada mais adiante no tutorial.

Para obter mais informações, consulte Considerações de desempenho (EF).

Próximos passos

Usar SQLite para desenvolvimento, SQL Server para produção

Próximo tutorial