[Simples] Criando templates customizados em C#
Tags: dotnet, csharp, template, programming
Published: 2022-05-07 17:58:25

> "Sejam bondosos e compassivos uns para com os outros, perdoando-se mutualmente, assim como Deus os perdoou em Cristo."
Efésios 4.32

Provavelmente você já viu ou utilizou o comando `dotnet new` para criar projetos usando o ~~novo~~ .NET, então vou te mostrar como criar seu próprio template customizado!

Pré-requisitos (para este tutorial):
- [dotnet CLI](https://docs.microsoft.com/pt-br/dotnet/machine-learning/how-to-guides/install-ml-net-cli)
- [VS Code](https://code.visualstudio.com/)

Vou criar o template de um projeto Web API, mas podemos criar templates de arquivos ou até estruturas completas com `Dockerfile`, `.editorconfig`, `.sln`, estruturas de pastas e etc, tudo depende da sua necessidade (ou criatividade). Mas para este tutorial faremos da forma mais simples e útil para este momento, então vamos prosseguir.

Com o terminal do VSCode aberto, vamos criar um projeto do tipo Web API, customizar e remover o que for desnecessário.

```bash
> dotnet new webapi --no-https -n MyProject -o src
> ri src/WeatherForecast.cs
> ren src/Controllers/WeatherForecastController.cs MyController.cs
```

Faremos algumas alterações no arquivo `MyController.cs` (caso seja iniciante não copie o código, mas escreva linha por linha).

```csharp
using Microsoft.AspNetCore.Mvc;

// MyProject será substituido pelo nome do projeto ao criar o template
namespace MyProject.Controllers;

[ApiController]
[Route("[controller]")]
// WeatherForecast foi renomeado para My
public class MyController : ControllerBase
{
    private readonly ILogger<MyController> _logger;

    public MyController(ILogger<MyController> logger)
    {
        _logger = logger;
    }

    [HttpGet()]
    public string Get()
    {
        _logger.LogInformation("Hello World");
        return "Olá Mundo";
    }

    [HttpPost()]
    public void Post([FromBody] object body)
    {
        _logger.LogInformation($"received {body}");
    }
}
```

Agora vamos rodar para ver se está tudo certo:

```bash
> dotnet run --project src
Building...
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5172
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: C:\repos\criando-template\src\
```

Eu utilizo uma extensão chamada [REST Client](https://marketplace.visualstudio.com/items?itemName=humao.rest-client) para fazer as requisições usando o próprio VSCode para testar coisas mais rapidamente, mas você pode utilizar o [Postman](https://www.postman.com/) se preferir ou o próprio navegador no caso do método GET. Para não confundir ninguém vou mostrar o resultado do meu terminal ao fazer as requisições.

```bash
info: MyProject.Controllers.MyController[0]
      Hello World
info: MyProject.Controllers.MyController[0]
      received { "confia": "no Pai" }
```

Agora com a nossa Web API customizada, vamos configurar o nosso template:

```bash
> mkdir ./src/.template.config
> '' > ./src/.template.config/template.json
```

Conteúdo do arquivo `template.json`:

```json
{
    "$schema": "http://json.schemastore.org/template",
    "author": "@confianodev",
    "identity": "My Web Api",
    "name": "My Web Api",
    "shortName": "myapi",
    "preferNameDirectory": false,
    "sourceName": "MyProject",
    "classifications": ["Web API", "API"],
    "tags": {
        "language": "C#",
        "type": "project"
    }
}
```

Vou dar uma breve explicação de alguns desses campos, lembrando que podemos adaptar essas informações:

**author** - Nome de quem tem a propriedade intelectual deste template(você, a empresa, uma organização).

**shortName** - O nome que será utilizado no comando, exemplo: `dotnet new myapi`

**preferNameDirectory** - Caso seja `true` será gerado o projeto dentro de uma pasta com o nome informado(`dotnet new myapi -n EsseNome`) caso seja `false` não cria pasta nenhuma.

**sourceName** - Muito importante pois é a palavra-chave que vai substituir arquivos, namespace, textos, etc, ao criar um novo projeto usando o seu template (`dotnet new myapi -n PalavraChave`).

**tags** - Utilizado para informar qual o tipo do template e quais linguagens são suportadas(podemos criar em F# também)

Para mais informações pode acessar este [link](https://github.com/dotnet/templating/wiki/).

Finalmente, vamos instalar nosso template, criar um projeto e testá-lo:

```bash
> dotnet new -i .
> dotnet new myapi -n Oloko -o sample
> dotnet run --project sample/
Building...
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5172
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: C:\repos\criando-template\sample\
```

E está pronto o nosso template. Lembrando que a ideia do template é facilitar a criação de novos projetos e novos arquivos, então crie da maneira que for mais útil para o seu dia-a-dia.

Caso queria desinstalar basta utilizar o comando:

```bash
> dotnet new --uninstall .
```

Claro que este é o jeito mais simples de fazer um template, no próximo Post vou mostrar como criar uma solução completa, com dois projetos e uma solução, com Dockerfile, padronização de código e etc, utilizando o github actions para publicar como pacote Nuget.

Fico muito agradecido de ter compartilhado este conhecimento com você, se tiver alguma dúvida deixe nos comentários.

Acesse meu canal no YouTube [clicando aqui](https://www.youtube.com/channel/UCtzrdserH-SqGFPKhj72UUg)
E caso queria ir para o post mais avançado, [clique aqui](https://dev.to/vinibeloni/avancado-criando-templates-customizados-em-c-8jc)

Abraços e até a próxima!

Fontes:

[Donovan Brown: Custom Templates for dotnet new](https://www.youtube.com/watch?v=nnr9yeYtr6I)
[How to create your own templates](https://devblogs.microsoft.com/dotnet/how-to-create-your-own-templates-for-dotnet-new/)
[Templating Wiki](https://github.com/dotnet/templating/wiki/)