Criando um CRUD do ZERO em .NET usando o Liquid Framework
Tags: dotnet, backend, csharp, braziliandevs
Published: 2022-08-16 23:29:40

---
title: Criando um CRUD do ZERO em .NET usando o Liquid Framework
published: true
description: Este artigo demonstra como criar um CRUD em .NET do ZERO absoluto usando o Liquid Framework, e como esse processo fica ainda mais rápido com o uso do Liquid.Templates
tags: #dotnet #backend #csharp #braziliandevs 
---

O [Liquid](https://github.com/Avanade/Liquid-Application-Framework) é um framework Open Source desenvolvido pela Avanade, para acelerar o desenvolvimento de aplicações cloud-native em .NET.

Neste artigo, serão utilizadas apenas ferramentas de linha de comando e todos os passos podem ser realizados em qualquer setup que seja compatível com o dotnet (inclusive o artigo foi elaborado usando o WSL2 com Ubuntu)

Para a construção do nosso CRUD vamos começar instalando o Liquid.Templates, que irá nos apoiar no processo de criação do projeto.

## Pré-Requisitos

* .NET 5 (no momento em que este artigo foi escrito esta era a versão mais recente do .NET compatível com o Liquid)

## Instalando o Liquid.Templates

```bash
dotnet new -i Liquid.Templates
```

Caso você já possua o Liquid.Templates instalado, recomendo a atualização do mesmo, para garantir que estamos trabalhando com a versão mais atual.

```bash
dotnet new --update-apply
```

Para ter certeza que o Liquid.Templates foi instalado com sucesso vamos executar o seguinte comando:

```bash
dotnet new Liquid -l
```

## Como explorar o Liquid.Templates

Caso o template tenha sido instalado corretamente, você deverá ter um retorno semelhante ao apresentado abaixo:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d4h2x94thnzyryr42ybo.png)
 
Na imagem acima, temos a relação de todos os templates que foram instalados com uma breve descrição de cada um deles.

Para este artigo utilizaremos o liquidcrudextsolution.

Vamos então explorar os parâmetros esperados para este template através do comando abaixo:

```bash
dotnet new liquidcrudextsolution -h
```

Será apresentada a seguinte tela:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2s8m457x57fhqj3ayx0e.png)
 
Para este template são esperados os seguintes parâmetros:

|Parâmetro|Descrição|
|-|-|
|projectName|Namespace da Solution|
|entityName|Nome da Entidade|
|entityIdType|Tipo do Id da Entidade|

Para começar o processo de criação do micro serviço, vamos criar um diretório chamado "catalogo" e vamos entrar no diretorio.

```bash
mkdir catalogo
cd catalogo
```

##Realizando SETUP do Projeto

Neste exemplo o microserviço será chamado "Fructuoso.Exemplo.Catalogo", minha entidade será Produto e o tipo do Id será Guid.

```bash
dotnet new liquidcrudextsolution -p Fructuoso.Exemplo.Catalogo -e Produto -en Guid
```

Após executar o comando acima, a seguinte estrutura de pastas será criada:

```
📦src
 ┣ 📂Fructuoso.Exemplo.Catalogo.Domain
 ┃ ┣ 📂Entities
 ┃ ┃ ┗ 📜ProdutoEntity.cs
 ┃ ┣ 📜Fructuoso.Exemplo.Catalogo.Domain.csproj
 ┃ ┗ 📜IDomainInjection.cs
 ┣ 📂Fructuoso.Exemplo.Catalogo.WebApi
 ┃ ┣ 📂Controllers
 ┃ ┃ ┗ 📜ProdutoController.cs
 ┃ ┣ 📜Fructuoso.Exemplo.Catalogo.WebApi.csproj
 ┃ ┣ 📜Program.cs
 ┃ ┣ 📜Startup.cs
 ┃ ┗ 📜appsettings.json
 ┗ 📜Fructuoso.Exemplo.Catalogo.Microservice.sln
 ```

Antes de seguir, é necessário restaurar as dependêcias da solução. (Em alguns casos sua IDE pode sugerir fazer isso automáticamente para você)

```bash
cd src
dotnet restore
```

