Padrão de repositório e unidade de trabalho com Asp.Net Core 5 (2023)

Neste artigo, exploraremos a Unidade de trabalho e o padrão Repositório com EF Core e .Net 5.

Então, o que vamos cobrir hoje:

• O que é Padrão de Repositório
• Por que queremos usar o padrão de repositório
• O que é Unidade de Trabalho (UoW)
• Benefícios do UoW
• Ingredientes & Contas
• Código e implementações

O padrão de repositório é muito falado, especialmente no mundo pesado de APIs e microsserviços em que o .net core brilha.

O padrão de repositório é uma estratégia paraabstraindo a camada de acesso a dados. Então, o que é uma camada de dados? é formado pelo código do aplicativo responsável por armazenar e recuperar os dados.

Adicionar, remover, atualizar e selecionar itens dessa coleção é feito por meio de uma série de métodos diretos, sem a necessidade de lidar com questões de banco de dados como conexões, comandos, cursores ou leitores. O uso desse padrão pode ajudar a obter acoplamento fraco e pode manter a persistência de objetos de domínio ignorante.

Existem muitas razões pelas quais queremos usar abstrações de código

• Reduzir a duplicação de código: isso nos permitirá usar o princípio de design DRY, onde escrevemos o código uma vez e podemos utilizá-lo em qualquer lugar que quisermos em nosso código
• baixo acoplamento à tecnologia de persistência subjacente: no caso de precisarmos mudar nosso banco de dados de MSSQL para PostgreSQL. Somente na implementação da camada de dados será necessário fazer alterações, não onde estamos consumindo a camada de acesso a dados. Isso facilitará as alterações, diminuirá a chance de erros.
• A testabilidade é muito mais fácil, o padrão de repositório nos permitirá zombar de nosso banco de dados para que possamos realizar nossos testes
• Separação de preocupações: funcionalidades de aplicativos separados com base na função, o que facilita a evolução e a manutenção do código.

Se o padrão Repository é nossa abstração sobre a ideia de armazenamento persistente, o padrão Unit of Work (UoW) é nossa abstração sobre a ideia de operações atômicas. Isso nos permitirá desacoplar finalmente e totalmente nossa camada de serviço da camada de dados.

A unidade de padrão de trabalho agora gerencia os estados do banco de dados. Depois que todas as atualizações das entidades no escopo são concluídas, as alterações rastreadas são reproduzidas no banco de dados em uma transação para que o banco de dados reflita as alterações desejadas.

Assim, o padrão de unidade de trabalho rastreia uma transação de negócios e a converte em uma transação de banco de dados, em que as etapas são executadas coletivamente como uma única unidade. Para garantir que a integridade dos dados não seja comprometida, a transação é confirmada ou revertida discretamente, evitando assim um estado indeterminado.
Começaremos verificando nosso Dotnet SDK.

dotnet --versão

Agora precisamos instalar a ferramenta Entity Framework

instalação da ferramenta dotnet --global dotnet-ef

Agora precisamos criar nossa aplicação

dotnet new webapi -n "PocketBook"

Depois que o aplicativo é criado, navegamos para o nosso código-fonte no Vs Code, a primeira coisa que fazemos é verificar se o aplicativo foi criado com sucesso.

Abrimos o terminal caso não o veja aberto vá em View ⇒ Terminal

construção dotnet
corrida dotnet

Agora precisamos adicionar os pacotes necessários para utilizar SQLLite e Entity Framework Core

dotnet adicionar pacote Microsoft.AspNetCore.Identity.EntityFrameworkCore
dotnet adicionar pacote Microsoft.EntityFrameworkCore.Sqlite
dotnet adicionar pacote Microsoft.EntityFrameworkCore.Tools
dotnet adicionar pacote Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore

Depois de adicionar os pacotes, precisamos atualizar o appsettings.json para incluir a string de conexão em nosso banco de dados

"Conexões": {
"DefaultConnection": "DataSource=app.db;Cache=Shared"
}

Começaremos limpando nosso aplicativo de parte do código da placa de caldeira que foi criado. Precisamos deletar os seguintes arquivos

• WeatherForecast.cs
• Controladores/WeatherForecastController.cs

Após a limpeza, começaremos criando nosso ApplicationDbContext. Precisamos criar uma pasta Data no diretório raiz, e então criaremos a classe ApplicationDbContext

