Gerando APIs clients com as ferramentas de OpenAPI do .NET \| TreinaWeb               Promoção no ar   Matricule-se agora e garanta **54% de desconto**  

  Termina em   Tempo restante da oferta: 04 Horas 

 04 Min 

 36 Seg 

   Tempo restante da oferta: 04 04 36 

  [Assinar →](https://www.treinaweb.com.br/checkout/pagamento/plano/anual?cupom=TW-SCLIENTE26) 

   [                ](https://www.treinaweb.com.br)  Explorar  

 [ Quanto custa? ](#assinatura) [ FAQ ](https://www.treinaweb.com.br#faq) [Matricule-se](#assinatura) [ Entrar ](https://www.treinaweb.com.br/login) 

     [ Início ](https://www.treinaweb.com.br) [ Artigos ](https://www.treinaweb.com.br/blog) Gerando APIs clients com as ferramentas de OpenAPI do .NET  [ Desenvolvimento Back-end ](https://www.treinaweb.com.br/blog/categoria/desenvolvimento-back-end) [ .NET Core ](https://www.treinaweb.com.br/blog/categoria/net-core) 

# Gerando APIs clients com as ferramentas de OpenAPI do .NET

 Aprenda como gerar APIs clientes com a global tool Microsoft.dotnet-openapi.

 [ Wladimilson M. Nascimento ](https://www.treinaweb.com.br/blog/autor/wladimilson-m-nascimento) 6 anos atrás

  ![](https://dkrn4sk0rn31v.cloudfront.net/uploads/2021/02/gerando-apis-clients-com-as-ferramentas-de-openapi-do-net.png)  

Se for necessário [consumir os dados de uma API](https://www.treinaweb.com.br/blog/c-consumindo-apis-com-flurl/), como vimos, este processo pode ser facilitado com o uso da biblioteca [Flurl](https://www.treinaweb.com.br/blog/c-testando-requisicoes-com-flurl). Mesmo não sendo complexo, ainda irá requerer códigos redundantes e qualquer alteração na API, irá necessitar de modificações no *client*. Entretanto, este processo pode ser facilitado e praticamente automatizado com uso das ferramentas de OpenAPI do .NET.

## OpenAPI

Quase sinônimo de [Swagger](https://www.treinaweb.com.br/blog/documentando-uma-asp-net-core-web-api-com-o-swagger/), OpenAPI é uma série de especificações definidas pela comunidade em conjunto com a [Open API Iniciative](https://www.openapis.org/), para descrição e documentação de [APIs](https://www.treinaweb.com.br/blog/o-que-e-uma-api/).

Totalmente independente de uma linguagem de programação, a especificação OpenAPI permite que tanto humanos quanto aplicações compreendam e explorem um serviço sem necessitar ter acesso ao seu código fonte ou documentação adicional.

Quando corretamente definida, um consumidor poderá interagir com o serviço utilizando uma implementação simples ou nenhuma dependendo das ferramentas utilizadas.

## Microsoft.dotnet-openapi

Por permitir definir todos os aspectos da API, algumas ferramentas conseguem gerar *clients* ao analisar uma especificação OpenAPI. Uma ferramenta clássica que faz este tipo de procedimento é o Swagger, que disponibiliza uma interface para uma análise visual e testável da especificação.

Já outras ferramentas geram códigos que podem ser adicionados à uma aplicação. Com isso, o desenvolvedor não precisa se preocupar em implementar o *client* da API no projeto. Para o .NET uma ferramenta clássica que realiza este tipo de procedimento é a [NSwag](https://github.com/RicoSuter/NSwag), entretanto, na versão 5 desta biblioteca, a Microsoft disponibiliza a ferramenta [Microsoft.dotnet-openapi](https://www.nuget.org/packages/Microsoft.dotnet-openapi) que também realiza este procedimento.

Esta [global tool](https://www.treinaweb.com.br/blog/global-tools-no-net-core-2-1/) cria todo o código necessário para consumir os dados de uma API de acordo com a especificação OpenAPI indicada. Caso haja alguma alteração na especificação, ela também pode ser utilizada para atualizar os códigos. Com isso, o desenvolvedor não precisa digitar nenhuma linha para poder consumir os dados da API.

## Api de exemplo

Para exemplificar a ferramenta Microsoft.dotnet-openapi, irei utilizar a especificação OpenAPI gerada pela [API criada com a biblioteca Carter](https://www.treinaweb.com.br/blog/criando-uma-api-restful-com-o-carter-e-net-core/), pois ela está completa e não requer nenhuma modificação.

Caso queira utilizá-la você pode obter o projeto no meu [Github](https://github.com/wladimilson/carterapi).

## Gerando os códigos do client

Neste exemplo o *client* será definido em uma aplicação à parte da API, entretanto, nada impede que ele seja definido no mesmo projeto, ou dentro da mesma solução.

Assim, inicialmente será criado um projeto console:

```shell
dotnet new console -n OpenAPiClient

```

Em seguida, adicione a global tool:

```shell
dotnet tool install -g Microsoft.dotnet-openapi

```

Com isso, no nível do arquivo de configuração do projeto (`*.csproj`), execute o comando abaixo:

```shell
dotnet openapi add url https://localhost:5001/openapi --output-file CarterApi.json

```

Por ser uma URL, acima é utilizado o `add url`. Caso queira especificar um arquivo de configuração, pode ser utilizado o comando `add file`, e.g.:

```shell
dotnet openapi add file CarterApi.json

```

O comando `add url` irá baixar da url informada a especificação OpenAPI e irá salvar uma cópia dela no projeto:

![Explorer do VS Code mostrando um projeto console com destaque no arquivo CarterApi.json](https://dkrn4sk0rn31v.cloudfront.net/uploads/2021/02/carterapi-json_no_projeto.png)

E no arquivo de configuração dele, será adicionado a configuração abaixo:

```xml

```

Assim, caso queira, isso pode ser definido manualmente.

Se não quiser utilizar a ferramenta de linha de comando, no Visual Studio Community (Professional e Enterprise), isso também pode ser definido com a opção “Connected Service” (Add > Connected Service, ao clicar com o botão direito do mouse sobre projeto).

Com esta configuração, a ferramenta já criará os códigos necessários para se conectar à API:

```csharp
class Program
{
    static async Task Main(string[] args)
    {
        using var httpClient = new HttpClient();

        var apiClient = new CarterApiClient("https://localhost:5001", httpClient);

        await apiClient.PostPessoaAsync(new Pessoa{
            Id = 1,
            Nome = "Carlos",
            Idade = 33
        });

        await apiClient.PostPessoaAsync(new Pessoa{
            Id = 2,
            Nome = "Maria",
            Idade = 33
        });
        var pessoas = await apiClient.GetPessoaAsync();

        foreach(var pessoa in pessoas)
        {
            Console.WriteLine($"{pessoa.Id} - {pessoa.Nome} - {pessoa.Idade}");
        }

        await apiClient.PutPessoaAsync(1, new Pessoa{
            Id = 1,
            Nome = "José",
            Idade = 12
        });

        var jose = await apiClient.GetPessoaByIdAsync(1);

        Console.WriteLine($"{jose.Id} - {jose.Nome} - {jose.Idade}");

        await apiClient.DeletePessoaAsync(1);

        pessoas = await apiClient.GetPessoaAsync();

        foreach(var pessoa in pessoas)
        {
            Console.WriteLine($"{pessoa.Id} - {pessoa.Nome} - {pessoa.Idade}");
        }
    }
}

```

O nome do *client* sempre será o mesmo nome do arquivo de configuração definido no projeto, seguindo de `Client`:

```csharp
var apiClient = new CarterApiClient("https://localhost:5001", httpClient);

```

O nome padrão é `OpenApiClient`.

Note que ele também criou classes equivalentes as consumidas pela api:

```csharp
await apiClient.PostPessoaAsync(new Pessoa{
    Id = 1,
    Nome = "Carlos",
    Idade = 33
});

```

Por fim, o nome dos métodos serão criados de acordo com o atributo `operationId` da operação definida na especificação do OpenAPI:

```json
{
  "openapi": "3.0.1",
  "info": {
    "title": "Carter