##Conhecendo a estrutura da solução

O template escolhido criará automaticamente dois projetos **WebAPI** e **Domain**.

### WebAPI

Neste projeto ficam os *controllers* e toda a injeção de dependência necessaria, sendo que parte dela já foi criada automaticamente pelo template do Liquid.

### Domain

Neste projeto fica toda a regra de negócio necessária para o funcionamento do micro serviço, como estamos utilizando o Liquid CRUD Extension, a regra necessária para a criação de um CRUD básico fica totalmente encapsulada.

Nos próximos artigos veremos como estender esses comportamentos.

##Implementação

Depois de explorar um poouco o código gerado automaticamente pelo template é possivel notar que temos 2 TODO para implementar e com a implementação desses dois blocos de código teremos nosso CRUD 100% funcional.

### Entidade (ProdutoEntity)

Neste primeiro TODO precisamos apenas definir quais propriedades serão utilizadas.

Para este exemplo vamos criar apenas Código, Nome e Preço.

```csharp
public class ProdutoEntity : LiquidEntity<Guid>
{
    public int Codigo { get; set; }
    public string Nome { get; set; }
    public double Preco { get; set; }
}
```

### Startup

A classe Startup.cs é responsável pela configuração da nossa WebAPI, seguiremos com o passo a passo sugerido pelo TODO gerado pelo template. Neste artigo faremos uso do InMemory do **Entity Framework**.

1. Vamos criar o projeto **Repository**
```bash
dotnet new liquiddbcontextproject --projectName Fructuoso.Exemplo.Catalogo --entityName Produto
```
2. Adicione o projeto **Repository** na solução.
```bash
dotnet sln add Fructuoso.Exemplo.Catalogo.Repository/Fructuoso.Exemplo.Catalogo.Repository.csproj
```
3. Restaure as dependências do projeto novamente
```bash
dotnet restore
```
4. Adicione o projeto **Repository** como referência ao projeto **WebAPI**
```bash
cd Fructuoso.Exemplo.Catalogo.WebApi 
dotnet add reference ../Fructuoso.Exemplo.Catalogo.Repository/Fructuoso.Exemplo.Catalogo.Repository.csproj
```
5. Adicione o pacote **Microsoft.EntityFrameworkCore.InMemory**
```bash
dotnet add package Microsoft.EntityFrameworkCore.InMemory --version 5.0.13
```
6. Importe a referência do **EntityFrameworkCore** nesta classe
```csharp
using Microsoft.EntityFrameworkCore;
```
7. Configure o DbContextOptions incluíndo o seguinte código abaixo do TODO (este passo determina o banco de dados que será utilizado pela aplicação)
```csharp
Action<DbContextOptionsBuilder> options = (opt) => opt.UseInMemoryDatabase("CRUD");
```
8. Adicione o pacote **Liquid.Repository.EntityFramework**
```csharp
dotnet add package Liquid.Repository.EntityFramework --version 2.*
```
9. Importe a referência do **Liquid.Repository.EntityFramework.Extensions**
```csharp
using Liquid.Repository.EntityFramework.Extensions;
```
10. Importe a referência do Repository nesta classe
```csharp
using Fructuoso.Exemplo.Catalogo.Repository;
```
11. Registre o DbContext no **ServiceCollection**
```csharp
services.AddLiquidEntityFramework<LiquidDbContext, ProdutoEntity, Guid>(options);
```

## Executando aplicação

Com o CRUD completamente implementado é hora de executar

```bash
dotnet run
```

Por padrão a aplicação rodará nas portas 5000 (http) e 5001 (https), ao acessar o endereço https://localhost:5001/swagger

Deverá ser apresentada uma tela como esta:

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fqtvl2d64qeqy4nb60bw.png)

## Encerramento

Como foi possível perceber, para criar um CRUD foi preciso apenas determinar as propriedades da nossa entidade e definir qual o repositório que será utilizado todo o restante do trabalho foi gerado automaticamente. 

Por hoje é isso, se você curtiu esse artigo não esqueça de deixar seu like e fique ligado nos proximos posts com mais conteudo sobre o Liquid Framework.