usando Microsoft.EntityFrameworkCore;
espaço de nomes PocketBook.Data
{
classe pública ApplicationDbContext : DbContext
{
public ApplicationDbContext(DbContextOptions opções)
: base(opções)
{
}
}
}

Depois de adicionar nosso ApplicationDbContext, precisamos atualizar a classe de inicialização para utilizar o DbContext

services.AddDbContext(options =>
opções.UseSqlite(
Configuration.GetConnectionString("Conexão Padrão")));
services.AddDatabaseDeveloperPageExceptionFilter();

Continuaremos criando nossos Models, dentro do nosso diretório raiz. Dentro da pasta Models, criaremos uma nova classe chamada User

usuário de classe pública
{
Id do Guid público { get; definir; }
public string FirstName { get; definir; }
string pública Sobrenome { get; definir; }
public string E-mail { get; definir; }
}

Agora precisamos adicionar nosso Model ao aplicativo DbContext adicionando o código abaixo

classe pública ApplicationDbContext : DbContext
{
// A propriedade DbSet dirá ao EF Core que temos uma tabela que precisa ser criada
public virtual DbSet Usuários { get; definir; }
public ApplicationDbContext(DbContextOptions opções)
: base(opções)
{
}
// A função de criação de modelo nos fornecerá a capacidade de gerenciar as propriedades das tabelas
substituição protegida void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
}
}
(Video) Design Patterns: Implementando o Padrão Unit of Work

Assim que atualizarmos o ApplicationDbContext, precisamos criar um novo script de migração para preparar o EF Core para atualizar nosso banco de dados

dotnet ef migrations add "Migração inicial e adição da tabela de usuários"
atualização do banco de dados dotnet ef

Após a conclusão da atualização do banco de dados, podemos verificar nosso banco de dados SQLite com o navegador SQLite, podemos ver que a tabela foi criada para nós.

Agora precisamos começar criando nossos repositórios. Dentro do diretório raiz da nossa aplicação vamos criar uma nova pasta chamada Core, dentro da pasta core criaremos outra pasta chamada IRepositories. Dentro da pasta IRepositories vamos criar uma nova interface chamada IGenericRepository e vamos preencher a interface da seguinte forma

interface pública IGenericRepository onde T : classe
{
Tarefa> All();
Tarefa GetById(ID do guia);
Tarefa Add(entidade T);
Tarefa Delete(id do guia);
Tarefa Upsert(entidade T);
Task> Find(Expression> predicate);
}

Agora precisamos de uma nova interface chamada IUserRepository

interface pública IUserRepository : IGenericRepository
{
}

Agora dentro da pasta Core, precisamos criar uma nova pasta chamada IConfiguration onde ficarão as configurações do UoW. Dentro do IConfiguration precisamos criar uma interface chamada IUnitOfWork

interface pública IUnitOfWork
{
Usuários IUserRepository { get; }
Tarefa CompleteAsync();
}

Então precisamos criar uma pasta Repository dentro da pasta Core, dentro da pasta Repository precisamos criar a classe GenericRepository e utilizá-la da seguinte forma

public class GenericRepository : IGenericRepository onde T : class
{
contexto ApplicationDbContext protegido;
interno DbSet dbSet;
public readonly ILogger _logger;
public GenericRepository(
Contexto ApplicationDbContext,
Registros do ILogger)
{
this.context = contexto;
this.dbSet = context.Set();
_log = log;
}
Tarefa assíncrona virtual pública GetById(ID do guia)
{
return await dbSet.FindAsync(id);
}
Tarefa assíncrona virtual pública Adicionar(entidade T)
{
aguarde dbSet.AddAsync(entidade);
retornar verdadeiro;
}
Tarefa virtual pública Excluir (id do guia)
{
lance o novo NotImplementedException();
}
tarefa virtual pública> All()
{
lance o novo NotImplementedException();
}
public async Task> Find(Expression> predicate)
{
return await dbSet.Where(predicado).ToListAsync();
}
Tarefa virtual pública Upsert(entidade T)
{
lance o novo NotImplementedException();
}
}

Então precisamos criar nosso UserRepository na pasta Repository também

