Use procedimentos assíncronos e armazenados para aplicativos ASP.NET MVC
Esta é uma tradução do tutorial oficial da Microsoft Introdução ao Código do Entity Framework 6 Primeiro, usando a série MVC 5, aqui está o nono artigo: Usando procedimentos assíncronos e armazenados para aplicativos ASP.NET MVC
Próximo: Procedimentos assíncronos e armazenados com o Entity Framework em um aplicativo ASP.NET MVC
No tutorial anterior, você aprendeu como usar o modelo de programação síncrona para ler e atualizar dados. Neste tutorial, você verá como implementar um modelo de programação assíncrono. Devido ao melhor uso dos recursos do servidor, o código assíncrono pode ajudar os aplicativos a executarem melhor.
Neste tutorial, você também verá como usar procedimentos armazenados para inserir, atualizar e excluir entidades.
A ilustração a seguir mostra a página que você escreverá:
Por que usar código assíncrono problemático
Um servidor WEB possui apenas um número limitado de threads disponíveis e, sob alta carga, todos os threads podem estar em uso. Quando isso acontece, o servidor não poderá processar novas solicitações até que um encadeamento seja liberado. No caso de código síncrono, vários encadeamentos podem ser associados, mas, na verdade, eles não realizam nenhum trabalho, apenas aguardam a conclusão do IO. Usando código assíncrono, quando um processo está aguardando a conclusão do IO, seus encadeamentos podem ser liberados pelo servidor para processar outras solicitações. Portanto, o código assíncrono pode usar os recursos do servidor com mais eficiência, e o servidor pode lidar com mais tráfego sem demora.
Nas versões anteriores do .NET, escrever e testar código assíncrono era complexo, passível de erros e difícil de depurar. No .Net 4.5, escrever, testar e depurar código assíncrono se torna simples.Você sempre deve usar código assíncrono, a menos que não tenha permissão para fazê-lo por um motivo. O código assíncrono custará muito pouco overhead, mas a perda de desempenho é insignificante para situações de baixo tráfego. Para situações de tráfego intenso, as sugestões de desempenho em potencial são enormes.
Para obter mais informações sobre programação assíncrona, consulte Usar o suporte assíncrono do .NET 4.5 para evitar o bloqueio de chamadas .
Crie um controlador de sistema
Crie um controlador de sistema da mesma maneira que você criou outros controladores antes, mas desta vez optamos por usar a opção de operação do controlador assíncrono .
No código a seguir, a parte destacada mostra a diferença entre o método assíncrono e o método síncrono:
public async Task<ActionResult> Index()
{
var departments = db.Departments.Include(d => d.Administrator);
return View(await departments.ToListAsync());
}Aplicamos quatro alterações para permitir que o banco de dados do Entity Framework execute consultas assíncronas:
- Esse método usa a palavra-chave async, que informa ao compilador para gerar parte do corpo do método de retorno de chamada e criar automaticamente um
Task<ActionResult>objeto de retorno. - O tipo de retorno foi alterado de ActionResult
Task<ActionResult>.Task<T>Tipo indica que a tarefa em andamento tem um resultado do tipo T. - A palavra-chave wait é aplicada às chamadas de serviço da web. Quando o compilador vê essa palavra-chave, ele divide o método em duas partes em segundo plano. A primeira parte termina quando a operação assíncrona é iniciada e a segunda parte é colocada em um método de retorno de chamada quando a operação é concluída.
- A versão assíncrona do método de extensão ToList é chamada.
Por que apenas modificar a instrução departamentos.ToList em vez da instrução departamentos = db.Departimentos? O motivo é que apenas as consultas ou instruções executadas pelo banco de dados que está sendo enviado podem ser executadas de forma assíncrona. A instrução departments = db.Departments configura uma consulta, mas a consulta não será executada até que o método ToList seja chamado. Portanto, apenas o método ToList é executado de forma assíncrona.
No método Details e nos métodos Edit e Delete do Httpget, o método Find é o método que faz com que a consulta seja enviada ao banco de dados para recuperação, para que esse método possa ser executado de forma assíncrona.
public async Task<ActionResult> Details(int? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Department department = await db.Departments.FindAsync(id);
if (department == null)
{
return HttpNotFound();
}
return View(department);
}Nos métodos Edit e DeleteConfirmed de Create, HttpPost, é o método SaveChanges que faz com que o comando seja executado, enquanto métodos como db.Department.Add (departamento) causam apenas a modificação da entidade na memória.
public async Task<ActionResult> Create(Department department)
{
if (ModelState.IsValid)
{
db.Departments.Add(department);
await db.SaveChangesAsync();
return RedirectToAction("Index");
}Abra Views \ Department \ Index.cshtml e substitua o original pelo seguinte código:
@model IEnumerable<ContosoUniversity.Models.Department>
@{
ViewBag.Title = "Departments";
}
<h2>Departments</h2>
<p>
@Html.ActionLink("Create New", "Create")
</p>
<table class="table">
<tr>
<th>
@Html.DisplayNameFor(model => model.Name)
</th>
<th>
@Html.DisplayNameFor(model => model.Budget)
</th>
<th>
@Html.DisplayNameFor(model => model.StartDate)
</th>
<th>
Administrator
</th>
<th></th>
</tr>
@foreach (var item in Model) {
<tr>
<td>
@Html.DisplayFor(modelItem => item.Name)
</td>
<td>
@Html.DisplayFor(modelItem => item.Budget)
</td>
<td>
@Html.DisplayFor(modelItem => item.StartDate)
</td>
<td>
@Html.DisplayFor(modelItem => item.Administrator.FullName)
</td>
<td>
@Html.ActionLink("Edit", "Edit", new { id=item.DepartmentID }) |
@Html.ActionLink("Details", "Details", new { id=item.DepartmentID }) |
@Html.ActionLink("Delete", "Delete", new { id=item.DepartmentID })
</td>
</tr>
}
</table>O código modifica o título e move a coluna do chefe de departamento para a direita, fornecendo o nome do chefe de departamento.
Nas visualizações Criar, Excluir, Detalhes e Editar, altere o título do campo Código do Instrutor para "Chefe do Departamento", semelhante à forma como você alterou o campo Nome do Departamento para "Departamento" na Visualização do Curso antes.
Use o seguinte código na criação e edição de visualizações:
<label class="control-label col-md-2" for="InstructorID">Administrator</label>Use o seguinte código nas exibições de exclusão e detalhada:
<dt>
Administrator
</dt>Execute o aplicativo e clique na guia Departamento.
O programa é executado normalmente, assim como outros controladores. Mas neste controlador, todas as consultas SQL são executadas de forma assíncrona.
Algumas coisas a serem observadas ao usar a programação assíncrona no Entity Framework:
- Código assíncrono não é seguro para threads. Em outras palavras, não use a mesma instância de contexto para executar várias operações em paralelo.
- Se você quiser tirar proveito das vantagens de desempenho do código assíncrono, verifique se todos os pacotes de bibliotecas que você está usando (como paginação), qualquer método do Entity Framework, como consultas de banco de dados no pacote, também usam execução assíncrona.
Procedimentos armazenados para inserir, atualizar e excluir
Alguns desenvolvedores e DBAs preferem usar procedimentos armazenados para acessar o banco de dados. Nas versões anteriores do Entity Framework, você pode usar a consulta SQL original para recuperar dados para executar procedimentos armazenados, mas não pode usar procedimentos armazenados para operações de atualização. No Entity Framework 6, você pode configurar facilmente o Code First para usar procedimentos armazenados.
- Em DAL \ SchoolContext.cs, adicione o código destacado ao método OnModelCreating.
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
modelBuilder.Entity<Course>()
.HasMany(c => c.Instructors).WithMany(i => i.Courses)
.Map(t => t.MapLeftKey("CourseID")
.MapRightKey("InstructorID")
.ToTable("CourseInstructor"));
modelBuilder.Entity<Department>().MapToStoredProcedures();
}Este código instrui o Entity Framework a usar procedimentos armazenados para inserir, atualizar e excluir entidades de departamento.
- No console de gerenciamento de pacotes, digite o seguinte comando:
add-migration DepartmentSPAbra Migrations \ <timestamp> _DepartmentSP.cs, consulte o código no método Up. Você verá os procedimentos armazenados para inserir, atualizar e excluir:
public override void Up()
{
CreateStoredProcedure(
"dbo.Department_Insert",
p => new
{
Name = p.String(maxLength: 50),
Budget = p.Decimal(precision: 19, scale: 4, storeType: "money"),
StartDate = p.DateTime(),
InstructorID = p.Int(),
},
body:
@"INSERT [dbo].[Department]([Name], [Budget], [StartDate], [InstructorID])
VALUES (@Name, @Budget, @StartDate, @InstructorID)
DECLARE @DepartmentID int
SELECT @DepartmentID = [DepartmentID]
FROM [dbo].[Department]
WHERE @@ROWCOUNT > 0 AND [DepartmentID] = scope_identity()
SELECT t0.[DepartmentID]
FROM [dbo].[Department] AS t0
WHERE @@ROWCOUNT > 0 AND t0.[DepartmentID] = @DepartmentID"
);
CreateStoredProcedure(
"dbo.Department_Update",
p => new
{
DepartmentID = p.Int(),
Name = p.String(maxLength: 50),
Budget = p.Decimal(precision: 19, scale: 4, storeType: "money"),
StartDate = p.DateTime(),
InstructorID = p.Int(),
},
body:
@"UPDATE [dbo].[Department]
SET [Name] = @Name, [Budget] = @Budget, [StartDate] = @StartDate, [InstructorID] = @InstructorID
WHERE ([DepartmentID] = @DepartmentID)"
);
CreateStoredProcedure(
"dbo.Department_Delete",
p => new
{
DepartmentID = p.Int(),
},
body:
@"DELETE [dbo].[Department]
WHERE ([DepartmentID] = @DepartmentID)"
);
}- No console do gerenciador de pacotes, digite o seguinte comando:
update-database- Execute o aplicativo no modelo de depuração, clique na guia Departamento e, em seguida, clique em Criar.
- Insira os dados relevantes para um novo departamento e clique em Criar.
- Veja o log na janela de saída no VS.
Código Primeiro criou o procedimento armazenado usando o nome padrão. Se você estiver usando um banco de dados existente, poderá ser necessário personalizar o nome do procedimento armazenado.Para obter informações sobre como fazer isso, consulte Código da estrutura da entidade Primeiro insira / atualize / exclua procedimentos armazenados .
Se você deseja personalizar o procedimento armazenado, você pode editar o método Up no código de andaime na migração para criar o procedimento armazenado. Com esse método, suas alterações serão feitas automaticamente quando o aplicativo for migrado ou após a implantação no ambiente de produção.
Se você deseja modificar um procedimento armazenado que foi criado na migração anterior, use o comando Adicionar Migração para gerar uma migração em branco e, em seguida, escreva manualmente o código para chamar o método AlterStoredProcedure.
Implantar no Windows Azure
Ligeiramente ...
Sumário
Neste tutorial, você viu como melhorar a eficiência do servidor. Insira, atualize e exclua operações escrevendo código de execução assíncrono e usando procedimentos armazenados. No próximo tutorial, você verá como evitar a perda de dados quando vários usuários tentarem editar o mesmo registro.
Informações do autor
Tom Dykstra -Tom Dykstra é um programador e escritor sênior da equipe Microsoft Web Platform and Tools.