public class UserRepository: GenericRepository, IUserRepository
{
public UserRepository(ApplicationDbContext context, ILogger logger): base(context, logger) { }
substituição pública async Task> All()
{
tentar
{
return await dbSet.ToListAsync();
}
pegar (Exceção ex)
{
_logger.LogError(ex, "{Repo} Erro em todas as funções", typeof(UserRepository));
return new List();
}
}
public override async Task Upsert(Entidade do usuário)
{
tentar
{
var existUser = await dbSet.Where(x => x.Id == entity.Id)
.FirstOrDefaultAsync();
if (usuário existente == nulo)
retornar aguardar Adicionar(entidade);
existindoUser.FirstName = entidade.FirstName;
currentUser.LastName = entidade.LastName;
existenteUser.Email = entidade.Email;
retornar verdadeiro;
}
pegar (Exceção ex)
{
_logger.LogError(ex, "{Repo} Erro na função Upsert", typeof(UserRepository));
retorna falso;
}
}
tarefa assíncrona de substituição pública Excluir (id do guia)
{
tentar
{
var exist = await dbSet.Where(x => x.Id == id)
.FirstOrDefaultAsync();
if (exist == null) return false;
dbSet.Remove(existir);
retornar verdadeiro;
}
pegar (Exceção ex)
{
_logger.LogError(ex, "{Repo} Excluir erro de função", typeof(UserRepository));
retorna falso;
}
}
}
(Video) asp net core 6 tutorial (part -05  Repository and Unit of Work)

Uma vez que o repositório foi criado, agora precisamos criar nossa classe UnitofWork dentro da pasta Data.

classe pública UnitOfWork: IUnitOfWork, IDisposable
{
private readonly ApplicationDbContext _context;
private readonly ILogger _logger;
public IUserRepository Users { get; conjunto privado; }
public UnitOfWork (ApplicationDbContext context, ILoggerFactory loggerFactory)
{
_contexto = contexto;
_logger = loggerFactory.CreateLogger("logs");
Usuários = new UserRepository(contexto, _logger);
}
Tarefa assíncrona pública CompleteAsync()
{
aguarde _context.SaveChangesAsync();
}
public void Dispose()
{
_context.Dispose();
}
}

Agora que a Unit of work foi criada, precisamos atualizar a classe de inicialização, para que ela seja injetada em nosso framework de injeção de dependência. Para fazer isso, precisamos ir para a classe de inicialização na pasta raiz e adicionar o seguinte no método ConfigureServices.

services.AddScoped();

Agora vamos criar nosso controller dentro da pasta controller, criar uma nova classe chamada UsersController.cs

[ApiController]
[Rota("[controlador]")]
classe pública UsersController : ControllerBase
{
private readonly ILogger _logger;
private readonly IUnitOfWork _unitOfWork;
public UsersController(
ILogger registrador,
IUnitOfWork unitOfWork)
{
_log = log;
_unitOfWork = unitOfWork;
}
[HttpGet]
Tarefa assíncrona pública Get()
{
var users = await _unitOfWork.Users.All();
return Ok(usuários);
}
[HttpGet("{id}")]
Tarefa assíncrona pública GetItem(ID do guia)
{
var item = await _unitOfWork.Users.GetById(id);
if(item == nulo)
return NotFound();
return Ok(item);
}
[HttpPost]
Tarefa assíncrona pública  CreateUser (User user)
{
if(ModelState.IsValid)
{
user.Id = Guid.NewGuid();
aguarde _unitOfWork.Users.Add(usuário);
aguarde _unitOfWork.CompleteAsync();
return CreatedAtAction("GetItem", novo {usuário.Id}, usuário);
}
return new JsonResult("Algo deu errado") {StatusCode = 500};
}
[HttpPut("{id}")]
public async Task UpdateItem(id do guia, usuário do usuário)
{
if(id != user.Id)
return BadRequest();
aguarde _unitOfWork.Users.Upsert(usuário);
aguarde _unitOfWork.CompleteAsync();
// Seguindo o padrão REST na atualização, precisamos retornar NoContent
return SemConteúdo();
}
[HttpDelete("{id}")]
Tarefa assíncrona pública DeleteItem(ID do guia)
{
var item = await _unitOfWork.Users.GetById(id);
if(item == nulo)
return BadRequest();
aguarde _unitOfWork.Users.Delete(id);
aguarde _unitOfWork.CompleteAsync();
return Ok(item);
}
}

Obrigado por ler, deixe-me saber suas perguntas, pensamentos ou feedback na seção de comentários. Eu aprecio o seu feedback e encorajamento.

Continue aprendendo…. !!!